Conecta un PACS a la API de Cloud Healthcare

En esta página, se explica cómo usar la API de Adaptador de DICOM de la API de Cloud Healthcare en Google Kubernetes Engine (GKE) para completar las siguientes tareas:

• Conecta un sistema de archivo y comunicación de imágenes (PACS) a la API de Cloud Healthcare.
• Importa datos de DICOM de PACS a un almacén de DICOM en la API de Cloud Healthcare.

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

Descripción general del adaptador de DICOM

El adaptador consta de dos componentes principales: el adaptador de importación y el adaptador de exportación. En esta guía, se muestra cómo usar el adaptador de importación para almacenar imágenes de DICOM en un almacén de DICOM.

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

Costos

En esta guía, se usan componentes facturables de Google Cloud, incluidos los siguientes:

• API de Cloud Healthcare
• 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

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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

4. Enable the Cloud Healthcare API, Google Kubernetes Engine, and Container Registry APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

7. Enable the Cloud Healthcare API, Google Kubernetes Engine, and Container Registry APIs.

   Enable the APIs

8. Espera a que la API y los servicios relacionados se habiliten. Esto puede tomar varios minutos.
9. Crea un almacén DICOM si aún no lo hiciste.

Elige una shell

Para completar esta guía, usa 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 las siguientes herramientas, que usarás en esta guía:

• CLI de gcloud: Proporciona la interfaz de línea de comandos principal para Google Cloud.
• kubectl: proporciona la interfaz de línea de comandos para ejecutar comandos en clústeres de GKE.

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

Cloud Shell

1. Ve a la consola de Google Cloud.

   Consola de Google Cloud

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

Si prefieres usar tu shell local, debes instalar el gcloud CLI. Consulta Instala Google Cloud CLI para obtener instrucciones.

Implementa el adaptador con Google Kubernetes Engine

El adaptador de importación y el de exportación son aplicaciones alojadas en contenedores en una imagen de Docker compilada con anterioridad en Container Registry. En esta guía, implementarás la imagen dicom-import-adapter para que se ejecute en un clúster de GKE.

Otorga permisos de cuenta de servicio de Compute Engine

Sigue las instrucciones en Crea y habilita cuentas de servicio para instancias a fin de otorgar la función roles/healthcare.dicomEditor a la cuenta de servicio predeterminada de Compute Engine. Para obtener más información, consulta Funciones de la tienda de DICOM.

Nota: Si inicias el clúster de GKE con una cuenta de servicio diferente, otorga la función roles/healthcare.dicomEditor a la otra cuenta de servicio.

Cree el clúster

Nota: El siguiente comando crea un clúster de GKE en la red de VPC predeterminada y usa la cuenta de servicio predeterminada de Compute Engine. Los cambios en la cuenta de servicio o la red pueden afectar otras partes de esta guía. Si cambias la cuenta de servicio o la red de VPC, en esta guía se describen los cambios adicionales que debes realizar.

gcloud

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

Antes de usar cualquiera de los datos de comando a continuación, realiza los siguientes reemplazos:

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

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init o gcloud auth login y gcloud config set project.

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

Windows (PowerShell)

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init o gcloud auth login y gcloud config set project.

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

Windows (cmd.exe)

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init, o gcloud auth login y gcloud config set project.

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

Deberías recibir una respuesta similar a la que figura a continuación:

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.18.16-gke.502   123.456.789.012  n1-standard-1  1.18.16-gke.502  3     RUNNING

Configura la implementación

Cuando implementas una aplicación en GKE, defines las propiedades de los Implementación con un Archivo de manifiesto de la Deployment, que suele ser un archivo YAML. Para obtener información sobre los archivos de manifiesto de Deployment, consulta Crea implementaciones.

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: apps/v1
kind: Deployment
metadata:
  name: dicom-adapter
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dicom-adapter
  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.43
          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"

Reemplaza lo siguiente:

• PROJECT_ID: Es el ID del proyecto.
• LOCATION: Es la ubicación del conjunto de datos.
• DATASET_ID: Es el ID del conjunto de datos superior de tu almacén DICOM.
• DICOM_STORE_ID: Es el ID del almacén de DICOM al que importas datos de DICOM

Configura el servicio:

A fin de 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 del balanceador de cargas te permite exponer de forma interna la DIMSE (en esta guía, el puerto 2575).

Crea un archivo de manifiesto del Servicio para configurar el balanceo de cargas. 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. Crea e implementa el archivo de manifiesto del servicio en Implementa el servicio y el balanceador de cargas interno.

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

Nota: Usa un balanceador de cargas interno solo si accederás al adaptador de DICOM de la misma red de VPC a la que está conectado el clúster de GKE. como se describe en esta página. Si implementas un adaptador DICOM para usarlo desde otros redes, como las locales, borra la línea cloud.google.com/load-balancer-type: "Internal" del archivo que se mostró antes.

Implementa el Deployment

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

kubectl apply -f dicom_adapter.yaml

Este es el resultado:

deployment.apps/dicom-adapter created

Inspecciona el Deployment

Después de crear la implementación, usa 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 ver Pod que creó el objeto Deployment, ejecuta el siguiente comando:

kubectl get pods -l app=dicom-adapter

Si deseas obtener información sobre el Pod creado, ejecuta el siguiente comando con el nombre del Pod que se mostró en el comando anterior:

kubectl describe pod POD_NAME

Si la implementación se realizó de forma correcta, la última parte del resultado del comando anterior contiene la siguiente información: El adaptador está listo para entregar solicitudes cuando el contenedor dicom-import-adapter tenga el valor Started en la columna Reason.

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.43"
  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.43"
  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 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

Este es el resultado:

service/dicom-adapter-load-balancer created

Inspecciona el servicio

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

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

kubectl describe service dicom-adapter-load-balancer

Este es el resultado:

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. Guarda la dirección IP LoadBalancer Ingress. En la siguiente sección, deberás usarlo para acceder al servicio desde fuera del clúster.

Crear una máquina virtual de Compute Engine

Para simular tus PACS locales, crea una VM de Compute Engine 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 deben estar en la misma región y usar la misma red de VPC.

Completa los siguientes pasos para crear una instancia de máquina virtual de Linux en Compute Engine:

Consola

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

   Ir a Instancias de VM

2. Haz clic en Crear instancia.

3. Elige una región y una zona para la instancia que coincide con la zona que seleccionaste cuando creaste el clúster. Por ejemplo, si usaste us-central1-a para COMPUTE_ZONE cuando creaste el clúster, selecciona us-central1 (Iowa) para la Región y us-central1-a para la Zona.

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

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

6. Haz 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

Ejecuta el comando gcloud compute instances create. El comando usa la etiqueta http-server para permitir el tráfico HTTP.

Antes de usar cualquiera de los datos de comando a continuación, realiza los siguientes reemplazos:

• PROJECT_IDEl ID de tu proyecto de Google Cloud.
• COMPUTE_ZONE: la zona que seleccionaste cuando creaste el clúster.
• INSTANCE_NAME: nombre de la VM

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init o gcloud auth login y gcloud config set project.

gcloud compute instances create INSTANCE_NAME \
  --project=PROJECT_ID \
  --zone=COMPUTE_ZONE \
  --image-family=debian-9 \
  --image-project=debian-cloud \
  --tags=http-server

Windows (PowerShell)

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init o gcloud auth login y gcloud config set project.

gcloud compute instances create INSTANCE_NAME `
  --project=PROJECT_ID `
  --zone=COMPUTE_ZONE `
  --image-family=debian-9 `
  --image-project=debian-cloud `
  --tags=http-server

Windows (cmd.exe)

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init, o gcloud auth login y gcloud config set project.

gcloud compute instances create INSTANCE_NAME ^
  --project=PROJECT_ID ^
  --zone=COMPUTE_ZONE ^
  --image-family=debian-9 ^
  --image-project=debian-cloud ^
  --tags=http-server

Deberías recibir una respuesta similar a la que figura a continuación:

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 y el clúster usan la red de VPC predeterminada, lo que significa que el tráfico se puede enviar desde la instancia al clúster. Si el clúster de GKE en el que se ejecuta el adaptador de DICOM se creó en una red de VPC diferente, realiza una de las siguientes acciones:

• Cambia el procedimiento anterior para iniciar la VM en la diferente red de VPC.
• Quita la anotación cloud.google.com/load-balancer-type: "Internal" de la definición del servicio del balanceador de cargas.

Conéctate a la VM.

Para conectarte a la VM, completa los siguientes pasos:

Consola

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

   Ir a 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

Ejecuta el comando gcloud compute ssh.

Antes de usar cualquiera de los datos de comando a continuación, realiza los siguientes reemplazos:

• PROJECT_IDEl ID de tu proyecto de Google Cloud.
• COMPUTE_ZONE: la zona de la VM
• INSTANCE_NAME: El nombre de la VM

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init o gcloud auth login y gcloud config set project.

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

Windows (PowerShell)

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init o gcloud auth login y gcloud config set project.

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

Windows (cmd.exe)

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init, o gcloud auth login y gcloud config set project.

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 de DICOM

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

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 DICOM de DCMTK:

   sudo apt-get install -y dcmtk
   

2. Guarda la imagen de DICOM en la VM. Por ejemplo, si la imagen de DICOM se almacena en un bucket de Cloud Storage, ejecuta el siguiente comando para descargarlo en tu directorio de trabajo actual:

   gcloud storage cp gs://BUCKET/DCM_FILE .

   Para usar una imagen de DICOM que Google Cloud pone a disposición desde el conjunto de datos gcs-public-data--healthcare-tcia-lidc-idri, ejecuta el siguiente comando:

   gcloud storage 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 . --billing-project=PROJECT_ID

3. Ejecuta dcmsend. que está disponible a través del kit de herramientas DCMTK DICOM. Cuando ejecutes el comando, configura el título de la entidad de la aplicación (AE) como IMPORTADAPTER. De forma opcional, puedes agregar la marca --verbose para mostrar los detalles del procesamiento. El puerto que se usa en esta guía es el 2575.

   dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER

   Reemplaza lo siguiente:

   • PEER: Es la dirección IP LoadBalancer Ingress que se mostró cuando inspeccionaste el servicio.
   • DCMFILE_IN: Es la ruta de acceso a la imagen de DICOM en la VM.

   Cuando ejecutas dcmsend con una sola imagen de DICOM, el resultado es el siguiente:

   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 haya importado de forma correcta 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, implementaste correctamente el adaptador de DICOM en GKE y enviaste una imagen de DICOM desde una instancia de PACS a través del adaptador a la API de Cloud Healthcare.

Solucionar problemas

Solución de problemas de GKE

Si el adaptador DICOM encuentra una falla después de implementarla en GKE, sigue los pasos en Soluciona problemas con cargas de trabajo implementadas.

Solución de problemas del adaptador

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 la consola de Google Cloud o Herramienta kubectl:

Consola

1. Ve al panel Cargas de trabajo de GKE en la consola de Google Cloud.

   Ve a 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 comienza con dicom-adapter.

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

kubectl logs POD_NAME

Si perdiste alguno de los pasos de esta guía, es posible que el comando dcmsend no suba imágenes. A fin de investigar este problema, vuelve a ejecutar el comando con la marca -d (para “depurar”). La marca imprime un registro más detallado de las acciones, incluidos los mensajes que proporcionan información sobre la falla.

Solución de problemas de permisos y autorización

En las siguientes secciones, se describen errores que pueden ocurrir en dcmsend cuando los permisos o las autorizaciones están configurados de forma incorrecta.

Nota: Es posible que los mensajes de error no se muestren al final del resultado de dcmsend. Debes analizar todo el resultado de dcmsend para buscar los siguientes mensajes de error.

Error de asociación anulado de pares

El siguiente problema ocurre cuando el tráfico de red no puede fluir desde PACS al puerto 2575 del balanceador de cargas:

cannot send SOP instance: Peer aborted Association (or never connected)

Para resolver este problema, asegúrate de que la VM de PACS y el clúster de GKE se ejecuten en la misma red de VPC. Si no se ejecutan en la misma red de VPC, verifica lo siguiente:

• El balanceador de cargas no está configurado como “interno”.
• No hay reglas de firewall que bloqueen las conexiones al puerto 2575.

Este error también puede ocurrir cuando el servicio del balanceador de cargas o el Pod del adaptador no están configurados de forma correcta en el clúster de GKE. Para asegurarte de que estén configurados de forma correcta, consulta Inspecciona la implementación e Inspecciona el servicio en esta guía.

Error las API obligatorias no están habilitadas

El siguiente problema se produce cuando la API de Cloud Healthcare no se habilitó en el proyecto en el que se ejecuta el clúster de GKE con el adaptador:

LO [Http_403, PERMISSION_DENIED, Cloud Healthcare API has not been u]

Para resolver este problema, asegúrate de que todas las API necesarias estén habilitadas mediante las instrucciones que se indican en Antes de comenzar.

Error de permiso insuficiente

El siguiente problema ocurre cuando el clúster de GKE en el que se ejecuta el adaptador no tiene configurado el valor de permiso correcto:

LO [Http_403, PERMISSION_DENIED, Request had insufficient authentica]

Para resolver este problema, actualiza el clúster de GKE o crea uno nuevo con la siguiente marca:

--scopes=https://www.googleapis.com/auth/cloud-healthcare

Error de permiso de almacenamiento de DICOM denegado

El siguiente error ocurre cuando la cuenta de servicio que usa el clúster de GKE en el que se ejecuta el adaptador no tiene la función roles/healthcare.dicomEditor:

LO [Http_403, PERMISSION_DENIED, Permission healthcare.dicomStores.d]

Para resolver este problema, sigue las instrucciones en Otorga permisos de cuenta de servicio de Compute Engine.

¿Qué sigue?

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