InterSystems API Manager (IAM) es un componente clave de la plataforma de datos InterSystems IRIS y ofrece una gestión centralizada de APIs con un fuerte enfoque en la seguridad. IAM simplifica todo el ciclo de vida de las APIs, desde su creación hasta su retirada, y proporciona un portal de desarrolladores para facilitar el descubrimiento y la integración de APIs. Las funciones de control de acceso permiten a los administradores definir permisos precisos, y IAM se integra de forma fluida con la plataforma de datos IRIS, mejorando las capacidades de gestión e integración de datos.

Las características de IAM incluyen:

• Pasarela de APIs: centro centralizado de gestión y seguridad de APIs.
• Gestión del ciclo de vida de las APIs: control completo del ciclo de vida desde la creación hasta la retirada.
• Seguridad: autenticación, autorización y cifrado de datos.
• Supervisión y analítica: herramientas para la supervisión del uso y el análisis de patrones.
• Portal de desarrolladores: portal de descubrimiento de APIs con documentación y pruebas.
• Control de acceso: control granular sobre el acceso y las acciones de las APIs.
• Integración con InterSystems IRIS: integración fluida con la plataforma de datos IRIS.

Caso de uso: El caso de uso en este informe es Gestión de Identidad y Acceso.

Autenticación y autorización siguiendo el estándar OAuth 2.0, asegurando un servidor FHIR mediante IAM.

En este documento aprenderéis cómo asegurar un servidor FHIR con OAuth 2.0 usando InterSystems API Manager. OAuth 2.0 es un estándar ampliamente utilizado para la autorización que permite a las aplicaciones acceder a recursos protegidos en un servidor FHIR. InterSystems API Manager es una herramienta que simplifica la creación, gestión y supervisión de APIs FHIR. Siguiendo los pasos de este documento, podréis configurar InterSystems API Manager para que actúe como servidor de autorización OAuth 2.0 y otorgue tokens de acceso a clientes autorizados. También aprenderéis a usar bibliotecas de cliente para conectar vuestra aplicación al servidor FHIR usando OAuth 2.0.

Nota: el servidor FHIR solo admite tokens JWT para la autenticación OAuth 2.0, no admite tokens opacos.

Instrucciones para ejecutar la demo localmente:

1. Ejecutad el siguiente comando en el Símbolo del sistema para clonar el repositorio correspondiente:

   git clone https://github.com/isc-padhikar/IAM_FHIRServer

2. Entrad en el directorio del repositorio recién clonado, cread un nuevo directorio y llamadlo 'key'. A continuación, copiád un archivo iris.key, que es la licencia de InterSystems IRIS for Health que soporta la gestión de APIs.
3. Luego, volved al Símbolo del sistema y ejecutad los siguientes comandos uno por uno:

   docker-compose build docker-compose up

4. Acceded a localhost:8002, donde está ejecutándose IAM.
5. Usando IAM, puedo poner un servidor FHIR disponible como un servicio, como se ve en la imagen siguiente:
6. Definid una ruta que será el proxy del servidor FHIR (yo he definido /fhir como el proxy), como se muestra en la imagen siguiente:
7. Y definid los plugins que gestionarán las solicitudes entrantes al servidor FHIR, autenticando y autorizando el acceso al servidor FHIR. Debemos definir el emisor del token JWT (el servidor de autorización) y la clave pública que obtenemos al decodificar la clave privada (consultad la sección «Servidor de autorización» que sigue para esta parte), en el plugin JWT, dentro de la sección «Credenciales», como se muestra en las imágenes siguientes:  

Autenticación usando el servidor Auth0 y autorización mediante tokens JWT a través de IAM. Obteniendo un token JWT del servidor de autorización: Usando el token JWT para acceder al servidor FHIR a través de la ruta proxy definida en IAM:

Servidor de autorización:

Se utiliza un servidor de autorización externo, que es Auth0. Las instrucciones para configurar un servidor de autorización se encuentran en el README de la demo #1 (FHIROktaIntegration), mencionada en la próxima sección «Demos usadas como referencia».

Endpoint para obtener el JSON Web Key Set (JWKS): https://dev-bi2i05hvuzmk52dm.au.auth0.com/.well-known/jwks.json

Nos proporciona un par de claves para el servidor de autorización que hemos configurado y que se pueden usar para obtener la clave privada mediante un algoritmo de decodificación.

Usaremos la clave privada en IAM para verificar las firmas de los tokens JWT.

La mejor práctica para obtener la clave pública de un JWKS es usar un lenguaje de programación. Yo utilicé el siguiente código en Python:

import base64
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
import requests
# Replace 'YOUR_DOMAIN' with your actual Auth0 domain
jwks_url = 'https://dev-bi2i05hvuzmk52dm.au.auth0.com/.well-known/jwks.json'
response = requests.get(jwks_url)
jwks = response.json()
# Choose a specific key from the JWKS (e.g., the first key)
selected_key = jwks['keys'][0]
# Decode 'AQAB' (exponent 'e') from Base64 URL-safe to integer
decoded_exponent = int.from_bytes(base64.urlsafe_b64decode(selected_key['e'] + '==='), byteorder='big')
decoded_modulus = int.from_bytes(base64.urlsafe_b64decode(selected_key['n'] + '==='), byteorder='big')
# Construct the RSA public key
public_key = rsa.RSAPublicNumbers(
    decoded_exponent,
    decoded_modulus
).public_key(default_backend())
# Convert the public key to PEM format
public_key_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
print(public_key_pem.decode('utf-8'))

Demos usadas como referencia:

1. FHIROktaIntegration: https://openexchange.intersystems.com/package/FHIROktaIntegration Esta demo muestra cómo configurar OAuth 2.0 directamente en InterSystems IRIS for Health y usar esa configuración para un servidor FHIR. Seguid las instrucciones que incluye para configurar los detalles del servidor de autorización. Sin embargo, las configuraciones se ven así en el portal de administración una vez completadas:
2. Incluye una aplicación Angular que se autentica con el servidor de autorización, con una interfaz que muestra los recursos FHIR tras la autorización. Esto demuestra cómo se puede configurar OAuth 2.0 dentro de InterSystems IRIS for Health para asegurar un servidor FHIR.
3. IAM Zero-to-Hero: https://openexchange.intersystems.com/package/iam-zero-to-hero

La demo está compuesta por IAM y formación relacionada con IAM. La modificaré para incluir un servidor FHIR y usar la instancia de IAM en esta demo para autenticar con el servidor de autorización Auth0 y autorizar el acceso mediante el plugin JWT.

A diferencia de la demo anterior, esta demuestra el uso de IAM para exponer un endpoint de un servidor FHIR y asegurarlo según el estándar OAuth 2.0 usando la biblioteca de plugins que ofrece IAM.

Cambios realizados en esta demo:

1. He añadido un servidor FHIR en la instancia de IRIS for Health de esta demo. Sustituid el código del archivo iris.script por el siguiente código:

;do $System.OBJ.LoadDir("/opt/irisapp/src","ck",,1)
zn "%SYS"
Do ##class(Security.Users).UnExpireUserPasswords("*")
set $namespace="%SYS", name="DefaultSSL" do:'##class(Security.SSLConfigs).Exists(name) ##class(Security.SSLConfigs).Create(name) set url="https://pm.community.intersystems.com/packages/zpm/latest/installer" Do ##class(%Net.URLParser).Parse(url,.comp) set ht = ##class(%Net.HttpRequest).%New(), ht.Server = comp("host"), ht.Port = 443, ht.Https=1, ht.SSLConfiguration=name, st=ht.Get(comp("path")) quit:'st $System.Status.GetErrorText(st) set xml=##class(%File).TempFilename("xml"), tFile = ##class(%Stream.FileBinary).%New(), tFile.Filename = xml do tFile.CopyFromAndSave(ht.HttpResponse.Data) do ht.%Close(), $system.OBJ.Load(xml,"ck") do ##class(%File).Delete(xml)

//init FHIR Server
zn "HSLIB"
set namespace="FHIRSERVER"
Set appKey = "/csp/healthshare/fhirserver/fhir/r4"
Set strategyClass = "HS.FHIRServer.Storage.Json.InteractionsStrategy"
set metadataPackages = $lb("hl7.fhir.r4.core@4.0.1")
set importdir="/opt/irisapp/src"
//Install a Foundation namespace and change to it
Do ##class(HS.Util.Installer.Foundation).Install(namespace)
zn namespace

// Install elements that are required for a FHIR-enabled namespace
Do ##class(HS.FHIRServer.Installer).InstallNamespace()

// Install an instance of a FHIR Service into the current namespace
Do ##class(HS.FHIRServer.Installer).InstallInstance(appKey, strategyClass, metadataPackages)

// Configure FHIR Service instance to accept unauthenticated requests
set strategy = ##class(HS.FHIRServer.API.InteractionsStrategy).GetStrategyForEndpoint(appKey)
set config = strategy.GetServiceConfigData()
set config.DebugMode = 4
do strategy.SaveServiceConfigData(config)

zw ##class(HS.FHIRServer.Tools.DataLoader).SubmitResourceFiles("/opt/irisapp/fhirdata/", "FHIRSERVER", appKey)

zn "USER"
zpm "load /opt/irisbuild/ -v":1:1
zpm 
load /opt/irisapp/ -v
q
do ##class(Sample.Person).AddTestData()
halt

2. En el archivo docker-compose.yml, actualizad la imagen de IAM a la última versión (containers.intersystems.com/intersystems/iam:3.2.1.0-4), porque solo las versiones de IAM (Kong) a partir de la 3.1 soportan JSON draft-6, que es el formato que proporciona la especificación FHIR.