Transmitir mensajes HL7v2 a través de conexiones TCP/IP con una imagen de MLLP firmada

En este instructivo, se proporcionan instrucciones para usar la autorización binaria como parte de una implementación del protocolo de capa mínima inferior (MLLP) en una configuración de varios proyectos. El uso de la autorización binaria en Google Kubernetes Engine garantiza que el adaptador MLLP solo se pueda implementar desde una imagen de contenedor verificada y firmada.

El codelab de autorización binaria del adaptador MLLP de código abierto en GitHub muestra una situación similar en detalle.

Objetivos

Después de completar el instructivo, sabrás cómo realizar la siguiente actividad:

Configura un certificador con el fin de certificar cuando una imagen MLLP está lista para la implementación.
Implementa una imagen certificada del objeto binario del adaptador de MLLP.
Usa una configuración de varios proyectos para separar la responsabilidad de firmar imágenes del entorno de implementación.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

API de Cloud Healthcare
Google Kubernetes Engine
Artifact Analysis
Cloud Key Management Service
Autorización Binaria

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Requisitos previos

Antes de comenzar este instructivo, familiarízate con la documentación conceptual sobre MLLP mediante la revisión de MLLP y el adaptador de MLLP de Google Cloud. La documentación conceptual proporciona una descripción general de MLLP, cómo los sistemas de cuidado pueden enviar y recibir mensajes hacia y desde la API de Cloud Healthcare a través de una conexión MLLP y los conceptos básicos de seguridad de MLLP.

Elige un shell

Para completar este instructivo, puedes usar Cloud Shell o tu shell local.

Cloud Shell es un entorno de shell que se usa para administrar recursos alojados en Google Cloud. Cloud Shell ya viene instalado en Google Cloud CLI y la herramienta de línea de comandos de kubectl. La gcloud CLI proporciona la interfaz de línea de comandos principal para Google Cloud. La herramienta de kubectl proporciona la interfaz de línea de comandos para ejecutar comandos con clústeres de Kubernetes.

Si prefieres usar tu shell local, debes instalar Google Cloud CLI.

Para abrir Cloud Shell o configurar tu shell local, completa los siguientes pasos:

Cloud Shell

Para iniciar Cloud Shell, sigue estos pasos:

Ve a la consola de Google Cloud.

Consola de Google Cloud
En la esquina superior derecha de la consola, haz clic en el botón Activar Google Cloud Shell:

Se abrirá una sesión de Cloud Shell dentro de un marco en la parte inferior de la consola. Usa este shell para ejecutar los comandos gcloud y kubectl.

Shell local

Para instalar la CLI de gcloud y la herramienta de kubectl, completa los siguientes pasos:

Instala e inicializa la CLI de gcloud
Para instalar la herramienta de línea de comandos de kubectl, ejecuta el siguiente comando:
```
gcloud components install kubectl
```

Proyecto del contenedor

El proyecto de contenedor, cloud-healthcare-containers, ya existe. Contiene las imágenes del adaptador de MLLP.

Crea un llavero de claves y un par de claves

El proyecto de Cloud KMS ofrece una firma de infraestructura de clave pública (X.509) (PKIX) mediante Cloud KMS. La autorización binaria usa claves criptográficas para verificar de forma segura la identidad de los certificadores. Esto garantiza que solo las partes verificadas puedan participar en la autorización de una imagen de contenedor. El par de claves consta de una clave privada, que el certificador usa para firmar de forma digital las certificaciones, y una clave pública, que se agrega al certificador que almacenó el servicio de autorización binaria.

Si quieres administrar pares de claves públicas y privadas a nivel local, el proyecto de Cloud KMS no es obligatorio. Para obtener más información, consulta la página sobre Usa claves de encriptación administradas por el cliente.

Para crear un llavero de claves y un par de claves, completa los siguientes pasos:

Crea el proyecto de Cloud KMS mediante los siguientes pasos:
1. En la consola de Google Cloud, ve a la página Proyecto nuevo.
  Ir a Proyecto nuevo
2. Completa el formulario y, luego, haz clic en Crear. El nombre del proyecto que selecciones se menciona como KMS_PROJ_ID en todo este instructivo.
Para obtener más información sobre cómo crear proyectos, consulta Crea y administra proyectos.
Para habilitar la API de Cloud KMS en el proyecto de Cloud KMS, ejecuta el siguiente comando:
```
gcloud services enable cloudkms.googleapis.com \
    --project=KMS_PROJ_ID
```
Si deseas crear un llavero de claves, ejecuta el siguiente comando, en el que KEY_RING es un nombre único para el llavero de claves y KEY_RING_LOCATION es una región como us-central-1:
```
gcloud kms keyrings create KEY_RING \
    --project=KMS_PROJ_ID \
    --location=KEY_RING_LOCATION
```

Para crear un par de claves, ejecuta el siguiente comando:

gcloud kms keys create KEY \
    --project=KMS_PROJ_ID \
    --keyring=KEY_RING \
    --location=KEY_RING_LOCATION \
    --purpose=asymmetric-signing \
    --default-algorithm="ec-sign-p256-sha256"

Para verificar la versión de clave del proyecto de Cloud KMS, ejecuta el siguiente comando: La versión de clave debe ser 1.

gcloud kms keys versions list \
    --project=KMS_PROJ_ID \
    --location=KEY_RING_LOCATION \
    --key=KEY \
    --keyring=KEY_RING

Crea y configura el proyecto, el conjunto de datos y la tienda de HL7v2

Para crear y configurar el proyecto HL7v2, el conjunto de datos y la tienda HL7v2, completa los siguientes pasos:

Para crear el proyecto HL7v2, completa los siguientes pasos:
1. En la consola de Google Cloud, ve a la página Proyecto nuevo.
  Ir a Proyecto nuevo
2. Completa el formulario y, luego, haz clic en Crear. El nombre del proyecto que selecciones se menciona como HL7V2_PROJ_ID en todo este instructivo.
Para habilitar la API de Cloud Healthcare en el proyecto, ejecuta el siguiente comando:
```
gcloud services enable healthcare.googleapis.com \
    --project=HL7V2_PROJ_ID
```

Si deseas crear un conjunto de datos para almacenar la tienda HL7v2, ejecuta el siguiente comando:

gcloud healthcare datasets create DATASET_ID \
    --location=HL7V2_STORE_LOCATION \
    --project=HL7V2_PROJ_ID

Para crear la tienda HL7v2, ejecute el siguiente comando:

gcloud healthcare hl7v2-stores create HL7V2_STORE_ID \
    --dataset=DATASET_ID \
    --location=HL7V2_STORE_LOCATION \
    --project=HL7V2_PROJ_ID

Crea una nota de Artifact Analysis

El proyecto de la nota es propietario de la nota de Artifact Analysis.

Para crear una nota de Artifact Analysis, completa los siguientes pasos:

Para crear el proyecto de nota, completa los siguientes pasos:
1. En la consola de Google Cloud, ve a la página Proyecto nuevo.
  Ir a Proyecto nuevo
2. Completa el formulario y, luego, haz clic en Crear. El nombre del proyecto que selecciones se menciona como NOTE_PROJ_ID en todo este instructivo.
Para habilitar la API de Artifact Analysis en el proyecto de la nota, ejecuta el siguiente comando:
```
gcloud services enable containeranalysis.googleapis.com \
     --project=NOTE_PROJ_ID
```

Para guardar la carga útil de la nota de muestra en un archivo llamado ./tmp/note_payload.json, ejecuta el siguiente comando:

cat > ./tmp/note_payload.json << EOM
{
  "name": "projects/NOTE_PROJ_ID/notes/NOTE_ID",
  "attestation": {
    "hint": {
      "human_readable_name": "Attestor note"
    }
  }
}
EOM

Para crear una nota de Artifact Analysis en el proyecto de la nota, ejecuta el siguiente comando:

curl -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)"  \
    --data-binary @./tmp/note_payload.json  \
    "https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/?noteId=NOTE_ID"

Para verificar que se haya creado la nota, ejecuta el comando siguiente:

curl \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
"https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/NOTE_ID"

Crea y configura un certificador

El proyecto certificador almacena certificadores, que verifican o certifican que una imagen de contenedor está lista para su implementación.

Para crear y configurar un certificador, completa los siguientes pasos:

Para crear el proyecto certificador, completa los siguientes pasos:
1. En la consola de Google Cloud, ve a la página Proyecto nuevo.
  Ir a Proyecto nuevo
2. Completa el formulario y, luego, haz clic en Crear. El nombre del proyecto que selecciones se menciona como ATTESTOR_PROJ_ID en todo este instructivo.

Para habilitar las API de autorización binaria y Cloud KMS en el proyecto de certificador, ejecuta los siguientes comandos:

gcloud services enable binaryauthorization.googleapis.com \
    --project=ATTESTOR_PROJ_ID
gcloud services enable cloudkms.googleapis.com \
    --project=ATTESTOR_PROJ_ID

Para crear un certificador en el proyecto del certificador, ejecuta el siguiente comando. El certificador usa la nota creada en el proyecto de nota para la certificación.

gcloud beta container binauthz attestors create ATTESTOR_ID \
    --project=ATTESTOR_PROJ_ID \
    --attestation-authority-note=NOTE_ID \
    --attestation-authority-note-project=NOTE_PROJ_ID

Para verificar que se creó el certificador, ejecuta el siguiente comando:

gcloud beta container binauthz attestors list \
    --project=ATTESTOR_PROJ_ID

Realiza las siguientes sustituciones y guarda el JSON de muestra en un archivo llamado ./tmp/iam_request.json mediante la ejecución del siguiente comando:
- Usa los valores de NOTE_PROJ_ID y NOTE_ID de Crea una nota de Artifact Analysis.
- Para encontrar el ATTESTOR_PROJECT_NUM, completa los siguientes pasos:
  1. Ve a la página Panel en la consola de Google Cloud.
    Ir a la página Panel
  2. Haz clic en la lista desplegable Seleccionar desde en la parte superior de la página. En la ventana Seleccionar desde que aparece, selecciona el proyecto del certificador.
  El número de proyecto se muestra en la tarjeta Información del proyecto del panel del proyecto.
```
cat > ./tmp/iam_request.json << EOM
{
  "resource": "projects/NOTE_PROJ_ID/notes/NOTE_ID",
  "policy": {
    "bindings": [
      {
        "role": "roles/containeranalysis.notes.occurrences.viewer",
        "members": [
          "serviceAccount:service-ATTESTOR_PROJ_NUM@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
        ]
      }
    ]
  }
}
EOM
```

Si quieres otorgar permiso a la cuenta de servicio de autorización binaria del proyecto del certificador para leer los casos de notas de Artifact Analysis en el proyecto de notas, ejecuta el siguiente comando:

curl -X POST  \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    --data-binary @./tmp/iam_request.json \
"https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/NOTE_ID:setIamPolicy"

Para agregar la clave generada en el proyecto de Cloud KMS al certificador, ejecuta el siguiente comando:

gcloud beta container binauthz attestors public-keys add  \
    --project=ATTESTOR_PROJ_ID \
    --attestor=ATTESTOR_ID  \
    --keyversion-project=KMS_PROJ_ID  \
    --keyversion-location=KEY_RING_LOCATION \
    --keyversion-keyring=KEY_RING \
    --keyversion-key=KEY \
    --keyversion=KEY_VERSION

Crea una certificación

El proyecto de certificación almacena certificaciones. Una certificación es una declaración de un certificador que completa un proceso requerido en tu canalización y una imagen de contenedor autorizada para la implementación.

Para crear una certificación, sigue estos pasos:

Para crear el proyecto de certificación, completa los siguientes pasos:
1. En la consola de Google Cloud, ve a la página Proyecto nuevo.
  Ir a Proyecto nuevo
2. Completa el formulario y, luego, haz clic en Crear. El nombre del proyecto que selecciones se menciona como ATTESTATION_PROJ_ID en todo este instructivo.
Para habilitar la API de autorización binaria en el proyecto de certificación, ejecuta el siguiente comando:
```
gcloud services enable binaryauthorization.googleapis.com \
    --project=ATTESTATION_PROJ_ID
```

Para firmar y crear la certificación, ejecute el siguiente comando, IMAGE_SIGNED es la ubicación de la Imagen del adaptador de MLLP firmada, gcr.io/cloud-healthcare-containers/mllp-adapter@sha256:231b073df13db0c65e57b0e1d526ab6816a73c37262e25c18bcca99bf4b4b185:

gcloud beta container binauthz attestations sign-and-create \
    --project=ATTESTATION_PROJ_ID \
    --artifact-url=IMAGE_SIGNED \
    --attestor=ATTESTOR_ID \
    --attestor-project=ATTESTOR_PROJ_ID \
    --keyversion-project=KMS_PROJ_ID \
    --keyversion-location=KEY_RING_LOCATION \
    --keyversion-keyring=KEY_RING \
    --keyversion-key=KEY \
    --keyversion=KEY_VERSION

Implementa el adaptador de MLLP

El proyecto implementador es propietario del clúster de GKE en el que se importa y almacena la autorización binaria.

Para implementar el adaptador de MLLP, completa los siguientes pasos:

Para crear el proyecto del implementador, completa los pasos siguientes:
1. En la consola de Google Cloud, ve a la página Proyecto nuevo.
  Ir a Proyecto nuevo
2. Completa el formulario y, luego, haz clic en Crear. El nombre del proyecto que selecciones se menciona como DEPLOYER_PROJ_ID en todo este instructivo.
Para habilitar la API de autorización binaria en el proyecto del implementador, ejecuta el siguiente comando:
```
gcloud services enable binaryauthorization.googleapis.com \
    --project=DEPLOYER_PROJ_ID
```

Para otorgar permiso a la cuenta de servicio de autorización binaria en el proyecto de implementación a fin de acceder al certificador para la verificación, ejecuta el siguiente comando:

gcloud beta container binauthz attestors add-iam-policy-binding \
    "projects/ATTESTOR_PROJ_ID/attestors/ATTESTOR_ID" \
    --project=ATTESTOR_PROJ_ID \
    --member="serviceAccount:service-DEPLOYER_PROJ_NUM@gcp-sa-binaryauthorization.iam.gserviceaccount.com" \
    --role=roles/binaryauthorization.attestorsVerifier

Para crear un clúster con --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE en el proyecto de implementación, ejecuta el siguiente comando:

gcloud beta container clusters create CLUSTER_NAME \
    --project=DEPLOYER_PROJ_ID \
    --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
    --zone CLUSTER_ZONE

La política de implementación de muestra agrega fuentes de imágenes a la lista de entidades permitidas y establece una regla predeterminada de alcance del proyecto para bloquear las imágenes de las fuentes que el certificador no probó. Para guardar la política de implementación de muestra en un archivo llamado ./tmp/policy.yaml, ejecuta el siguiente comando:

cat > ./tmp/policy.yaml << EOM
    admissionWhitelistPatterns:
    - namePattern: gcr.io/google_containers/*
    - namePattern: gcr.io/google-containers/*
    - namePattern: k8s.gcr.io/*
    - namePattern: gcr.io/stackdriver-agents/*
    defaultAdmissionRule:
      evaluationMode: REQUIRE_ATTESTATION
      enforcementMode: ENFORCED_BLOCK_AND_AUDIT_LOG
      requireAttestationsBy:
        - projects/ATTESTOR_PROJ_ID/attestors/ATTESTOR_ID
    name: projects/DEPLOYER_PROJ_ID/policy
EOM

Para importar la política de implementación en el proyecto del implementador, ejecuta el siguiente comando:
```
gcloud beta container binauthz policy import ./tmp/policy.yaml \
    --project=DEPLOYER_PROJ_ID
```
Para ver los detalles de la política, ve a la página Autorización binaria en la consola de Google Cloud.

Ir a la página Autorización binaria

Para verificar las credenciales del clúster de GKE, ejecute el siguiente comando:

gcloud container clusters get-credentials \
    --project=DEPLOYER_PROJ_ID \
    --zone CLUSTER_ZONE CLUSTER_NAME

Realiza las siguientes sustituciones y guarda el YAML de muestra en un archivo llamado ./tmp/deployment.yaml mediante la ejecución del siguiente comando:

IMAGE_SIGNED es la ubicación de la imagen del adaptador de MLLP firmada, gcr.io/cloud-healthcare-containers/mllp-adapter@sha256:231b073df13db0c65e57b0e1d526ab6816a73c37262e25c18bcca99bf4b4b185.
Usa los valores de HL7V2_PROJ_ID, HL7V2_STORE_LOCATION, DATASET_ID y HL7V2_STORE_ID que usaste en Crea y configura el proyecto, el conjunto de datos y la tienda HL7v2.

cat > ./tmp/deployment.yaml << EOM
 apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: mllp-adapter-deployment
 spec:
   replicas: 1
   selector:
     matchLabels:
       app: mllp-adapter
   template:
     metadata:
       labels:
         app: mllp-adapter
     spec:
       containers:
         - name: mllp-adapter
           imagePullPolicy: Always
           image: IMAGE_SIGNED
           ports:
             - containerPort: 2575
               protocol: TCP
               name: "port"
           command:
             - "/usr/mllp_adapter/mllp_adapter"
             - "--hl7_v2_project_id=HL7V2_PROJ_ID"
             - "--hl7_v2_location_id=HL7V2_STORE_LOCATION"
             - "--hl7_v2_dataset_id=DATASET_ID"
             - "--hl7_v2_store_id=HL7V2_STORE_ID"
             - "--api_addr_prefix=https://healthcare.googleapis.com:443/v1beta1"
             - "--logtostderr"
             - "--receiver_ip=0.0.0.0"
EOM

Para crear una implementación con la imagen certificada, ejecuta el siguiente comando:
```
kubectl create -f ./tmp/deployment.yaml
```
Para confirmar que la implementación se realizó correctamente, ejecuta los siguientes comandos:
```
kubectl get pods
kubectl get event
```
El comando get pods muestra un pod en ejecución y get event muestra Scaled up replica set mllp-adapter-deployment-xxxx to 1.

Después de completar esta sección, implementaste de manera correcta una imagen de adaptador de MLLP certificada en Google Kubernetes Engine.

Borra los proyectos

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos utilizados en este instructivo, puedes limpiar los recursos que creaste en Google Cloud.

Sigue los pasos a continuación para borrar los siguientes proyectos que creaste en este instructivo:

Proyecto de certificador
Proyecto de certificación
Proyecto de implementación
Proyecto de nota
Proyecto de Cloud KMS

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

En la consola de Google Cloud, ve a la página Administrar recursos.
Ir a Administrar recursos
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.