PACS mit der Cloud Healthcare API verbinden

Auf dieser Seite wird erläutert, wie Sie mit dem Open-Source-DICOM-Adapter der Cloud Healthcare API in Google Kubernetes Engine ein Bildarchivierungs- und Kommunikationssystem (Picture Archive and Communication System, PACS) mit der Cloud Healthcare API verbinden und DICOM-Daten importieren

Dieser Leitfaden bietet eine einfache Möglichkeit, einen Prototyp mit Google Kubernetes Engine und einer virtuellen Maschine (VM) von Compute Engine einzurichten. Die Compute Engine-VM simuliert das lokale PACS. Weitere Informationen finden Sie in der README-Datei zum DICOM-Adapter in GitHub.

Übersicht

Der DICOM-Adapter stellt eine Reihe von Komponenten bereit, mit denen Daten zwischen herkömmlichen DICOM-DIMSE-Protokollen wie C-STORE und RESTful-Webwebprotokollen (z. B. STOW-RS) übersetzt werden können. Der Adapter besteht aus zwei Hauptkomponenten: dem Importadapter und dem Exportadapter. In dieser Anleitung verwenden Sie den Importadapter, um DICOM-Images in einen DICOM-Speicher zu importieren.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter:

  • Cloud Healthcare API
  • Google Kubernetes Engine
  • Compute Engine

Sie können mithilfe des Preisrechners eine Kostenschätzung für Ihre voraussichtliche Nutzung erstellen. Neuen Cloud Platform-Nutzern steht möglicherweise einekostenlose Testversion zur Verfügung.

Hinweis

Bevor Sie den DICOM-Adapter einrichten können, müssen Sie ein Google Cloud-Projekt auswählen oder erstellen und die erforderlichen APIs aktivieren. Gehen Sie dazu folgendermaßen vor:

  1. Melden Sie sich bei Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, melden Sie sich hier für ein neues Konto an.

  2. Wählen Sie in der Cloud Console auf der Seite für die Projektauswahl ein Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

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

    Aktivieren Sie die APIs

  5. Warten Sie, bis die GKE API und die zugehörigen Dienste aktiviert wurden. Dieser Vorgang kann einige Minuten dauern.

Shell auswählen

Für diese Anleitung können Sie Cloud Shell oder Ihre lokale Shell verwenden.

Cloud Shell ist eine Shell-Umgebung für die Verwaltung von Ressourcen, die in Google Cloud gehostet werden. In Cloud Shell sind die Tools gcloud und kubectl vorinstalliert. Das gcloud-Tool stellt die primäre Befehlszeilenschnittstelle für die GCP bereit. kubectl bietet die Befehlszeilenschnittstelle zum Ausführen von Befehlen für GKE-Cluster.

Wenn Sie Ihre lokale Shell bevorzugen, müssen Sie das Cloud SDK installieren, das das Tool gcloud und das Tool kubectl enthält.

So öffnen Sie Cloud Shell oder konfigurieren Ihre lokale Shell:

Cloud Shell

So starten Sie Cloud Shell:

  1. Öffnen Sie die Google Cloud Console.

    Google Cloud Console

  2. Klicken Sie in der oberen rechten Ecke der Console auf die Schaltfläche Google Cloud Shell aktivieren:

Im unteren Bereich der Konsole wird ein Frame für die Cloud Shell-Sitzung geöffnet. In dieser Shell führen Sie gcloud- und kubectl-Befehle aus.

Lokale Shell

Zum Installieren des gcloud- und des kubectl-Tools müssen Sie die aktuelle Cloud SDK-Version installieren und initialisieren.

DICOM-Speicher erstellen

Bevor Sie den DICOM-Adapter verwenden, müssen Sie einen DICOM-Speicher erstellen, wenn Sie dies noch nicht getan haben.

Adapter mit Google Kubernetes Engine bereitstellen

Der Importadapter und der Exportadapter sind containerisierte Anwendungen, die in einem vordefinierten Docker-Image in Container Registry bereitgestellt werden. Sie können diese Images zur Ausführung in einem GKE-Cluster bereitstellen.

Cluster erstellen

Führen Sie den Befehl gcloud container clusters create aus, um in GKE einen Cluster mit dem Namen dicom-adapter zu erstellen:

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

Dabei gilt:

  • COMPUTE_ZONE ist die Zone, in der Ihr Cluster bereitgestellt wird. Eine Zone ist ein ungefährer regionaler Standort, an dem Ihre Cluster und deren Ressourcen bereitgestellt werden. us-west1-a ist z. B. eine Zone in der Region us-west. Wenn Sie eine Standardzone mit gcloud config set compute/zone festgelegt haben, überschreibt der Wert dieses Flags den Standardwert.

Wenn der Prozess erfolgreich durchgeführt wurde, gibt der Befehl folgende Antwort zurück:

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

Deployment konfigurieren

Wenn Sie eine Anwendung in GKE bereitstellen, definieren Sie die Eigenschaften des Deployment mithilfe einer Deployment-Manifestdatei, bei der es sich in der Regel um eine YAML-Datei handelt.

Erstellen Sie mit einem Texteditor eine Deployment-Manifestdatei für den Importadapter namens dicom_adapter.yaml mit folgendem Inhalt:

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"

Dabei gilt:

  • PROJECT_ID ist die ID für das Google Cloud-Projekt, das Ihren DICOM-Speicher enthält.
  • LOCATION ist der Standort, an dem sich Ihr DICOM-Speicher befindet.
  • DATASET_ID ist die ID des übergeordneten Datasets Ihres DICOM-Speichers.
  • DICOM_STORE_ID ist die ID für den DICOM-Speicher, in den Sie DICOM-Daten importieren.

Konfigurieren Sie den Dienst

Sie müssen einen internen Load-Balancer konfigurieren, um den DICOM-Adapter für Anwendungen außerhalb des GKE-Clusters zugänglich zu machen (z. B. ein PACS). Mit dem Load-Balancer können Sie den DIMSE-Port intern freigeben (in diesem Leitfaden Port 5755).

Erstellen Sie eine Dienstmanifestdatei, um das interne Load-Balancing zu konfigurieren. Erstellen Sie in dem Verzeichnis, in dem Sie die Deployment-Manifestdatei erstellt haben, mit einem Texteditor eine Datei namens dicom_adapter_load_balancer.yaml mit folgendem Inhalt:

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

Deployment bereitstellen

Führen Sie den folgenden Befehl aus, um den Adapter in einem Verzeichnis mit der Manifestdatei dicom_adapter.yaml des Deployment in einem GKE-Cluster bereitzustellen:

kubectl apply -f dicom_adapter.yaml

Wenn der Prozess erfolgreich durchgeführt wurde, gibt der Befehl folgendes Ergebnis zurück:

deployment.extensions "dicom-adapter-deployment" created

Deployment prüfen

Nachdem Sie das Deployment erstellt haben, können Sie es mit dem kubectl-Tool prüfen.

Führen Sie den folgenden Befehl aus, um ausführliche Informationen zum Deployment zu erhalten:

kubectl describe deployment dicom-adapter

Führen Sie den folgenden Befehl aus, um den vom Deployment erstellten Pod aufzulisten:

kubectl get pods -l app=dicom-adapter

So rufen Sie Informationen zum erstellten Pod ab:

kubectl describe pod POD_NAME

Wenn das Deployment erfolgreich war, sollte der letzte Teil der Ausgabe des vorherigen Befehls die folgenden Informationen enthalten:

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

Dienst bereitstellen und den internen Load-Balancer erstellen

Führen Sie den folgenden Befehl aus, um den internen Load-Balancer in dem Verzeichnis zu erstellen, das die Manifestdatei des Dienstes dicom_adapter_load_balancer.yaml enthält:

kubectl apply -f dicom_adapter_load_balancer.yaml

Wenn der Prozess erfolgreich durchgeführt wurde, gibt der Befehl folgendes Ergebnis zurück:

deployment.extensions "dicom_adapter_load_balancer.yaml" created

Dienst prüfen

Nachdem Sie den Dienst erstellt haben, prüfen Sie, ob er erfolgreich konfiguriert wurde.

Führen Sie den folgenden Befehl aus, um den internen Load-Balancer zu prüfen:

kubectl describe service dicom-adapter-load-balancer

Wenn der Prozess erfolgreich war, sollte die Ausgabe in etwa so aussehen:

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 kann bis zu einer Minute dauern, bis die IP-Adresse LoadBalancer Ingress ausgefüllt ist. Kopieren Sie die IP-Adresse LoadBalancer Ingress, da Sie diese und den Port 2575 verwenden werden, um im nächsten Abschnitt von außerhalb des Clusters auf den Dienst zuzugreifen.

Compute Engine-VM erstellen

Erstellen Sie zum Simulieren Ihres lokalen PACS eine Compute Engine-VM, mit der Sie Anfragen an den DICOM-Adapter senden. Da Sie einen internen Load-Balancer bereitgestellt haben, muss sich die von Ihnen erstellte VM und der vorhandene GKE-Cluster in derselben Region befinden und dasselbe VPC-Netzwerk verwenden.

Die folgenden Schritte zeigen, wie Sie eine Linux-VM-Instanz in Compute Engine erstellen:

Console

  1. Rufen Sie in der Cloud Console die Seite VM-Instanzen auf.

    Zur Seite "VM-Instanzen"

  2. Klicken Sie auf Instanz erstellen.

  3. Wählen Sie eine Region und eine Zone für die Instanz aus, die der Zone entspricht, die Sie beim Erstellen des Clusters ausgewählt haben. Wenn Sie beispielsweise beim Erstellen des Clusters us-central1-a für COMPUTE_ZONE verwendet haben, wählen Sie im Bildschirm zur Instanzerstellung us-central1 (Iowa) für die Region und us-central1-a für die Zone aus.

  4. Klicken Sie im Abschnitt Bootlaufwerk auf Ändern, um mit der Konfiguration des Bootlaufwerks zu beginnen.

  5. Wählen Sie auf dem Tab Öffentliche Images die Version 9 des Debian-Betriebssystems aus.

  6. Klicken Sie auf Auswählen.

  7. Wählen Sie im Bereich Firewall die Option HTTP-Traffic zulassen aus.

  8. Erstellen klicken, um die Instanz zu erstellen.

gcloud

Führen Sie zum Erstellen einer Compute-Instanz die Methode gcloud compute instances create mit den folgenden Optionen aus:

  • Die COMPUTE_ZONE, die Sie beim Erstellen des Clusters ausgewählt haben
  • Das http-server-Tag, das HTTP-Traffic zulässt
gcloud compute instances create INSTANCE_NAME \
   --project=PROJECT_ID \
   --zone=COMPUTE_ZONE \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --tags=http-server

Die Ausgabe ähnelt dem folgenden Beispiel:

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

Warten Sie, bis die Instanz gestartet ist. Nachdem die Instanz gestartet wurde, wird sie auf der Seite "VM-Instanzen" mit einem grünen Statussymbol angezeigt.

Standardmäßig verwendet die Instanz das Standard-VPC-Netzwerk wie der Cluster. Das bedeutet, dass Traffic von der Instanz an den Cluster gesendet werden kann.

So stellen Sie eine Verbindung zur Instanz her:

Console

  1. Rufen Sie in der Cloud Console die Seite VM-Instanzen auf.

    Zur Seite "VM-Instanzen"

  2. Klicken Sie in der Liste der VM-Instanzen in der Zeile der von Ihnen erstellten Instanz auf SSH.

gcloud

Führen Sie den Befehl gcloud compute ssh aus, um eine Verbindung zur Instanz herzustellen:

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

Sie haben nun ein Terminalfenster, über das Sie mit Ihrer Linux-Instanz interagieren können.

DICOM-Images in den DICOM-Speicher importieren

Es gibt mehrere Softwareoptionen, mit denen Sie DICOM-Images über ein Netzwerk senden können. In den folgenden Abschnitten verwenden Sie das DCMTK-DICOM-Toolkit.

Führen Sie die folgenden Schritte von der im vorherigen Abschnitt erstellten VM aus, um DICOM-Images in den DICOM-Speicher zu importieren:

  1. Installieren Sie die DCMTK-DICOM-Toolkit-Software:

    sudo apt install dcmtk
    
  2. Laden Sie das DICOM-Image, das Sie in Ihren DICOM-Speicher importieren möchten, auf die VM hoch. Wenn das DICOM-Image beispielsweise in einem Cloud Storage-Bucket gespeichert ist, können Sie es mit folgendem Befehl in Ihr aktuelles Arbeitsverzeichnis herunterladen:

    gsutil cp gs://BUCKET/DCM_FILE .
    

    Führen Sie den folgenden Befehl aus, um ein von Google Cloud kostenlos zur Verfügung gestelltes DICOM-Image aus dem Dataset gcs-public-data--healthcare-tcia-lidc-idri zu verwenden:

    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. Führen Sie den Befehl dcmsend aus, der über das DCMTK-DICOM-Toolkit verfügbar ist. Setzen Sie den Titel der Anwendungsentität (AE) auf IMPORTADAPTER, wenn Sie den Befehl ausführen. Sie können optional das Flag --verbose hinzufügen, um die Verarbeitungsdetails aufzurufen. Ersetzen Sie die folgenden Werte, bevor Sie die Anfrage stellen:

    • PEER: Die LoadBalancer Ingress-IP-Adresse, die bei der Prüfung des Dienstes zurückgegeben wurde.
    • PORT: Der verwendete Port ist 2575.
    • DCMFILE_IN: Der Pfad in Ihrem Dateisystem zum DICOM-Image, das Sie hochladen.
    dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER
    

    Wenn die Anfrage erfolgreich ist, zeigt das Terminal die folgende Ausgabe an, wenn Sie dcmsend mit einem einzelnen DICOM-Image ausführen:

    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. Wenn Sie prüfen möchten, ob das DICOM-Image erfolgreich in den DICOM-Speicher importiert wurde, suchen Sie im DICOM-Speicher nach Instanzen und vergewissern Sie sich, dass sich das neue DICOM-Image im Speicher befindet.

Nachdem Sie diesen Abschnitt abgeschlossen haben, haben Sie den DICOM-Adapter erfolgreich in GKE bereitgestellt und ein DICOM-Image von einer PACS-Instanz über den Adapter und an die Cloud Healthcare API gesendet.

Fehlerbehebung bei Adapterfehlern

Wenn der DICOM-Adapter nach der Bereitstellung in GKE einen Fehler feststellt, führen Sie die Schritte unter Fehlerbehebung bei bereitgestellten Arbeitslasten aus.

Die Import- und Exportadapter generieren Logs, die Sie zur Diagnose von Problemen verwenden können. Wenn Sie einen Adapter mit GKE ausführen, werden die Logs in Cloud Logging gespeichert. Nutzen Sie zum Aufrufen der Logs entweder die Google Cloud Console oder das kubectl-Tool:

Console

  1. Rufen Sie in der Cloud Console das GKE-Dashboard "Arbeitslasten" auf.

    GKE-Dashboard "Arbeitslasten" aufrufen

  2. Wählen Sie die Arbeitslast dicom-adapter aus.

  3. Klicken Sie auf der Seite Deployment-Details auf Containerlogs.

kubectl

Führen Sie den folgenden Befehl aus, um alle in Ihrem Cluster ausgeführten Pods anzusehen:

kubectl get pods

Suchen Sie nach dem Pod, dessen Name mit dicom-adapter beginnt.

Führen Sie den folgenden Befehl aus, um die Logs des Pods abzurufen:

kubectl logs POD_NAME

Nächste Schritte

Nachdem Sie den Prototyp in diesem Leitfaden konfiguriert haben, können Sie mit Cloud VPN den Traffic zwischen Ihrem PACS und der Cloud Healthcare API verschlüsseln.