Connetti un PACS all'API Cloud Healthcare

Questa pagina spiega come utilizzare l'adattatore DICOM dell'API Cloud Healthcare open source su Google Kubernetes Engine (GKE) per completare le attività seguenti:

• Connetti un sistema PACS (Picture Storage and Communication System) all'API Cloud Healthcare.
• Importa i dati DICOM dal PACS a 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 VM di Compute Engine simula il PACS on-premise. Per informazioni più dettagliate, consulta il documento README dell'adattatore DICOM.

Panoramica dell'adattatore DICOM

L'adattatore è costituito da due componenti principali: l'adattatore di importazione e l'adattatore per l'esportazione. Questa guida mostra come utilizzare l'adattatore di importazione 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 dal formato C-STORE al 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 di Cloud Platform potrebbero essere idonei per una prova gratuita.

Prima di iniziare

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

2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. Abilita le API Cloud Healthcare API, Google Kubernetes Engine, and Container Registry.

   Abilita le API

5. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

7. Abilita le API Cloud Healthcare API, Google Kubernetes Engine, and Container Registry.

   Abilita le API

8. Attendi l'abilitazione dell'API GKE e dei relativi servizi. Questa operazione può richiedere diversi minuti.
9. Se non l'hai ancora fatto, crea un archivio DICOM.

Scegli una shell

Per completare questa guida, utilizza Cloud Shell o la tua shell locale.

Cloud Shell è un ambiente shell per la gestione delle risorse ospitate su Google Cloud. Cloud Shell è preinstallato con i seguenti strumenti, che puoi utilizzare 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 di comandi sui cluster GKE

Per aprire Cloud Shell o configurare la tua shell locale, completa questi passaggi:

Cloud Shell

1. Vai alla console Google Cloud.

   Console Google Cloud

2. Nell'angolo in alto a destra della console, fai clic sul pulsante Attiva Google Cloud Shell:

Si apre una sessione di Cloud Shell all'interno di un frame nella parte inferiore della console. Puoi utilizzare questa shell per eseguire i comandi gcloud e kubectl.

Shell locale

Se preferisci utilizzare la tua shell locale, devi installare gcloud CLI. Per le istruzioni, consulta Installazione di Google Cloud CLI.

Esegui il deployment dell'adattatore utilizzando Google Kubernetes Engine

L'adattatore di importazione e l'adattatore di esportazione sono applicazioni containerizzate inserite in un'immagine Docker predefinita in Container Registry. In questa guida, eseguirai il deployment dell'immagine dicom-import-adapter per l'esecuzione 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 di Compute Engine il ruolo roles/healthcare.dicomEditor. Per ulteriori informazioni, consulta Ruoli dell'archivio DICOM.

Nota: se avvii il cluster GKE utilizzando un account di servizio diverso, concedi il ruolo roles/healthcare.dicomEditor all'account di servizio diverso.

Crea il cluster

Nota: il seguente comando crea un cluster GKE nella rete VPC predefinita e utilizza l'account di servizio predefinito di Compute Engine. Le modifiche all'account di servizio o alla rete potrebbero influire su altre parti di questa guida. Se modifichi l'account di servizio o la rete VPC, questa guida descrive le modifiche aggiuntive che devi apportare.

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 regione us-west. Se hai impostato una zona predefinita utilizzando il comando gcloud config set compute/zone, il valore del flag nel comando precedente sostituisce quello predefinito.

Esegui questo comando:

Linux, macOS o Cloud Shell

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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

Windows (PowerShell)

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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

Windows (cmd.exe)

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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, definisci le proprietà del deployment utilizzando un file manifest di deployment, che in genere è un file YAML. Per informazioni sui file manifest di deployment, consulta la sezione Creazione di deployment.

Utilizzando un editor di testo, crea un file manifest Deployment per l'adattatore di importazione denominato dicom_adapter.yaml con il seguente contenuto:

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: posizione 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 in cui stai importando i dati DICOM

Configura il servizio

Per rendere l'adattatore DICOM accessibile alle applicazioni esterne al cluster GKE (ad esempio un PACS), devi configurare un bilanciatore del carico interno. Il bilanciatore del carico consente di esporre internamente la porta DIMSE (in questa guida, la porta 2575).

Crea un file manifest di Service per configurare il bilanciamento del carico. Nella directory in cui hai creato il file manifest del deployment, utilizza un editor di testo per creare un file denominato dicom_adapter_load_balancer.yaml con i contenuti seguenti. 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

Nota: utilizza un bilanciatore del carico interno solo se accedi all'adattatore DICOM dalla stessa rete VPC a cui è collegato il cluster GKE, come descritto in questa pagina. Se esegui il deployment di un adattatore DICOM da utilizzare da altre reti, ad esempio on-premise, elimina la riga cloud.google.com/load-balancer-type: "Internal" dal file mostrato in precedenza.

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

Per ottenere informazioni dettagliate sul deployment, esegui questo comando:

kubectl describe deployment dicom-adapter

Per visualizzare il pod creato dal deployment, esegui questo comando:

kubectl get pods -l app=dicom-adapter

Per ottenere informazioni sul pod creato, esegui questo comando utilizzando il nome del pod restituito dal comando precedente:

kubectl describe pod POD_NAME

Se il deployment ha esito positivo, l'ultima parte dell'output del comando precedente contiene le seguenti informazioni. L'adattatore è pronto per gestire le richieste quando il contenitore 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 il file manifest del servizio dicom_adapter_load_balancer.yaml, 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, esaminalo per verificare che sia stato configurato correttamente.

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. Potrai 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. Poiché hai eseguito il deployment di un bilanciatore del carico interno, la VM che hai creato e il cluster GKE esistente devono trovarsi nella stessa regione e utilizzare la stessa rete VPC.

Completa i seguenti passaggi per creare un'istanza di macchina virtuale Linux in Compute Engine:

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Scegli una regione e una zona per l'istanza corrispondenti alla zona selezionata al momento della creazione del cluster. Ad esempio, se hai utilizzato us-central1-a per COMPUTE_ZONE quando hai creato il cluster, seleziona us-central1 (Iowa) per Regione e us-central1-a per Zona.

4. Nella sezione Disco di avvio, fai clic su Cambia per configurare il disco di avvio.

5. Nella scheda Immagini pubbliche, scegli la versione 9 del sistema operativo Debian.

6. Fai clic su Seleziona.

7. Nella sezione Firewall, seleziona Consenti traffico HTTP.

8. 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 selezionata quando hai creato il cluster
• INSTANCE_NAME: nome della VM

Esegui questo comando:

Linux, macOS o Cloud Shell

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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)

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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)

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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. Una volta avviata, l'istanza viene elencata nella pagina Istanze VM con un'icona di stato verde.

Per impostazione predefinita, l'istanza e il cluster utilizzano entrambi la rete VPC predefinita, il che significa che il traffico può essere inviato dall'istanza al cluster. Se il cluster GKE su cui è in esecuzione l'adattatore DICOM è stato creato in una rete VPC diversa, procedi in uno dei seguenti modi:

• Modifica la procedura precedente per avviare la VM in un'altra rete VPC.
• Rimuovi l'annotazione cloud.google.com/load-balancer-type: "Internal" dalla definizione del servizio del bilanciatore del carico.

Connettiti alla VM

Per connetterti alla VM, completa i seguenti passaggi:

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Nell'elenco delle istanze di macchine virtuali, fai clic su SSH nella riga dell'istanza 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 questo comando:

Linux, macOS o Cloud Shell

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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

Windows (PowerShell)

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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

Windows (cmd.exe)

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

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

A questo punto hai una finestra del terminale per interagire con l'istanza Linux.

importa immagini DICOM nell'archivio DICOM

Sono disponibili diverse opzioni software che puoi utilizzare per inviare immagini DICOM attraverso una rete. Nelle sezioni seguenti, utilizzerai il toolkit DICOM di DCMTK.

Per importare immagini DICOM nel tuo archivio DICOM, completa i seguenti passaggi dalla VM creata nella sezione precedente:

1. Installa il software del toolkit DICOM DCMTK:

   sudo apt-get install -y dcmtk
   

2. Salva l'immagine DICOM nella VM. Ad esempio, se l'immagine DICOM è archiviata in un bucket Cloud Storage, esegui questo comando per scaricarla nella directory di lavoro attuale:

   gsutil cp gs://BUCKET/DCM_FILE .
   

   Per utilizzare un'immagine DICOM resa liberamente disponibile da Google Cloud dal set di dati gcs-public-data--healthcare-tcia-lidc-idri, esegui questo comando:

   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. Esegui il comando dcmsend, disponibile tramite il toolkit DICOM di DCMTK. Quando esegui il comando, imposta il titolo dell'entità applicazione (AE) su IMPORTADAPTER. Facoltativamente, puoi aggiungere il flag --verbose per mostrare i dettagli dell'elaborazione. La porta utilizzata in questa guida è la 2575.

   dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER
   

   Sostituisci quanto segue:

   • PEER: LoadBalancer Ingress indirizzo IP restituito al momento dell'ispezione del 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
   

4. 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 nell'archivio.

Dopo aver completato questa sezione, hai eseguito correttamente il deployment dell'adattatore DICOM a GKE e hai inviato un'immagine DICOM da un'istanza PACS tramite l'adattatore all'API Cloud Healthcare.

Risolvere i problemi

Risoluzione dei problemi di GKE

Se si verifica un errore durante il deployment dell'adattatore DICOM dopo che ne hai eseguito il deployment su GKE, segui i passaggi descritti in Risoluzione dei problemi relativi ai carichi di lavoro di cui è stato eseguito il deployment.

Risoluzione dei problemi dell'adattatore

Gli adattatori per l'importazione e l'esportazione generano log che puoi utilizzare per diagnosticare eventuali problemi. Quando esegui un adattatore utilizzando GKE, i log vengono archiviati in Cloud Logging. Per visualizzare i log, completa i seguenti passaggi utilizzando la console Google Cloud o lo strumento kubectl:

Console

1. Vai alla dashboard Carichi di lavoro GKE nella console Google Cloud.

   Vai a Carichi di lavoro GKE

2. Seleziona il carico di lavoro dicom-adapter.

3. Nella pagina Dettagli deployment, fai clic su Log del container.

kubectl

Per visualizzare tutti i pod in esecuzione nel 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 perso uno dei passaggi in questa guida, il comando dcmsend potrebbe non caricare le immagini. Per esaminare il problema, esegui nuovamente il comando con il flag -d (per "debug"). Il flag stampa un log più dettagliato delle azioni, inclusi i messaggi che forniscono informazioni sull'errore.

Risoluzione dei problemi relativi ad autorizzazioni e autorizzazioni

Nelle sezioni seguenti vengono descritti gli errori che possono verificarsi in dcmsend quando le autorizzazioni o le autorizzazioni sono configurate in modo errato.

Nota: i messaggi di errore potrebbero non essere visualizzati alla fine dell'output dcmsend. Devi analizzare l'intero output di dcmsend per verificare se sono presenti i seguenti messaggi di errore.

Errore di associazione del peer interrotta

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 questo problema, assicurati che la VM PACS e il cluster GKE siano in esecuzione nella stessa rete VPC. Se non sono in esecuzione nella stessa rete VPC, verifica quanto segue:

• Il bilanciatore del carico non è configurato come "interno".
• Non sono presenti regole firewall che bloccano le connessioni alla porta 2575.

Questo errore può verificarsi anche quando il servizio del bilanciatore del carico o il pod adattatore non sono configurati correttamente nel cluster GKE. Per assicurarti che siano configurati correttamente, consulta le sezioni Ispezione del deployment e Ispezione del servizio in questa guida.

Errore 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 riportate in Prima di iniziare.

Errore di ambito insufficiente

Il seguente problema si verifica quando per il cluster GKE su cui è in esecuzione l'adattatore non è impostato il valore dell'ambito corretto:

LO [Http_403, PERMISSION_DENIED, Request had insufficient authentica]

Per risolvere questo 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 dal cluster GKE su cui è in esecuzione l'adattatore non ha il ruolo roles/healthcare.dicomEditor:

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

Per risolvere questo 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 PACS e l'API Cloud Healthcare.