Esta página explica como usar o adaptador DICOM da Cloud Healthcare API de código aberto no Google Kubernetes Engine (GKE) para concluir as seguintes tarefas:
- Associe um sistema de arquivo e comunicação de imagens (PACS) à Cloud Healthcare API.
- Importe dados DICOM do PACS para um arquivo DICOM na Cloud Healthcare API.
Este guia oferece uma forma simples de configurar um protótipo com o Google Kubernetes Engine e uma máquina virtual (VM) do Compute Engine. A VM do Compute Engine simula o PACS no local. Para obter informações mais detalhadas, consulte o README do adaptador DICOM.
Vista geral do adaptador DICOM
O adaptador é composto por dois componentes principais: o adaptador de importação e o adaptador de exportação. Este guia mostra como usar o adaptador de importação para armazenar imagens DICOM num arquivo DICOM.
Use o adaptador DICOM para traduzir dados entre protocolos tradicionais e protocolos RESTful. Por exemplo, pode traduzir do formato C-STORE para o formato STOW-RS.
Custos
Este guia usa componentes faturáveis do Google Cloud, incluindo o seguinte:
- API Cloud Healthcare
- Google Kubernetes Engine
- Compute Engine
Use a calculadora de preços para gerar uma estimativa de custos com base na sua utilização projetada. Os novos utilizadores da Cloud Platform podem ser elegíveis para uma avaliação gratuita.
Antes de começar
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
Enable the Cloud Healthcare API, Google Kubernetes Engine, and Container Registry APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (
roles/serviceusage.serviceUsageAdmin), which contains theserviceusage.services.enablepermission. Learn how to grant roles. -
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
Enable the Cloud Healthcare API, Google Kubernetes Engine, and Container Registry APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (
roles/serviceusage.serviceUsageAdmin), which contains theserviceusage.services.enablepermission. Learn how to grant roles. - Aguarde que a API GKE e os serviços relacionados sejam ativados. Esta ação pode demorar vários minutos.
- Crie um arquivo DICOM, se ainda não o fez.
- CLI gcloud: fornece a interface de linhas de comando principal para Google Cloud
kubectl: fornece a interface de linhas de comando para executar comandos em clusters do GKEAceda à Google Cloud consola.
No canto superior direito da consola, clique no botão Ativar Google Cloud Shell:
- COMPUTE_ZONE: a zona onde o cluster está implementado. Uma zona é uma localização regional aproximada onde os seus clusters e respetivos recursos são implementados. Por exemplo,
us-west1-aé uma zona na regiãous-west. Se tiver definido uma zona predefinida através do comandogcloud config set compute/zone, o valor da flag no comando anterior substitui a predefinição. - PROJECT_ID: ID do projeto
- LOCATION: localização do conjunto de dados
- DATASET_ID: ID do conjunto de dados principal do seu arquivo DICOM
- DICOM_STORE_ID: ID do arquivo DICOM para o qual está a importar dados DICOM
Na Google Cloud consola, aceda à página Instâncias de VM.
Clique em Criar instância.
Escolha uma Região e uma Zona para a instância que corresponda à zona que selecionou quando criou o cluster. Por exemplo, se usou
us-central1-apara o COMPUTE_ZONE quando criou o cluster, selecioneus-central1 (Iowa)para a região eus-central1-apara a zona.Na secção Disco de arranque, clique em Alterar para configurar o disco de arranque.
No separador Imagens públicas, escolha a versão 9 do sistema operativo Debian.
Clique em Selecionar.
Na secção Firewall, selecione Permitir tráfego HTTP.
Clique em Criar para criar a instância.
- PROJECT_ID: o ID do seu Google Cloud projeto
- COMPUTE_ZONE: a zona que selecionou quando criou o cluster
- INSTANCE_NAME: nome da VM
Na Google Cloud consola, aceda à página Instâncias de VM.
Na lista de instâncias de máquinas virtuais, clique em SSH na linha da instância que criou.
Instale o software do conjunto de ferramentas DICOM DCMTK:
sudo apt-get install -y dcmtkGuarde a imagem DICOM na VM. Por exemplo, se a imagem DICOM estiver armazenada num contentor do Cloud Storage, execute o seguinte comando para a transferir para o diretório de trabalho atual:
gcloud storage cp gs://BUCKET/DCM_FILE .
Para usar uma imagem DICOM disponibilizada gratuitamente pelo conjunto de dados Google Cloud from the
gcs-public-data--healthcare-tcia-lidc-idri, execute o seguinte 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
Execute o comando
dcmsend, que está disponível através do conjunto de ferramentas DICOM DCMTK. Quando executar o comando, defina o título da entidade da aplicação (AE) comoIMPORTADAPTER. Opcionalmente, pode adicionar a flag--verbosepara mostrar os detalhes do processamento. A porta usada neste guia é 2575.dcmsend --verbose PEER 2575 DCM_FILE_IN -aec IMPORTADAPTER
Substitua o seguinte:
- PEER:
LoadBalancer Ingressendereço IP devolvido quando inspecionou o serviço - DCMFILE_IN: caminho para a imagem DICOM na VM
Quando executa o comando
dcmsendcom uma única imagem DICOM, o resultado é o seguinte: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:
Para verificar se a imagem DICOM foi importada com êxito para o seu arquivo DICOM. Pesquise instâncias no arquivo DICOM e certifique-se de que a nova imagem DICOM está no arquivo.
Aceda ao painel de controlo de cargas de trabalho do GKE na Google Cloud consola.
Selecione a carga de trabalho
dicom-adapter.Na página Detalhes da implementação, clique em Registos do contentor.
- O balanceador de carga não está configurado como "interno".
- Não existem regras de firewall que bloqueiem as ligações à porta 2575.
Escolha uma capa
Para concluir este guia, use a Cloud Shell ou a shell local.
O Cloud Shell é um ambiente de shell para gerir recursos alojados no Google Cloud. O Cloud Shell vem pré-instalado com as seguintes ferramentas, que usa neste guia:
Para abrir o Cloud Shell ou configurar o seu shell local, conclua os passos seguintes:
Cloud Shell
É aberta uma sessão do Cloud Shell numa moldura na parte inferior da consola. Use este shell para executar comandos gcloud e kubectl.
Shell local
Se preferir usar a shell local, tem de instalar a CLI gcloud. Consulte o artigo Instalar a CLI do Google Cloud para ver instruções.
Implemente o adaptador através do Google Kubernetes Engine
O adaptador de importação e o adaptador de exportação são aplicações contentorizadas preparadas numa imagem Docker pré-criada no Container Registry. Neste guia, implementa a imagem dicom-import-adapter para ser executada num cluster do GKE.
Conceda autorizações à conta de serviço do Compute Engine
Siga as instruções em Criar e ativar contas de serviço para instâncias
para conceder à conta de serviço predefinida do Compute Engine a função
roles/healthcare.dicomEditor. Para mais informações, consulte as funções da loja DICOM.
Crie o cluster
gcloud
Para criar um cluster no GKE com o nome dicom-adapter, execute o comando gcloud container clusters create.
Antes de usar qualquer um dos dados de comandos abaixo, faça as seguintes substituições:
Execute o seguinte comando:
Linux, macOS ou 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
Deve receber uma resposta semelhante à seguinte:
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
Configure a implementação
Quando implementa uma aplicação no GKE, define as propriedades da implementação através de um ficheiro de manifesto de implementação, que é normalmente um ficheiro YAML. Para obter informações sobre ficheiros de manifesto de implementação, consulte o artigo Criar implementações.
Com um editor de texto, crie um ficheiro de manifesto de implementação para o adaptador de importação denominado dicom_adapter.yaml com o seguinte conteúdo:
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"
Substitua o seguinte:
Configure o serviço
Para tornar o adaptador DICOM acessível a aplicações fora do cluster do GKE (como um PACS), tem de configurar um balanceador de carga interno. O balanceador de carga permite-lhe expor internamente a porta DIMSE (neste guia, a porta 2575).
Crie um ficheiro de manifesto Service para configurar o balanceamento de carga.
No diretório onde criou o ficheiro de manifesto de implementação, use um editor de texto para criar um ficheiro denominado dicom_adapter_load_balancer.yaml
com o seguinte conteúdo. Cria e implementa o ficheiro do manifesto do serviço
em Implementar o serviço e o balanceador de carga 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
Implemente a implementação
Para implementar o adaptador num cluster do GKE, execute o seguinte comando no diretório que contém o ficheiro de manifesto de implementação dicom_adapter.yaml:
kubectl apply -f dicom_adapter.yaml
O resultado é o seguinte:
deployment.apps/dicom-adapter created
Inspecione a implementação
Depois de criar a implementação, use a ferramenta kubectl para a inspecionar.
Para obter informações detalhadas sobre a implementação, execute o seguinte comando:
kubectl describe deployment dicom-adapter
Para ver o pod criado pela implementação, execute o seguinte comando:
kubectl get pods -l app=dicom-adapter
Para obter informações sobre o pod criado, execute o seguinte comando com o nome do pod devolvido pelo comando anterior:
kubectl describe pod POD_NAME
Se a implementação tiver sido bem-sucedida, a última parte do resultado do comando anterior contém as seguintes informações. O adaptador está pronto para publicar pedidos quando o contentor dicom-import-adapter tem o valor Started na coluna 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
Implemente o serviço e o balanceador de carga interno
Para criar o equilibrador de carga interno, no diretório que contém o
dicom_adapter_load_balancer.yaml ficheiro do manifesto do serviço, execute o seguinte comando:
kubectl apply -f dicom_adapter_load_balancer.yaml
O resultado é o seguinte:
service/dicom-adapter-load-balancer created
Inspecione o serviço
Depois de criar o serviço, inspecione-o para verificar se foi configurado corretamente.
Para inspecionar o balanceador de carga, execute o seguinte comando:
kubectl describe service dicom-adapter-load-balancer
O resultado é o seguinte:
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
O endereço IP LoadBalancer Ingress pode demorar até um minuto a ser preenchido.
Guarde o endereço IP LoadBalancer Ingress. Vai usá-lo para aceder ao Serviço
a partir do exterior do cluster na secção seguinte.
Crie uma máquina virtual do Compute Engine
Para simular o seu PACS no local, crie uma VM do Compute Engine para enviar pedidos para o adaptador DICOM. Uma vez que implementou um equilibrador de carga interno, a VM que criar e o cluster do GKE existente têm de estar na mesma região e usar a mesma rede da VPC.
Conclua os passos seguintes para criar uma instância de máquina virtual Linux no Compute Engine:
Consola
gcloud
Execute o comando gcloud compute instances create. O comando usa a etiqueta http-server para permitir o tráfego HTTP.
Antes de usar qualquer um dos dados de comandos abaixo, faça as seguintes substituições:
Execute o seguinte comando:
Linux, macOS ou 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
Deve receber uma resposta semelhante à seguinte:
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
Aguarde algum tempo para que a instância seja iniciada. Depois de a instância ser iniciada, é apresentada na página Instâncias de VM com um ícone de estado verde.
Estabeleça ligação à VM
Para estabelecer ligação à VM, conclua os seguintes passos:
Consola
gcloud
Execute o comando gcloud compute ssh.
Antes de usar qualquer um dos dados de comandos abaixo, faça as seguintes substituições:
Execute o seguinte comando:
Linux, macOS ou 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
Agora, tem uma janela de terminal para interagir com a sua instância do Linux.
Importe imagens DICOM para o arquivo DICOM
Existem várias opções de software disponíveis que pode usar para enviar imagens DICOM através de uma rede. Nas secções seguintes, vai usar o conjunto de ferramentas DICOM DCMTK.
Para importar imagens DICOM para o seu arquivo DICOM, conclua os seguintes passos a partir da VM que criou na secção anterior:
Depois de concluir esta secção, implementou com êxito o adaptador DICOM no GKE e enviou uma imagem DICOM de uma instância PACS através do adaptador para a Cloud Healthcare API.
Resolver problemas
Resolução de problemas do GKE
Se o adaptador DICOM encontrar uma falha após a implementação no GKE, siga os passos em Resolução de problemas com cargas de trabalho implementadas.
Resolução de problemas do transformador
Os adaptadores de importação e exportação geram registos que pode usar para diagnosticar
quaisquer problemas. Quando executa um adaptador através do GKE, os registos são armazenados no Cloud Logging. Para ver os registos,
conclua os seguintes passos através da Google Cloud consola ou da ferramentakubectl:
Consola
kubectl
Para ver todos os pods em execução no seu cluster, execute o seguinte comando:
kubectl get pods
Procure o Pod cujo nome começa por dicom-adapter.
Para obter os registos do pod, execute o seguinte comando:
kubectl logs POD_NAME
Se perdeu algum dos passos neste guia, o comando dcmsend pode não carregar as imagens. Para investigar este problema, execute novamente o comando com a flag -d (para "depuração"). O indicador imprime um registo mais detalhado das ações,
incluindo mensagens que fornecem informações sobre a falha.
Resolução de problemas de autorizações
As secções seguintes descrevem os erros que podem ocorrer no dcmsend quando as autorizações
são configuradas incorretamente.
Erro de associação anulada por par
O seguinte problema ocorre quando o tráfego de rede não consegue fluir do PACS para a porta 2575 do balanceador de carga:
cannot send SOP instance: Peer aborted Association (or never connected)
Para resolver este problema, certifique-se de que a VM PACS e o cluster GKE estão a ser executados na mesma rede da VPC. Se não estiverem a ser executados na mesma rede VPC, verifique o seguinte:
Este erro também pode ocorrer quando o serviço de balanceamento de carga ou o pod do adaptador não estão configurados corretamente no cluster do GKE. Para garantir que estão configurados corretamente, reveja as secções Inspeção da implementação e Inspeção do serviço neste guia.
Erro de APIs necessárias não ativadas
O seguinte problema ocorre quando a Cloud Healthcare API não foi ativada no projeto onde o cluster do GKE com o adaptador está em execução:
LO [Http_403, PERMISSION_DENIED, Cloud Healthcare API has not been u]
Para resolver este problema, certifique-se de que todas as APIs necessárias estão ativadas seguindo as instruções em Antes de começar.
Erro de âmbito insuficiente
O seguinte problema ocorre quando o cluster do GKE onde o adaptador está a ser executado não tem o valor de âmbito correto definido:
LO [Http_403, PERMISSION_DENIED, Request had insufficient authentica]
Para resolver este problema, atualize o cluster do GKE ou crie um novo cluster com a seguinte flag:
--scopes=https://www.googleapis.com/auth/cloud-healthcare
Erro de autorização de armazenamento DICOM negada
O seguinte erro ocorre quando a conta de serviço usada pelo cluster do GKE onde o adaptador está em execução não tem a função roles/healthcare.dicomEditor:
LO [Http_403, PERMISSION_DENIED, Permission healthcare.dicomStores.d]
Para resolver este problema, siga as instruções em Conceder autorizações à conta de serviço do Compute Engine.
O que se segue?
Depois de configurar o protótipo neste guia, pode começar a usar o Cloud VPN para encriptar o tráfego entre o seu PACS e a Cloud Healthcare API.