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 connecter un système d'archivage et de transmission d'images (PACS, picture archiving and communication system) à l'API Cloud Healthcare et importer des données DICOM.

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 README de l'adaptateur DICOM dans GitHub.

Aperçu

L'adaptateur DICOM fournit un ensemble de composants pouvant traduire les données entre les protocoles DICOM DIMSE traditionnels (tels que C-STORE) et les protocoles DICOMweb RESTful (tels que STOW-RS). L'adaptateur comprend deux composants principaux : l'adaptateur d'importation et l'adaptateur d'exportation. Dans ce guide, vous allez utiliser l'adaptateur d'importation pour importer des images DICOM vers un magasin DICOM.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • API Cloud Healthcare
  • Google Kubernetes Engine
  • Instance

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

Avant de pouvoir configurer l'adaptateur DICOM, vous devez choisir ou créer un projet Google Cloud et activer les API requises en procédant comme suit :

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Cloud Healthcare API, Google Kubernetes Engine, and Container Registry.

    Activer les API

  5. Patientez le temps de l'activation de l'API GKE et des services associés. Cette opération peut prendre plusieurs minutes.

Choisir une interface système

Pour réaliser ce tutoriel, vous pouvez utiliser Cloud Shell ou votre interface système locale.

Cloud Shell est un environnement shell permettant de gérer les ressources hébergées sur Google Cloud. Cloud Shell est préinstallé avec les outils gcloud et kubectl. L'outil gcloud fournit l'interface de ligne de commande principale pour GCP. kubectl fournit une interface de ligne de commande permettant d'exécuter des commandes sur des clusters GKE.

Si vous préférez utiliser votre interface système locale, vous devez installer le SDK Cloud, qui inclut les outils gcloud et kubectl.

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

Cloud Shell

Pour lancer Cloud Shell, procédez comme suit :

  1. Accédez à Google Cloud Console.

    Google Cloud Console

  2. Dans le coin supérieur droit de la console, cliquez sur le bouton Activer Google Cloud Shell .

Une session Cloud Shell s'ouvre dans un cadre en bas de la console. Cette interface système vous permet d'exécuter les commandes gcloud et kubectl.

Interface système locale

Pour installer les outils gcloud et kubectl, installez et initialisez la dernière version du SDK Cloud.

Créer un magasin DICOM

Avant d'utiliser l'adaptateur DICOM, vous devez créer un magasin DICOM si vous ne l'avez pas déjà fait.

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. Vous pouvez déployer ces images pour les exécuter sur un cluster GKE.

Créer le cluster

Pour créer un cluster dans GKE nommé dicom-adapter, exécutez la commande gcloud container clusters create :

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

où :

  • COMPUTE_ZONE est la zone dans laquelle votre cluster est déployé. Une zone est un emplacement régional approximatif dans lequel vos clusters et leurs ressources sont déployés. Par exemple, us-west1-a est une zone de la région us-west. Si vous avez défini une zone par défaut à l'aide de gcloud config set compute/zone, la valeur de cette option remplace la valeur par défaut.

Si l'opération réussit, la commande renvoie la réponse suivante :

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

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.

À 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: 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"

où :

  • PROJECT_ID est l'ID du projet Google Cloud contenant votre magasin DICOM.
  • LOCATION est l'emplacement de votre magasin DICOM.
  • DATASET_ID est l'ID de l'ensemble de données parent de votre magasin DICOM.
  • DICOM_STORE_ID est l'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 interne. 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 :

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 le déploiement

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

Si l'opération réussit, la commande renvoie le résultat suivant :

deployment.extensions "dicom-adapter-deployment" created

Inspecter le déploiement

Une fois le déploiement créé, vous pouvez l'inspecter à l'aide de l'outil kubectl.

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

kubectl describe deployment dicom-adapter

Pour répertorier 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éé :

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 doit contenir les informations suivantes :

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

Déployer le service et créer 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

Si l'opération réussit, la commande renvoie le résultat suivant :

deployment.extensions "dicom_adapter_load_balancer.yaml" 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 interne, exécutez la commande suivante :

kubectl describe service dicom-adapter-load-balancer

Si l'opération réussit, la commande renvoie un résultat semblable à celui-ci :

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. Copiez l'adresse IP LoadBalancer Ingress, car vous utiliserez celle-ci ainsi que le port 2575 pour accéder au service depuis l'extérieur 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 qui vous servira à 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.

Les étapes suivantes montrent comment créer une instance de VM Linux dans Compute Engine :

Console

  1. Dans Cloud Console, accédez à la page Instances de VM :

    Accéder à la page Instances de VM

  2. Cliquez sur Créer une instance.

  3. Choisissez une région et une zone pour l'instance. Celle-ci doit correspondre à la zone que vous avez sélectionnée lors de la création du cluster. Par exemple, si vous avez défini COMPUTE_ZONE sur us-central1-a lors de la création du cluster, sélectionnez us-central1 (Iowa) pour la région et us-central1-a pour la zone sur l'écran de création de l'instance.

  4. Dans la section Disque de démarrage, cliquez sur Modifier pour commencer la configuration de votre disque de démarrage.

  5. Dans l'onglet Images publiques, choisissez la version 9 du système d'exploitation Debian.

  6. Cliquez sur Sélectionner.

  7. Dans la section Pare-feu, sélectionnez Autoriser le trafic HTTP.

  8. Cliquez sur Créer pour créer l'instance.

gcloud

Pour créer une instance de calcul, exécutez la méthode gcloud compute instances create avec les options suivantes :

  • La COMPUTE_ZONE que vous avez sélectionné lors de la création du cluster
  • Le tag http-server pour autoriser le trafic HTTP
gcloud compute instances create INSTANCE_NAME \
   --project=PROJECT_ID \
   --zone=COMPUTE_ZONE \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --tags=http-server

Le résultat ressemble à ce qui suit :

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.

Par défaut, l'instance utilise le réseau VPC par défaut utilisé par le cluster, ce qui signifie que le trafic peut être envoyé de l'instance au cluster.

Pour vous connecter à l'instance, procédez comme suit :

Console

  1. Dans Cloud Console, accédez à la page Instances de VM :

    Accéder à la page Instances de VM

  2. Dans la liste des instances de machine virtuelle, cliquez sur SSH sur la ligne de l'instance que vous avez créée.

gcloud

Pour vous connecter à l'instance, exécutez la commande gcloud compute ssh :

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 install dcmtk
    
  2. Transférez l'image DICOM que vous souhaitez importer dans votre magasin DICOM vers 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 :

    gsutil 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 :

    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. 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. Avant d'envoyer la requête, effectuez les remplacements suivants :

    • PEER : l'adresse IP LoadBalancer Ingress qui a été renvoyée lors de l'inspection du service.
    • PORT : le port utilisé est 2575.
    • DCMFILE_IN : le chemin d'accès à l'image DICOM que vous importez sur votre système de fichiers.
    dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER
    

    Si la requête aboutit, le terminal affiche le résultat suivant lors de l'exécution de dcmsend avec une seule image 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. 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'échec de l'adaptateur

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.

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 :

Console

  1. Consultez le tableau de bord des charges de travail GKE dans Cloud Console.

    Consulter le tableau de bord des charges de travail GKE

  2. Sélectionnez la charge de travail dicom-adapter.

  3. Sur la page Informations sur le déploiement, cliquez sur Journaux de conteneur.

kubectl

Pour afficher tous les pods exécutés dans votre cluster, utilisez la commande suivante :

kubectl get pods

Recherchez le pod dont le nom commence par dicom-adapter.

Pour obtenir les journaux du pod, exécutez la commande suivante :

kubectl logs POD_NAME

É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.