Conectar un PACS a la API de Cloud Healthcare

En esta página, se explica cómo usar el adaptador DICOM de la API de Cloud Healthcare de código abierto en Google Kubernetes Engine (GKE) para conectar un Sistema de archivado y comunicación de imágenes (PACS) al API de Cloud Healthcare y, además, importa datos de DICOM.

En esta guía, se proporciona una forma sencilla de configurar un prototipo con Google Kubernetes Engine y una máquina virtual (VM) de Compute Engine. La VM de Compute Engine simula el PACS local. Para obtener información más detallada, consulta el adaptador del README de DICOM en GitHub.

Descripción general

El adaptador DICOM proporciona un conjunto de componentes que pueden traducir datos entre protocolos DICOM DIMSE tradicionales (como C-STORE) y los protocolos DICOMweb RESTful (como STOW-RS). El adaptador consta de dos componentes principales: el adaptador de importación y el de exportación. En esta guía, se usa el adaptador de importación para importar imágenes DICOM a un almacén DICOM.

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

  • Cloud Healthcare API
  • Google Kubernetes Engine
  • Compute Engine

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Los usuarios nuevos de Cloud Platform pueden optar por una prueba gratuita.

Antes de comenzar

Antes de configurar el adaptador DICOM, debes elegir o crear un proyecto de Google Cloud y habilitar las API necesarias si completas los siguientes pasos:

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  4. Habilita las API de Cloud Healthcare API, Google Kubernetes Engine, and Container Registry.

    Habilita las API

  5. Espera a que la API de GKE y los servicios relacionados se habiliten. Esto puede tomar varios minutos.

Elige un shell

Para completar este instructivo, puedes usar Cloud Shell o tu shell local.

Cloud Shell es un entorno de shell que se usa para administrar recursos alojados en Google Cloud. Cloud Shell ya viene instalado con la herramienta de gcloud y la herramienta kubectl. La herramienta de gcloud proporciona la interfaz de línea de comandos principal para GCP. kubectl proporciona la interfaz de línea de comandos para ejecutar comandos con clústeres de GKE.

Si prefieres usar tu shell local, debes instalar el SDK de Cloud, que incluye la herramienta gcloud y la herramienta kubectl.

Para abrir Cloud Shell o configurar tu shell local, completa los siguientes pasos:

Cloud Shell

Para iniciar Cloud Shell, sigue estos pasos:

  1. Ve a Google Cloud Console

    Google Cloud Console

  2. En la esquina superior derecha de la consola, haz clic en el botón Activar Google Cloud Shell:

Se abrirá una sesión de Cloud Shell dentro de un marco en la parte inferior de la consola. Usa este shell para ejecutar los comandos gcloud y kubectl.

Shell local

Para instalar la herramienta gcloud y la herramienta kubectl, instala y, luego, inicializa la versión más reciente del SDK de Cloud.

Crea una tienda de DICOM

Antes de usar el adaptador de DICOM, debes crear un almacén de DICOM si aún no lo hiciste.

Implementa el adaptador con Google Kubernetes Engine

El adaptador de importación y el adaptador de exportación son aplicaciones en contenedores distribuidas en una imagen de Docker compilada con anterioridad en Container Registry. Puedes implementar estas imágenes para que se ejecuten en un clúster de GKE.

Crea el clúster

Para crear un clúster en GKE llamado dicom-adapter, ejecuta el comando gcloud container clusters create:

gcloud container clusters create dicom-adapter \
    --zone=COMPUTE_ZONE \
    --scopes=https://www.googleapis.com/auth/cloud-healthcare

Donde:

  • COMPUTE_ZONE es la zona en la que se implementa tu clúster. Una zona es una ubicación regional aproximada en la que se implementan tus clústeres y sus recursos. Por ejemplo, us-west1-a es una zona en la región us-west. Si estableciste una zona predeterminada con gcloud config set compute/zone, el valor de esta marca anula el valor predeterminado.

Si se ejecuta de forma correcta, el comando mostrará la siguiente respuesta:

Creating cluster dicom-adapter in COMPUTE_ZONE... Cluster is being health-checked (master is healthy)...done.
Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/COMPUTE_ZONE/clusters/dicom-adapter].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/COMPUTE_ZONE/dicom-adapter?project=PROJECT_ID
kubeconfig entry generated for dicom-adapter.
NAME           LOCATION    MASTER_VERSION  MASTER_IP        MACHINE_TYPE   NODE_VERSION   NUM_NODES  STATUS
dicom-adapter  COMPUTE_ZONE  1.15.12-gke.2   123.456.789.012  n1-standard-1  1.15.12-gke.2  3          RUNNING

Configura la implementación

Cuando implementas una aplicación en GKE, debes definir propiedades de la implementación mediante un archivo de manifiesto de implementación, que suele ser un archivo YAML.

Con un editor de texto, crea un archivo de manifiesto de implementación para el adaptador de importación llamado dicom_adapter.yaml con el siguiente contenido:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: dicom-adapter
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: dicom-adapter
    spec:
      containers:
        - name: dicom-import-adapter
          image: gcr.io/cloud-healthcare-containers/healthcare-api-dicom-dicomweb-adapter-import:0.2.1
          ports:
            - containerPort: 2575
              protocol: TCP
              name: "port"
          args:
            - "--dimse_aet=IMPORTADAPTER"
            - "--dimse_port=2575"
            - "--dicomweb_address=https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID/dicomWeb"

Donde:

  • PROJECT_ID es el ID del proyecto de Google Cloud que contiene tu almacén de DICOM.
  • LOCATION es la ubicación en la que se encuentra el almacén DICOM.
  • DATASET_ID es el ID del conjunto de datos principal del almacén de DICOM.
  • DICOM_STORE_ID es el ID para el almacén de DICOM en el que importas datos de DICOM.

Configura el servicio

Para que el adaptador de DICOM sea accesible para las aplicaciones fuera del clúster de GKE (como un PACS), debes configurar un balanceador de cargas interno. El balanceador de cargas te permite exponer internamente el puerto DIMSE (en esta guía, el puerto 2575).

Cree un archivo de manifiesto del servicio para configurar el balanceo de cargas interno. En el directorio en el que creaste el archivo de manifiesto de implementación, usa un editor de texto para crear un archivo llamado dicom_adapter_load_balancer.yaml con el siguiente contenido:

apiVersion: v1
kind: Service
metadata:
  name: dicom-adapter-load-balancer
  # The "Internal" annotation will result in an load balancer that can only
  # be accessed from within the VPC the Kubernetes cluster is in.
  # You can remove this annotation to get an externally accessible load balancer.
  annotations:
    cloud.google.com/load-balancer-type: "Internal"
spec:
  ports:
  - port: 2575
    targetPort: 2575
    protocol: TCP
    name: port
  selector:
    app: dicom-adapter
  type: LoadBalancer

Implementa la implementación

Para implementar el adaptador en un clúster de GKE, ejecuta el siguiente comando en el directorio que contiene el archivo de manifiesto de implementación dicom_adapter.yaml:

kubectl apply -f dicom_adapter.yaml

Si no hay errores, el comando mostrará el siguiente resultado:

deployment.extensions "dicom-adapter-deployment" created

Inspecciona la implementación

Después de crear la implementación, puedes usar la herramienta de kubectl para inspeccionarla.

Para obtener información detallada sobre la implementación, ejecuta el siguiente comando:

kubectl describe deployment dicom-adapter

Para enumerar el Pod creado por la implementación, ejecuta el siguiente comando:

kubectl get pods -l app=dicom-adapter

Para obtener información sobre el Pod creado, sigue estos pasos:

kubectl describe pod POD_NAME

Si la implementación se realizó de forma correcta, la última parte del resultado del comando anterior debe contener la siguiente información:

Events:
  Type    Reason     Age    From                                                   Message
  ----    ------     ----   ----                                                   -------
  Normal  Scheduled  3m33s  default-scheduler                                      Successfully assigned default/dicom-adapter-69d579778-qrm7n to gke-dicom-adapter-default-pool-6f6e0dcd-9cdd
  Normal  Pulling    3m31s  kubelet, gke-dicom-adapter-default-pool-6f6e0dcd-9cdd  Pulling image "gcr.io/cloud-healthcare-containers/healthcare-api-dicom-dicomweb-adapter-import:0.2.1"
  Normal  Pulled     3m10s  kubelet, gke-dicom-adapter-default-pool-6f6e0dcd-9cdd  Successfully pulled image "gcr.io/cloud-healthcare-containers/healthcare-api-dicom-dicomweb-adapter-import:0.2.1"
  Normal  Created    3m7s   kubelet, gke-dicom-adapter-default-pool-6f6e0dcd-9cdd  Created container dicom-import-adapter
  Normal  Started    3m7s   kubelet, gke-dicom-adapter-default-pool-6f6e0dcd-9cdd  Started container dicom-import-adapter

Implementa el servicio y crea el balanceador de cargas interno

Para crear el balanceador de cargas interno, en el directorio que contiene el archivo de manifiesto del Service dicom_adapter_load_balancer.yaml, ejecuta el siguiente comando:

kubectl apply -f dicom_adapter_load_balancer.yaml

Si no hay errores, el comando mostrará el siguiente resultado:

deployment.extensions "dicom_adapter_load_balancer.yaml" created

Inspecciona el servicio

Después de crear el servicio, inspecciónalo para verificar que se haya configurado correctamente.

Para inspeccionar el balanceador de cargas interno, ejecuta el siguiente comando:

kubectl describe service dicom-adapter-load-balancer

Si no hay errores, el comando mostrará un resultado similar al siguiente:

Name:                     dicom-adapter-load-balancer
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/load-balancer-type: Internal
Selector:                 app=dicom-adapter
Type:                     LoadBalancer
IP:                       198.51.100.1
LoadBalancer Ingress:     203.0.113.1
Port:                     port  2575/TCP
TargetPort:               2575/TCP
NodePort:                 port  30440/TCP
Endpoints:                192.0.2.1:2575
Session Affinity:         None
External Traffic Policy:  Cluster
Events:

Events:
  Type    Reason                Age   From                Message
  ----    ------                ----  ----                -------
  Normal  EnsuringLoadBalancer  1m    service-controller  Ensuring load balancer
  Normal  EnsuredLoadBalancer   1m    service-controller  Ensured load balancer

La dirección IP de LoadBalancer Ingress puede tardar hasta un minuto en propagarse. Copia la dirección IP LoadBalancer Ingress porque la usarás y el puerto 2575 para acceder al servicio desde fuera del clúster en la siguiente sección.

Crea una máquina virtual de Compute Engine

Si deseas simular tu PACS local, crea una VM de Compute Engine que usarás para enviar solicitudes al adaptador de DICOM. Debido a que implementaste un balanceador de cargas interno, la VM que creas y el clúster de GKE existente deben estar en la misma región y usar la misma red de VPC.

En los siguientes pasos, se muestra cómo crear una instancia de máquina virtual de Linux en Compute Engine:

Console

  1. En Cloud Console, ve a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. Haz clic en Crear instancia.

  3. Elige una Región y una Zona para la instancia que coincida con la zona que seleccionaste cuando creaste el clúster. Por ejemplo, si usaste us-central1-a para la COMPUTE_ZONE cuando creaste el clúster, en la pantalla de creación de instancias, selecciona us-central1 (Iowa) para la Región como us-central1-a para la función Zona para crear el adjunto de VLAN de supervisión.

  4. En la sección Disco de arranque, haz clic en Cambiar para configurar el disco de arranque.

  5. En la pestaña Imágenes públicas, elige la versión 9 del sistema operativo Debian.

  6. Haga clic en Seleccionar.

  7. En la sección Firewall, selecciona Permitir el tráfico HTTP.

  8. Haga clic en Crear para crear la instancia.

gcloud

Para crear una instancia de procesamiento, ejecuta el método gcloud compute instances create con las siguientes opciones:

  • La COMPUTE_ZONE que seleccionaste cuando creaste el clúster
  • La etiqueta http-server para permitir el tráfico HTTP
gcloud compute instances create INSTANCE_NAME \
   --project=PROJECT_ID \
   --zone=COMPUTE_ZONE \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --tags=http-server

El resultado es similar al siguiente ejemplo:

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/COMPUTE_ZONE/instances/INSTANCE_NAME].
NAME          ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
INSTANCE_NAME  COMPUTE_ZONE           n1-standard-1               INTERNAL_IP  EXTERNAL_IP    RUNNING

La instancia tardará unos momentos en iniciarse. Una vez que se inicia la instancia, se mostrará en la página Instancias de VM con un ícono de estado verde.

De forma predeterminada, la instancia usa la red de VPC predeterminada que usa el clúster, lo que significa que el tráfico se puede enviar desde la instancia al clúster.

Para conectarte a la instancia, completa los siguientes pasos:

Console

  1. En Cloud Console, ve a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. En la lista de instancias de máquina virtual, haz clic en SSH en la fila de la instancia que creaste.

gcloud

Para conectarte a la instancia, ejecuta el comando gcloud compute ssh:

gcloud compute ssh INSTANCE_NAME \
    --project PROJECT_ID \
    --zone COMPUTE_ZONE

Ahora tienes una ventana de la terminal para interactuar con tu instancia de Linux.

Importa imágenes DICOM al almacén DICOM

Hay varias opciones de software disponibles que puedes usar para enviar imágenes de DICOM en una red. En las secciones siguientes, usarás el kit de herramientas DCMTK DICOM.

Para importar imágenes de DICOM a tu almacén DICOM, completa los siguientes pasos desde la VM que creaste en la sección anterior:

  1. Instala el software del kit de herramientas DCMTK DICOM:

    sudo apt install dcmtk
    
  2. Sube la imagen de DICOM que deseas importar a tu almacén de DICOM a la VM. Por ejemplo, si la imagen de DICOM se almacena en un depósito de Cloud Storage, podrías ejecutar el siguiente comando para descargarla en tu directorio de trabajo actual:

    gsutil cp gs://BUCKET/DCM_FILE .
    

    Para usar una imagen de DICOM que Google Cloud proporciona de forma gratuita desde el conjunto de datos gcs-public-data--healthcare-tcia-lidc-idri, ejecuta el siguiente comando:

    gsutil -u PROJECT_ID cp gs://gcs-public-data--healthcare-tcia-lidc-idri/dicom/1.3.6.1.4.1.14519.5.2.1.6279.6001.100036212881370097961774473021/1.3.6.1.4.1.14519.5.2.1.6279.6001.130765375502800983459674173881/1.3.6.1.4.1.14519.5.2.1.6279.6001.100395847981751414562031366859.dcm .
    
  3. Ejecuta el comando dcmsend, que está disponible a través del kit de herramientas DICOM de DCMTK. Cuando ejecutes el comando, establece el título de la entidad de aplicación (AE) como IMPORTADAPTER. De forma opcional, puedes agregar la marca --verbose para mostrar los detalles de procesamiento. Antes de enviar la solicitud, realiza los siguientes reemplazos:

    • PEER: la dirección IP LoadBalancer Ingress que se mostró cuando inspeccionó el servicio.
    • PORT: El puerto que se usa es 2575.
    • DCMFILE_IN: La ruta de acceso del sistema de archivos a la imagen de DICOM que estás subiendo.
    dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER
    

    Si la solicitud se realiza de forma correcta, la terminal muestra el siguiente resultado cuando ejecutas dcmsend con una sola imagen de DICOM:

    I: checking input files ...
    I: starting association #1
    I: initializing network ...
    I: negotiating network association ...
    I: Requesting Association
    I: Association Accepted (Max Send PDV: 16366)
    I: sending SOP instances ...
    I: Sending C-STORE Request (MsgID 1, MR)
    I: Received C-STORE Response (Success)
    I: Releasing Association
    I:
    I: Status Summary
    I: --------------
    I: Number of associations   : 1
    I: Number of pres. contexts : 1
    I: Number of SOP instances  : 1
    I: - sent to the peer       : 1
    I:   * with status SUCCESS  : 1
    
  4. Para verificar que la imagen de DICOM se importó correctamente a tu almacén de DICOM, busca instancias en el almacén de DICOM y asegúrate de que la imagen de DICOM nueva esté en el almacén.

Después de completar esta sección, has implementado con éxito el adaptador DICOM a GKE y enviaste una imagen de DICOM desde una instancia de PACS a través del adaptador y a la API de Cloud Healthcare.

Solución de problemas de fallas del adaptador

Si el adaptador DICOM experimenta una falla después de implementarlo en GKE, sigue los pasos en Solucionar problemas en las cargas de trabajo implementadas.

Los adaptadores de importación y exportación generan registros que puedes usar para diagnosticar cualquier problema. Cuando ejecutas un adaptador con GKE, los registros se almacenan en Cloud Logging. Para ver los registros, completa los siguientes pasos con Google Cloud Console o la herramienta de kubectl:

Console

  1. Visita el panel Cargas de trabajo de GKE en Cloud Console.

    Visitar el panel Cargas de trabajo de GKE

  2. Selecciona la carga de trabajo dicom-adapter.

  3. En la página Detalles de la implementación, haz clic en Registros de contenedores.

kubectl

Para ver todos los pods en ejecución en tu clúster, ejecuta el comando siguiente:

kubectl get pods

Busca el pod cuyo nombre comience con dicom-adapter.

Para obtener los registros del pod, ejecuta el siguiente comando:

kubectl logs POD_NAME

¿Qué sigue?

Después de configurar el prototipo en esta guía, puedes comenzar a usar Cloud VPN para encriptar el tráfico entre tu PACS y la API de Cloud Healthcare.