Connecter un PACS à l'API Cloud Healthcare

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

  • Connectez un système PACS (Picture Archive and Communication System) à l'API Cloud Healthcare.
  • Importer des données DICOM du PACS dans un magasin DICOM de 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 plus de précisions, 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 datastore DICOM.

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

Coûts

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

  • 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. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet 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.
  6. Créez un magasin DICOM si ce n'est pas déjà fait.

Choisir une interface système

Pour suivre ce guide, utilisez 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 suivants, que vous utilisez dans ce guide:

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

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

Cloud Shell

  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

Si vous préférez utiliser votre interface système locale, vous devez installer le SDK Cloud, qui comprend les outils gcloud et kubectl. Pour obtenir des instructions, consultez la page Installer le SDK Cloud.

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.

Attribuer les autorisations du compte de service Compute Engine

Suivez les instructions de la section Créer et activer des comptes de service pour les instances pour attribuer 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

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

COMPUTE_ZONE est la zone dans laquelle votre cluster est déployé. Une zone est une zone régionale approximative dans laquelle 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 la commande gcloud config set compute/zone, la valeur de l'option de la commande précédente remplace celle par défaut.

Le résultat est le suivant :

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

Lorsque vous déployez 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 en savoir plus sur les fichiers manifestes de déploiement, consultez la page 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.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"

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 l'objet 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 allez créer et déployer 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 le déploiement

Pour déployer l'adaptateur dans 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

Après avoir créé le déploiement, 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 les requêtes lorsque la valeur Started du conteneur dicom-import-adapter est définie dans la colonne 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.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 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 l'objet Service

Une fois l'objet 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. Dans la section suivante, vous allez l'utiliser pour accéder au service depuis l'extérieur du cluster.

Créer une machine virtuelle Compute Engine

Pour simuler vos PACS sur site, créez une VM Compute Engine pour 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:

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 correspondant à la zone que vous avez sélectionnée lors de la création du cluster. Par exemple, si vous avez utiliséus-central1-a pour leCOMPUTE_ZONE Lors de la création du cluster, sélectionnez us-central1 (Iowa) pour leRégion etus-central1-a pour leZone ...

  4. Dans la section Disque de démarrage, cliquez sur Modifier pour configurer le disque de démarrage.

  5. Dans l'onglet Images publiques, sélectionnez 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

Exécutez la commande gcloud compute instances create. La commande utilise la balise 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

Remplacez les éléments suivants :

  • INSTANCE_NAME: nom de la VM
  • PROJECT_ID : ID du projet
  • COMPUTE_ZONE: zone que vous avez sélectionnée lors de la création du cluster

Le résultat est le suivant :

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:

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

Exécutez la commande gcloud compute ssh :

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

Remplacez les éléments suivants :

  • INSTANCE_NAME: nom de la VM
  • PROJECT_ID : ID du projet
  • COMPUTE_ZONE: zone de la VM

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

Importer des images DICOM dans le datastore DICOM

Plusieurs options logicielles sont disponibles pour envoyer des images DICOM via 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:

    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. Le port utilisé dans ce guide est 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 vers GKE et envoyé une image DICOM depuis une instance PACS via l'adaptateur à l'API Cloud Healthcare.

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.

Résoudre les problèmes liés à 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 :

Console

  1. Accédez au tableau de bord des charges de travail GKE dans Cloud Console.

    Accéder au 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

Si vous avez manqué l'une des étapes de ce 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 d'actions plus détaillé, y compris les messages qui fournissent des informations sur l'échec.

Résolution des problèmes liés aux autorisations et aux autorisations

Les sections suivantes décrivent les erreurs qui peuvent se produire dans dcmsend lorsque les autorisations ou les autorisations ne sont pas configurées correctement.

Erreur d'association annulée par le pair

Le problème suivant se produit lorsque le trafic réseau ne peut pas passer de 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. Si elles 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 que service "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 n'est pas correctement configuré dans le cluster GKE. Pour vous assurer qu'ils sont correctement configurés, consultez les sections Inspecter le déploiement et Inspecter le service de ce guide.

Erreur "API non activées" requises

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 s'exécute ne dispose pas de la valeur de champ d'application correcte:

LO [Http_403, PERMISSION_DENIED, Request had insufficient authentica]

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

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

Erreur "Autorisation d'accès au magasin DICOM refusée"

L'erreur suivante se produit lorsque le compte de service utilisé par le cluster GKE sur lequel l'adaptateur s'exécute 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 des autorisations au 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.