Transmite 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 instructivo, se usan los siguientes componentes facturables de Google Cloud:

  • Cloud Healthcare API
  • Google Kubernetes Engine
  • Container Analysis
  • Cloud Key Management Service
  • Autorización binaria

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Los usuarios nuevos de Cloud Platform podrían cumplir con los requisitos para obtener una prueba gratuita.

Requisitos

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 con la herramienta de línea de comandos de gcloud y la herramienta de línea de comandos de kubectl. La herramienta de gcloud proporciona la interfaz de línea de comandos principal para GCP. 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 el SDK de Cloud, que incluye la herramienta gcloud y la herramienta kubectl.

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

Cloud Shell

Para iniciar Cloud Shell, sigue estos pasos:

  1. Ve a Google Cloud Console

    Google Cloud Console

  2. 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 las herramientas gcloud y kubectl, completa los siguientes pasos:

  1. Instala e inicializa el SDK de Cloud.

  2. 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:

  1. Crea el proyecto de Cloud KMS mediante los siguientes pasos:

    1. En Cloud Console, ve a la página Proyecto nuevo.

      Ir a la página 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.

  2. 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
    
  3. 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
    
  4. 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"
    
  5. 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:

  1. Para crear el proyecto HL7v2, completa los siguientes pasos:

    1. En Cloud Console, ve a la página Proyecto nuevo.

      Ir a la página 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.

  2. Para habilitar la API de Cloud Healthcare en el proyecto, ejecuta el siguiente comando:

    gcloud services enable healthcare.googleapis.com \
        --project=HL7V2_PROJ_ID
    
  3. 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
    
  4. 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 Container Analysis

El proyecto de nota posee la nota de Container Analysis.

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

  1. Para crear el proyecto de nota, completa los siguientes pasos:

    1. En Cloud Console, ve a la página Proyecto nuevo.

      Ir a la página 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.
  2. Para habilitar la API de Container Analysis en el proyecto de nota, ejecuta el siguiente comando:

    gcloud services enable containeranalysis.googleapis.com \
         --project=NOTE_PROJ_ID
    
  3. 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
    
  4. Para crear una nota de Container Analysis en el proyecto de 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"
    
  5. 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:

  1. Para crear el proyecto certificador, completa los siguientes pasos:

    1. En Cloud Console, ve a la página Proyecto nuevo.

      Ir a la página 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.
  2. 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
    
  3. 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
    
  4. Para verificar que se creó el certificador, ejecuta el siguiente comando:

    gcloud beta container binauthz attestors list \
        --project=ATTESTOR_PROJ_ID
    
  5. 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 Container Analysis.
    • Para encontrar el ATTESTOR_PROJECT_NUM, completa los siguientes pasos:

      1. Ve a la página Panel en Cloud Console.

        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
    
  6. A fin de otorgar permiso a la cuenta de servicio de autorización binaria del proyecto certificador para leer los casos de la nota de Container Analysis en el proyecto de 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/iam_request.json \
    "https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/NOTE_ID:setIamPolicy"
    
  7. 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:

  1. Para crear el proyecto de certificación, completa los siguientes pasos:

    1. En Cloud Console, ve a la página Proyecto nuevo.

      Ir a la página 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.
  2. 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
    
  3. 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:

  1. Para crear el proyecto del implementador, completa los pasos siguientes:

    1. En Cloud Console, ve a la página Proyecto nuevo.

      Ir a la página 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.
  2. 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
    
  3. 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
    
  4. Para crear un clúster con --enable-binauthz en el proyecto de implementación, ejecuta el siguiente comando:

    gcloud beta container clusters create CLUSTER_NAME \
        --project=DEPLOYER_PROJ_ID \
        --enable-binauthz \
        --zone CLUSTER_ZONE
    
  5. La política de implementación de muestra agrega fuentes de imágenes a la lista blanca 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
    
  6. 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
    
  7. Para ver los detalles de la política, ve a la página de autorización binaria en Google Cloud Console.

    Ir a la página Autorización binaria

  8. 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
    
  9. Realiza las siguientes sustituciones y guarda el YAML de muestra en un archivo llamado ./tmp/deployment.yaml mediante la ejecución del siguiente comando:

    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
    
  10. Para crear una implementación con la imagen certificada, ejecuta el siguiente comando:

    kubectl create -f ./tmp/deployment.yaml
    
  11. 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
  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
  3. En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.