In questa pagina viene spiegato come utilizzare l'open source Adattatore DICOM dell'API Cloud Healthcare su Google Kubernetes Engine (GKE) per completare le attività seguenti:
- Connetti un sistema di archiviazione e comunicazione delle immagini (PACS) all'API Cloud Healthcare.
- Importa i dati DICOM dal PACS in un archivio DICOM nell'API Cloud Healthcare.
Questa guida fornisce un modo semplice per configurare un prototipo utilizzando Google Kubernetes Engine e una macchina virtuale (VM) Compute Engine. La La VM di Compute Engine simula un PACS on-premise. Per maggiori informazioni informazioni dettagliate, vedi il file README dell'adattatore DICOM.
Panoramica dell'adattatore DICOM
L'adattatore è costituito da due componenti principali: l'adattatore per l'importazione e l'adattatore per l'esportazione. Questa guida illustra come utilizzare di importazione dell'adattatore per archiviare le immagini DICOM in un archivio DICOM.
Utilizza l'adattatore DICOM per tradurre i dati tra protocolli tradizionali e Protocolli RESTful. Ad esempio, puoi tradurre da C-STORE nel formato STOW-RS.
Costi
Questa guida utilizza i componenti fatturabili di Google Cloud, tra cui:
- API Cloud Healthcare
- Google Kubernetes Engine
- Compute Engine
Utilizza il Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto. I nuovi utenti della piattaforma Cloud potrebbero essere idonei per un prova gratuita.
Prima di iniziare
- Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API Cloud Healthcare API, Google Kubernetes Engine, and Container Registry.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API Cloud Healthcare API, Google Kubernetes Engine, and Container Registry.
- Attendi che l'API GKE e i servizi correlati siano abilitati. Questa operazione può richiedere diversi minuti.
- Se non l'hai ancora fatto, crea un archivio DICOM.
Scegli una shell
Per completare questa guida, utilizza Cloud Shell o shell locale.
Cloud Shell è un ambiente shell per la gestione delle risorse ospitate su Google Cloud. Cloud Shell arriva preinstallati i seguenti strumenti, usati in questa guida:
- gcloud CLI: fornisce l'interfaccia a riga di comando principale per Google Cloud
kubectl
: fornisce l'interfaccia a riga di comando per l'esecuzione dei comandi rispetto ai cluster GKE
Per aprire Cloud Shell o configurare la shell locale, completa seguenti passaggi:
Cloud Shell
Vai alla console Google Cloud.
Nell'angolo in alto a destra della console, fai clic su Attiva Google Pulsante Cloud Shell:
All'interno di un frame nella parte inferiore della console si apre una sessione di Cloud Shell. Tu
usa questa shell per eseguire i comandi gcloud
e kubectl
.
Shell locale
Se preferisci utilizzare la tua shell locale, devi installare con gcloud CLI. Consulta Per istruzioni, installa Google Cloud CLI.
Eseguire il deployment dell'adattatore utilizzando Google Kubernetes Engine
L'adattatore per l'importazione e l'adattatore per l'esportazione sono applicazioni containerizzate in fase di gestione temporanea
un'immagine Docker predefinita in Container Registry. In questo
guida, esegui il deployment dell'immagine dicom-import-adapter
per eseguirla su un cluster GKE.
Concedi le autorizzazioni all'account di servizio Compute Engine
Segui le istruzioni in Creazione e abilitazione degli account di servizio per le istanze
per concedere all'account di servizio predefinito Compute Engine
Ruolo roles/healthcare.dicomEditor
. Per ulteriori informazioni, vedi
Ruoli di archiviazione DICOM.
Crea il cluster
gcloud
Per creare un cluster in GKE denominato dicom-adapter
, esegui il comando gcloud container clusters create
.
Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:
- COMPUTE_ZONE: la zona in cui viene eseguito il deployment del cluster. Una zona è una località regionale approssimativa in cui viene eseguito il deployment dei cluster e delle relative risorse. Ad esempio,
us-west1-a
è una zona nella regioneus-west
. Se hai impostato una zona predefinita utilizzando il comandogcloud config set compute/zone
, il valore del flag nel comando precedente sostituisce il valore predefinito.
Esegui la persone che seguo :
Linux, macOS o Cloud Shell
gcloud container clusters create dicom-adapter \ --zone=COMPUTE_ZONE \ --scopes=https://www.googleapis.com/auth/cloud-healthcare
Windows (PowerShell)
gcloud container clusters create dicom-adapter ` --zone=COMPUTE_ZONE ` --scopes=https://www.googleapis.com/auth/cloud-healthcare
Windows (cmd.exe)
gcloud container clusters create dicom-adapter ^ --zone=COMPUTE_ZONE ^ --scopes=https://www.googleapis.com/auth/cloud-healthcare
Dovresti ricevere una risposta simile alla seguente:
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 il deployment
Quando esegui il deployment di un'applicazione in GKE, devi definire le proprietà del Deployment utilizzando un File manifest del deployment, che in genere è un file YAML. Per informazioni sui file manifest dei deployment, consulta Creazione di deployment.
Con un editor di testo, crea un file manifest Deployment per l'adattatore di importazione
chiamato dicom_adapter.yaml
con i seguenti contenuti:
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"
Sostituisci quanto segue:
- PROJECT_ID: ID progetto
- LOCATION: località del set di dati
- DATASET_ID: ID per il set di dati padre del tuo archivio DICOM
- DICOM_STORE_ID: ID per l'archivio DICOM a cui sei importando i dati DICOM
Configura il servizio
a rendere l'adattatore DICOM accessibile alle applicazioni al di fuori di GKE ad esempio un PACS, devi configurare un bilanciatore del carico interno. La Il bilanciatore del carico consente di esporre internamente DIMSE (in questa guida, la porta 2575).
Crea un file manifest del servizio per configurare il bilanciamento del carico.
Nella directory in cui hai creato il file manifest del deployment, utilizza un'interfaccia
editor per creare un file denominato dicom_adapter_load_balancer.yaml
con i seguenti contenuti. Puoi creare ed eseguire il deployment del file manifest del servizio
in Deployment del servizio e del bilanciatore del carico 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
esegui il deployment del deployment
Per eseguire il deployment dell'adattatore in un cluster GKE, esegui questo comando
nella directory contenente il file manifest del deployment dicom_adapter.yaml
:
kubectl apply -f dicom_adapter.yaml
L'output è il seguente:
deployment.apps/dicom-adapter created
Ispeziona il deployment
Dopo aver creato il deployment, usa lo strumento kubectl
per esaminarlo.
Per ottenere informazioni dettagliate sul deployment, esegui questo comando:
kubectl describe deployment dicom-adapter
Per visualizzare Pod creato dal deployment, esegui questo comando:
kubectl get pods -l app=dicom-adapter
Per ottenere informazioni sul pod creato, esegui questo comando utilizzando nome del pod restituito dal comando precedente:
kubectl describe pod POD_NAME
Se il deployment ha avuto esito positivo, l'ultima parte dell'output della query
contiene le seguenti informazioni. L'adattatore è pronto per la pubblicazione
Richieste quando il container dicom-import-adapter
ha il valore Started
nella colonna 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
Esegui il deployment del servizio e del bilanciatore del carico interno
Per creare il bilanciatore del carico interno, nella directory contenente
dicom_adapter_load_balancer.yaml
Nel file manifest del servizio, esegui questo comando:
kubectl apply -f dicom_adapter_load_balancer.yaml
L'output è il seguente:
service/dicom-adapter-load-balancer created
Ispeziona il servizio
Dopo aver creato il servizio, ispezionalo per verificare che sia stato configurato in modo corretto.
Per ispezionare il bilanciatore del carico, esegui questo comando:
kubectl describe service dicom-adapter-load-balancer
L'output è il seguente:
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 compilazione dell'indirizzo IP LoadBalancer Ingress
potrebbe richiedere fino a un minuto.
Salva l'indirizzo IP LoadBalancer Ingress
. Puoi utilizzarlo per accedere al Servizio
dall'esterno del cluster nella prossima sezione.
Crea una macchina virtuale Compute Engine
Per simulare il tuo PACS on-premise, crea una VM di Compute Engine per inviare richieste all'adattatore DICOM. Perché di cui è stato eseguito il deployment di un bilanciatore del carico interno la VM che crei e il cluster GKE esistente deve essere nella stessa regione e utilizzano la stessa rete VPC.
Completa i seguenti passaggi per creare un'istanza di macchina virtuale Linux in Compute Engine:
Console
Nella console Google Cloud, vai alla pagina Istanze VM.
Fai clic su Crea istanza.
Scegli una regione e una zona per l'istanza che corrisponda alla zona selezionato quando hai creato il cluster. Per Ad esempio, se hai utilizzato
us-central1-a
per COMPUTE_ZONE quando hai creato il cluster, selezionaus-central1 (Iowa)
per la Regione eus-central1-a
per la zona.Nella sezione Disco di avvio, fai clic su Cambia per configurare il disco di avvio.
Nella scheda Immagini pubbliche, scegli la versione 9 del sistema operativo Debian.
Fai clic su Seleziona.
Nella sezione Firewall, seleziona Consenti traffico HTTP.
Fai clic sul pulsante Crea per creare l'istanza.
gcloud
Esegui il comando gcloud compute instances create
. Il comando utilizza il tag http-server
per consentire il traffico HTTP.
Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:
- PROJECT_ID: l'ID del tuo progetto Google Cloud
- COMPUTE_ZONE: la zona che hai selezionato quando hai creato il cluster
- INSTANCE_NAME: nome della VM
Esegui la persone che seguo :
Linux, macOS o Cloud Shell
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)
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)
gcloud compute instances create INSTANCE_NAME ^ --project=PROJECT_ID ^ --zone=COMPUTE_ZONE ^ --image-family=debian-9 ^ --image-project=debian-cloud ^ --tags=http-server
Dovresti ricevere una risposta simile alla seguente:
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
Potrebbe essere necessario un po' di tempo per l'avvio dell'istanza. Dopo l'avvio dell'istanza, è elencato nella pagina Istanze VM con un'icona di stato verde.
Connettiti alla VM
Per connetterti alla VM, completa questi passaggi:
Console
Nella console Google Cloud, vai alla pagina Istanze VM.
Nell'elenco delle istanze di macchine virtuali, fai clic su SSH nella riga che hai creato.
gcloud
Esegui il comando gcloud compute ssh
.
Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:
- PROJECT_ID: l'ID del tuo progetto Google Cloud
- COMPUTE_ZONE: la zona della VM
- INSTANCE_NAME: il nome della VM
Esegui la persone che seguo :
Linux, macOS o Cloud Shell
gcloud compute ssh INSTANCE_NAME \ --project PROJECT_ID \ --zone COMPUTE_ZONE
Windows (PowerShell)
gcloud compute ssh INSTANCE_NAME ` --project PROJECT_ID ` --zone COMPUTE_ZONE
Windows (cmd.exe)
gcloud compute ssh INSTANCE_NAME ^ --project PROJECT_ID ^ --zone COMPUTE_ZONE
Ora hai una finestra del terminale per interagire con la tua istanza Linux.
importa immagini DICOM nell'archivio DICOM
Sono disponibili diverse opzioni software che puoi utilizzare per inviare Immagini DICOM su una rete. Nelle sezioni seguenti viene utilizzato il Toolkit DICOM per DCMTK.
Per importare le immagini DICOM nel tuo archivio DICOM, completa i seguenti passaggi da la VM che hai creato nella sezione precedente:
Installa il software del toolkit DICOM di DCMTK:
sudo apt-get install -y dcmtk
Salva l'immagine DICOM nella VM. Ad esempio, se l'immagine DICOM è archiviata in un bucket Cloud Storage, esegui questo comando per scaricarlo nel tuo attuale file directory:
gcloud storage cp gs://BUCKET/DCM_FILE .
Per utilizzare un'immagine DICOM resa liberamente disponibile da Google Cloud dal
gcs-public-data--healthcare-tcia-lidc-idri
set di dati, esegui il seguente 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
Esegui
dcmsend
. , disponibile tramite il toolkit DICOM di DCMTK. Quando esegui il comando, imposta il titolo dell'entità dell'applicazione (AE) suIMPORTADAPTER
. Facoltativamente, puoi aggiungere il flag--verbose
per mostrare i dettagli dell'elaborazione. La porta utilizzata in questa guida è 2575.dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER
Sostituisci quanto segue:
- PEER:
LoadBalancer Ingress
indirizzo IP restituito quando hai esaminato il servizio - DCMFILE_IN: percorso dell'immagine DICOM sulla VM
Quando esegui
dcmsend
con una singola immagine DICOM, l'output è il seguente: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
- PEER:
Per verificare che l'immagine DICOM sia stata importata correttamente nel tuo archivio DICOM. cerca istanze nell'archivio DICOM e assicurati che la nuova immagine DICOM sia presente nell'archivio.
Dopo aver completato questa sezione, hai eseguito correttamente il deployment dell'adattatore DICOM a GKE e ha inviato un'immagine DICOM da un'istanza PACS l'adattatore all'API Cloud Healthcare.
Risoluzione dei problemi
Risoluzione dei problemi di GKE
Se l'adattatore DICOM rileva un errore dopo il deployment su GKE, seguire la procedura Risoluzione dei problemi relativi ai carichi di lavoro di cui è stato eseguito il deployment.
Risoluzione dei problemi relativi all'adattatore
Gli adattatori di importazione ed esportazione generano log che puoi utilizzare per diagnosticare
problemi. Quando esegui un adattatore utilizzando GKE, i log
in Cloud Logging. Per visualizzare i log,
completa i seguenti passaggi utilizzando la console Google Cloud o
Strumento kubectl
:
Console
Vai alla dashboard Carichi di lavoro GKE nella console Google Cloud.
Seleziona il carico di lavoro
dicom-adapter
.Nella pagina Dettagli deployment, fai clic su Log dei container.
kubectl
Per visualizzare tutti i pod in esecuzione nel tuo cluster, esegui questo comando:
kubectl get pods
Cerca il pod il cui nome inizia con dicom-adapter
.
Per ottenere i log del pod, esegui questo comando:
kubectl logs POD_NAME
Se hai saltato uno qualsiasi dei passaggi di questa guida, il comando dcmsend
potrebbe non riuscire
caricare immagini. Per esaminare il problema, esegui nuovamente il comando con il flag -d
(per "debug"). La bandierina mostra
un registro di azioni più dettagliato,
inclusi i messaggi che forniscono informazioni sull'errore.
Risoluzione dei problemi relativi ad autorizzazioni e autorizzazioni
Le seguenti sezioni descrivono gli errori che possono verificarsi in dcmsend
quando le autorizzazioni o le autorizzazioni
non sono configurati correttamente.
Errore di associazione interrotta dai peer
Il seguente problema si verifica quando il traffico di rete non può passare dal PACS alla porta 2575 del bilanciatore del carico:
cannot send SOP instance: Peer aborted Association (or never connected)
Per risolvere il problema, assicurati che la VM PACS e l'ambiente GKE sono in esecuzione nella stessa rete VPC. Se non vengono eseguiti nello stesso rete VPC, controlla quanto segue:
- Il bilanciatore del carico non è configurato come "interno".
- Non esistono regole firewall che bloccano le connessioni alla porta 2575.
Questo errore può verificarsi anche quando il servizio del bilanciatore del carico o l'adattatore I pod non sono configurati correttamente nel cluster GKE. Per assicurarti che siano configurati correttamente, consulta la sezione Controllare il deployment. e l'ispezione del servizio in questa guida.
Errore di API obbligatorie non abilitate
Il seguente problema si verifica quando l'API Cloud Healthcare non è stata abilitata nel progetto in cui è in esecuzione il cluster GKE con l'adattatore:
LO [Http_403, PERMISSION_DENIED, Cloud Healthcare API has not been u]
Per risolvere il problema, assicurati che tutte le API necessarie siano abilitate seguendo le istruzioni in Prima di iniziare.
Errore di ambito insufficiente
Il seguente problema si verifica quando nel cluster GKE l'adattatore in esecuzione non dispone del valore corretto dell'ambito:
LO [Http_403, PERMISSION_DENIED, Request had insufficient authentica]
Per risolvere il problema, aggiorna il cluster GKE o crea un nuovo cluster con il seguente flag:
--scopes=https://www.googleapis.com/auth/cloud-healthcare
Errore di autorizzazione negata per l'archivio DICOM
Il seguente errore si verifica quando l'account di servizio utilizzato da GKE
in cui è in esecuzione l'adattatore non ha il token roles/healthcare.dicomEditor
ruolo:
LO [Http_403, PERMISSION_DENIED, Permission healthcare.dicomStores.d]
Per risolvere il problema, segui le istruzioni in Concessione delle autorizzazioni per l'account di servizio Compute Engine.
Passaggi successivi
Dopo aver configurato il prototipo in questa guida, puoi iniziare a utilizzare Cloud VPN per criptare il traffico tra il tuo PACS e l'API Cloud Healthcare.