Connecter un PACS à l'API Cloud Healthcare

Cette page explique comment utiliser l'adaptateur DICOM de l'API Cloud Healthcare sur Google Kubernetes Engine (GKE) pour effectuer les tâches suivantes:

• Connecter un système d'archivage et de transmission d'images (PACS, picture archiving and communication system) à l'API Cloud Healthcare.
• Importer des données DICOM depuis PACS vers un magasin DICOM dans l'API Cloud Healthcare.

Ce guide constitue un moyen simple de configurer un prototype à l'aide de Google Kubernetes Engine et d'une machine virtuelle (VM) Compute Engine. La VM Compute Engine simule le PACS sur site. Pour en savoir plus, consultez le fichier README de l'adaptateur DICOM.

Présentation de l'adaptateur DICOM

L'adaptateur comprend deux composants principaux : l'adaptateur d'importation et l'adaptateur d'exportation. Ce guide explique comment utiliser l'adaptateur d'importation pour stocker des images DICOM dans un magasin DICOM.

Utilisez l'adaptateur DICOM pour traduire des données entre les protocoles traditionnels et les protocoles RESTful. Par exemple, vous pouvez traduire du format C-STORE vers le format STOW-RS.

Coûts

Ce guide utilise des composants facturables de Google Cloud, y compris :

• API Cloud Healthcare
• Google Kubernetes Engine
• Compute Engine

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Cloud Platform peuvent bénéficier d'un essai gratuit.

Avant de commencer

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

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.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

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

   Enable the APIs

8. Patientez le temps de l'activation de l'API GKE et des services associés. Cette opération peut prendre plusieurs minutes.
9. Créez un magasin DICOM si vous ne l'avez pas déjà fait.

Choisir une interface système

Pour suivre ce guide, utilisez Cloud Shell ou votre shell local.

Cloud Shell est un environnement shell permettant de gérer les ressources hébergées sur Google Cloud. Cloud Shell est préinstallé sur les outils suivants, que vous utilisez dans le présent guide :

• gcloud CLI : fournit l'interface de ligne de commande principale pour Google Cloud.
• kubectl: fournit une interface de ligne de commande permettant d'exécuter des commandes sur des clusters GKE.

Pour ouvrir Cloud Shell ou configurer votre interface système locale, procédez comme suit :

Déployer l'adaptateur à l'aide de Google Kubernetes Engine

Les adaptateurs d'importation et d'exportation sont des applications en conteneurs stockées dans une image Docker prédéfinie dans Container Registry. Dans ce guide, vous déployez l'image dicom-import-adapter pour l'exécuter sur un cluster GKE.

Accorder des autorisations au compte de service Compute Engine

Suivez les instructions de la section Créer et activer des comptes de service pour les instances afin d'accorder le rôle roles/healthcare.dicomEditor au compte de service Compute Engine par défaut. Pour en savoir plus, consultez la section Rôles de magasin DICOM.

Créer le cluster

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

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

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

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

Configurer le déploiement

Lors du déploiement d'une application sur GKE, vous définissez les propriétés du déploiement à l'aide d'un fichier manifeste de déploiement, qui est généralement un fichier YAML. Pour plus d'informations sur les fichiers manifestes de déploiement, consultez la section Créer des déploiements.

À l'aide d'un éditeur de texte, créez un fichier manifeste de déploiement pour l'adaptateur d'importation appelé dicom_adapter.yaml avec le contenu suivant :

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"

Remplacez les éléments suivants :

• PROJECT_ID : ID du projet
• LOCATION : emplacement de l'ensemble de données
• DATASET_ID : ID de l'ensemble de données parent de votre magasin DICOM
• DICOM_STORE_ID : ID du magasin DICOM dans lequel vous importez des données DICOM

Configurer le service

Pour rendre l'adaptateur DICOM accessible aux applications extérieures au cluster GKE (telles qu'un PACS), vous devez configurer un équilibreur de charge interne. L'équilibreur de charge vous permet d'exposer en interne le port DIMSE (dans ce guide, le port 2575).

Créez un fichier manifeste de service pour configurer l'équilibrage de charge. Dans le répertoire dans lequel vous avez créé le fichier manifeste de déploiement, utilisez un éditeur de texte pour créer un fichier nommé dicom_adapter_load_balancer.yaml avec le contenu suivant. Vous créez et déployez le fichier manifeste de service dans la section Déployer le service et l'équilibreur de charge interne.

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

Déployer

Pour déployer l'adaptateur sur un cluster GKE, exécutez la commande suivante dans le répertoire contenant le fichier manifeste de déploiement dicom_adapter.yaml :

kubectl apply -f dicom_adapter.yaml

Le résultat est le suivant :

deployment.apps/dicom-adapter created

Inspecter le déploiement

Une fois le déploiement créé, utilisez l'outil kubectl pour l'inspecter.

Pour obtenir des informations détaillées sur le déploiement, exécutez la commande suivante :

kubectl describe deployment dicom-adapter

Pour afficher le pod créé par le déploiement, exécutez la commande suivante:

kubectl get pods -l app=dicom-adapter

Pour obtenir des informations sur le pod créé, exécutez la commande suivante en utilisant le nom du pod renvoyé par la commande précédente :

kubectl describe pod POD_NAME

Si le déploiement a réussi, la dernière partie du résultat de la commande précédente contient les informations suivantes : L'adaptateur est prêt à diffuser des requêtes lorsque la valeur de Started est indiquée dans la colonne Reason du conteneur dicom-import-adapter.

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

Déployer le service et l'équilibreur de charge interne

Pour créer l'équilibreur de charge interne, exécutez la commande suivante dans le répertoire contenant le fichier manifeste du service dicom_adapter_load_balancer.yaml :

kubectl apply -f dicom_adapter_load_balancer.yaml

Le résultat est le suivant :

service/dicom-adapter-load-balancer created

Inspecter le service

Une fois le service créé, inspectez-le pour vérifier qu'il a été configuré correctement.

Pour inspecter l'équilibreur de charge, exécutez la commande suivante :

kubectl describe service dicom-adapter-load-balancer

Le résultat est le suivant :

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

Le remplissage de l'adresse IP LoadBalancer Ingress peut prendre jusqu'à une minute. Enregistrez l'adresse IP LoadBalancer Ingress. Vous l'utiliserez pour accéder au service en dehors du cluster dans la section suivante.

Créer une machine virtuelle Compute Engine

Pour simuler votre PACS sur site, créez une VM Compute Engine afin d'envoyer des requêtes à l'adaptateur DICOM. Parce que vous avez déployé un équilibreur de charge interne, la VM que vous créez et le cluster GKE existant doivent être dans la même région et utiliser le même réseau VPC.

Pour créer une instance de machine virtuelle Linux dans Compute Engine, procédez comme suit :

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

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

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

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

Patientez un court instant le temps que l'instance démarre. Une fois l'instance démarrée, elle est répertoriée sur la page "Instances de VM" avec une icône d'état verte.

Se connecter à la VM

Pour vous connecter à la VM, procédez comme suit :

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

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

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

Vous disposez maintenant d'une fenêtre de terminal pour interagir avec votre instance Linux.

Importer des images DICOM dans le magasin DICOM

Plusieurs options logicielles sont à votre disposition pour envoyer des images DICOM sur un réseau. Dans les sections suivantes, vous allez utiliser la suite d'outils DICOM DCMTK.

Pour importer des images DICOM dans votre magasin DICOM, procédez comme suit à partir de la VM que vous avez créée dans la section précédente :

1. Installez le logiciel de la suite d'outils DICOM DCMTK :

   sudo apt-get install -y dcmtk
   

2. Enregistrez l'image DICOM sur la VM. Par exemple, si l'image DICOM est stockée dans un bucket Cloud Storage, exécutez la commande suivante pour la télécharger dans votre répertoire de travail actuel :

   gcloud storage cp gs://BUCKET/DCM_FILE .

   Pour utiliser une image DICOM mise à disposition gratuitement par Google Cloud à partir de l'ensemble de données gcs-public-data--healthcare-tcia-lidc-idri, exécutez la commande suivante :

   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. Exécutez la commande dcmsend, qui est disponible dans la suite d'outils DICOM DCMTK. Lorsque vous exécutez la commande, définissez le titre AE (Application Entity) sur IMPORTADAPTER. Vous pouvez éventuellement ajouter l'option --verbose pour afficher les détails du traitement. Le port utilisé dans ce guide est le port 2575.

   dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER

   Remplacez les éléments suivants :

   • PEER : adresse IP LoadBalancer Ingress qui a été renvoyée lors de l'inspection du service
   • DCMFILE_IN : chemin d'accès à l'image DICOM sur la VM

   Lors de l'exécution de dcmsend avec une seule image DICOM, le résultat est le suivant :

   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. Pour vérifier que l'image DICOM a bien été importée dans votre magasin DICOM, recherchez des instances dans le magasin DICOM et assurez-vous que la nouvelle image DICOM se trouve dans le magasin.

Une fois cette section terminée, vous avez déployé l'adaptateur DICOM sur GKE et envoyé une image DICOM d'une instance PACS vers l'API Cloud Healthcare via l'adaptateur.

Résoudre les problèmes

Dépannage de GKE

Si l'adaptateur DICOM rencontre un échec après son déploiement sur GKE, suivez les étapes décrites dans la section Résoudre les problèmes liés aux charges de travail déployées.

Dépannage de l'adaptateur

Les adaptateurs d'importation et d'exportation génèrent des journaux qui vous permettront de diagnostiquer les éventuels problèmes. Lorsque vous exécutez un adaptateur à l'aide de GKE, les journaux sont stockés dans Cloud Logging. Pour afficher les journaux, complétez les étapes suivantes à l'aide de Google Cloud Console ou de l'outil kubectl:

kubectl get pods

kubectl logs POD_NAME

Si vous avez omis l'une des étapes du présent guide, la commande dcmsend peut échouer à importer des images. Pour examiner ce problème, exécutez à nouveau la commande avec l'option -d (pour "debug"). L'option affiche un journal des actions plus détaillé et incluant des messages qui fournissent des informations sur l'échec.

Dépannage des autorisations

Les sections suivantes décrivent les erreurs pouvant survenir dans dcmsend lorsque les autorisations sont mal configurées.

Erreur d'association annulée par le pair

Le problème suivant se produit lorsque le trafic réseau ne peut pas passer du PACS au port 2575 de l'équilibreur de charge :

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

Pour résoudre ce problème, assurez-vous que la VM PACS et le cluster GKE s'exécutent sur le même réseau VPC. S'ils ne s'exécutent pas sur le même réseau VPC, vérifiez les points suivants :

• L'équilibreur de charge n'est pas configuré en tant qu'"interne".
• Aucune règle de pare-feu ne bloque les connexions au port 2575.

Cette erreur peut également se produire lorsque le service d'équilibrage de charge ou le pod de l'adaptateur ne sont pas correctement configurés dans le cluster GKE. Pour vous assurer qu'ils sont correctement configurés, consultez les pages Inspecter le déploiement et Inspecter le service du présent guide.

Erreur d'API requises non activées

Le problème suivant se produit lorsque l'API Cloud Healthcare n'a pas été activée dans le projet où le cluster GKE avec l'adaptateur est en cours d'exécution:

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

Pour résoudre ce problème, assurez-vous que toutes les API nécessaires sont activées en suivant les instructions de la section Avant de commencer.

Erreur de champ d'application insuffisant

Le problème suivant se produit lorsque le cluster GKE sur lequel l'adaptateur est exécuté n'a pas la bonne valeur de champ d'application :

LO [Http_403, PERMISSION_DENIED, Request had insufficient authentica]

Pour résoudre ce problème, mettez à jour le cluster GKE ou créez-en un avec l'option suivante :

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

Erreur d'autorisation refusée pour le magasin DICOM

L'erreur suivante se produit lorsque le compte de service utilisé par le cluster GKE sur lequel l'adaptateur est exécuté ne dispose pas du rôle roles/healthcare.dicomEditor :

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

Pour résoudre ce problème, suivez les instructions de la section Accorder les autorisations de compte de service Compute Engine.

Étape suivante

Après avoir configuré le prototype dans ce guide, vous pouvez commencer à utiliser Cloud VPN pour chiffrer le trafic entre votre PACS et l'API Cloud Healthcare.