Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Conectar un PACS a la API de Cloud Healthcare

En esta página, se explica cómo usar el adaptador de DICOM de API de Cloud Healthcare de Google Kubernetes Engine (GKE) para conectar un sistema de archivo de comunicación y comunicación de imágenes (PACS) a la API de Cloud Healthcare e importa datos de DICOM.

En esta guía, se proporciona una manera 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 archivo README de DICOM en GitHub.

Descripción general

El adaptador puede importar y exportar datos. En esta guía, se muestra cómo importar imágenes de DICOM a un almacén DICOM.

Usa el adaptador de DICOM para traducir datos entre protocolos tradicionales y protocolos RESTful. Por ejemplo, puedes traducir del formato C-STORE al formato STRO-RS.

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 de DICOM, debes elegir o crear un proyecto de Google Cloud y habilitar las API necesarias si completas los pasos siguientes:

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyecto

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

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

    Habilita las API

  5. Espera a que la API 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 viene preinstalado 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 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 habilitadas en una imagen de Docker compilada previamente en Container Registry. Puedes implementar estas imágenes para que se ejecuten en un clúster de GKE.

Cómo crear 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 predeterminado.

Si se completa correctamente, el comando muestra lo siguiente:

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 DICOM.
  • LOCATION es la ubicación en la que se encuentra tu almacén de DICOM.
  • DATASET_ID es el ID del conjunto de datos superior de tu almacén DICOM.
  • DICOM_STORE_ID es el ID para el almacén de DICOM al que importas los datos de DICOM.

Configura el servicio

Para que las aplicaciones fuera del clúster de GKE (como un PACS) puedan acceder al adaptador de DICOM, 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).

Crea un archivo de manifiesto de 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, en el directorio que contiene el archivo de manifiesto de implementación dicom_adapter.yaml, ejecuta el siguiente comando:

kubectl apply -f dicom_adapter.yaml

Si se completa correctamente, el comando muestra lo siguiente:

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 se completa correctamente, el comando muestra lo siguiente:

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

Es posible que la dirección IP LoadBalancer Ingress tarde 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

Para simular tu PACS local, crea una VM de Compute Engine que usarás a fin de 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 debe 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. Haga clic en Crear instancia.

  3. Elige una región y zona para la instancia que coincide con la zona que seleccionaste cuando creaste el clúster. Por ejemplo, si usasteus-central1-a para laCOMPUTE_ZONE cuando creaste el clúster y, en la pantalla de creación de instancias, seleccionaus-central1 (Iowa) para laRegión comous-central1-a para laZona las rutas "a GCP".

  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, selecciona 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.

Según la configuración 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 de DICOM al almacén DICOM

Hay varias opciones de software disponibles que puedes usar para enviar imágenes de DICOM. En las siguientes secciones, usa el kit de herramientas DCMTKDICOM.

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

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

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

    gsutil cp gs://BUCKET/DCM_FILE .
    

    Para usar una imagen de DICOM disponible de forma gratuita de Google Cloud 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 DCMTKDICOM. Cuando ejecutes el comando, configura el título de la entidad de aplicación (AE) en 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 inspeccionaste el servicio.
    • PORT: El puerto usado es 2575.
    • DCMFILE_IN: La ruta de tu sistema de archivos a la imagen DICOM que estás subiendo.
    dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER
    

    Si la solicitud se completa correctamente, la terminal muestra el siguiente resultado cuando se ejecuta 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 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, implementaste de forma correcta el adaptador de DICOM en GKE y enviaste una imagen de DICOM de una instancia de PACS a través del adaptador y a la API de Cloud Healthcare.

Solución de problemas del adaptador

Si el adaptador de DICOM encuentra una falla después de implementarla en GKE, sigue los pasos que se indican en Solución de problemas con 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 PAC y la API de Cloud Healthcare.