Trasmissione di messaggi HL7v2 su connessioni TCP/IP utilizzando un'immagine MLLP firmata

Questo tutorial fornisce istruzioni per utilizzare Autorizzazione binaria come parte di un deployment MLLP (Minimal Layer Protocol) in una configurazione multiprogetto. L'utilizzo di Autorizzazione binaria su Google Kubernetes Engine garantisce che il deployment dell'adattatore MLLP possa essere eseguito solo da un'immagine container verificata e firmata.

Il codelab open source per MLLP dell'adattatore Autorizzazione binaria in GitHub mostra uno scenario simile in dettaglio.

Obiettivi

Al termine di questo tutorial, saprai come:

  • Configura un attestatore per attestare quando un'immagine MLLP è pronta per il deployment.
  • Esegui il deployment di un'immagine attestata del programma binario dell'adattatore MLLP.
  • Utilizza una configurazione multiprogetto per separare la responsabilità della firma delle immagini dall'ambiente di deployment.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

  • API Cloud Healthcare
  • Google Kubernetes Engine
  • Artifact Analysis
  • Cloud Key Management Service
  • Autorizzazione binaria

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Prerequisiti

Prima di iniziare questo tutorial, acquisisci familiarità con la documentazione concettuale su MLLP esaminando MLLP e l'adattatore MLLP di Google Cloud. La documentazione concettuale offre una panoramica di MLLP, di come i sistemi di assistenza possono inviare e ricevere messaggi da e verso l'API Cloud Healthcare tramite una connessione MLLP e le nozioni di base sulla sicurezza MLLP.

Scelta di una shell

Per completare questo tutorial, puoi utilizzare Cloud Shell o la tua shell locale.

Cloud Shell è un ambiente shell per la gestione delle risorse ospitate su Google Cloud. In Cloud Shell sono preinstallati Google Cloud CLI e lo strumento a riga di comando kubectl. gcloud CLI fornisce la principale interfaccia a riga di comando per Google Cloud. Lo strumento kubectl fornisce l'interfaccia a riga di comando per l'esecuzione di comandi sui cluster Kubernetes.

Se preferisci utilizzare la tua shell locale, devi installare Google Cloud CLI.

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

Cloud Shell

Per avviare Cloud Shell, completa i seguenti passaggi:

  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:

All'interno di un frame nella parte inferiore della console si apre una sessione di Cloud Shell. Utilizza questa shell per eseguire i comandi gcloud e kubectl.

Shell locale

Per installare gcloud CLI e lo strumento kubectl, completa questi passaggi:

  1. Installa e inizializza gcloud CLI.

  2. Installa lo strumento a riga di comando kubectl eseguendo questo comando:

    gcloud components install kubectl

Progetto container

Il progetto container cloud-healthcare-containers esiste già. Contiene le immagini dell'adattatore MLLP.

Creazione di un keyring e una coppia di chiavi

Il progetto Cloud KMS fornisce una firma dell'infrastruttura a chiave pubblica (X.509) (PKIX) utilizzando Cloud KMS. Autorizzazione binaria utilizza chiavi crittografiche per verificare in modo sicuro l'identità degli attestatori. In questo modo, solo le parti verificate possono partecipare all'autorizzazione di un'immagine container. La coppia di chiavi è composta da una chiave privata, che l'attestatore utilizza per firmare digitalmente le attestazioni, e una chiave pubblica, che puoi aggiungere all'attestatore così come memorizzata dal servizio di Autorizzazione binaria.

Se vuoi gestire localmente le coppie di chiavi private e pubbliche, il progetto Cloud KMS non è obbligatorio. Per ulteriori informazioni, consulta Utilizzo delle chiavi di crittografia gestite dal cliente.

Per creare un keyring e una coppia di chiavi, segui questi passaggi:

  1. Per creare il progetto Cloud KMS, segui questi passaggi:

    1. Nella console Google Cloud, vai alla pagina Nuovo progetto.

      Vai al nuovo progetto

    2. Compila il modulo e fai clic su Crea. In questo tutorial viene fatto riferimento al nome del progetto selezionato come KMS_PROJ_ID.

    Per ulteriori informazioni sulla creazione di progetti, consulta Creazione e gestione dei progetti.

  2. Per abilitare l'API Cloud KMS nel progetto Cloud KMS, esegui questo comando:

    gcloud services enable cloudkms.googleapis.com \
    --project=KMS_PROJ_ID

  3. Per creare un keyring, esegui questo comando, dove KEY_RING è un nome univoco per il keyring e KEY_RING_LOCATION è un'area geografica come us-central-1:

    gcloud kms keyrings create KEY_RING \
    --project=KMS_PROJ_ID \
    --location=KEY_RING_LOCATION

  4. Per creare una coppia di chiavi, esegui questo 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. Per verificare la versione della chiave nel progetto Cloud KMS, esegui questo comando. La versione della chiave deve essere 1.

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

Creazione e configurazione del progetto HL7v2, del set di dati e dell'archivio HL7v2

Per creare e configurare il progetto HL7v2, il set di dati e l'archivio HL7v2, completa i seguenti passaggi:

  1. Per creare il progetto HL7v2, completa i seguenti passaggi:

    1. Nella console Google Cloud, vai alla pagina Nuovo progetto.

      Vai al nuovo progetto

    2. Compila il modulo e fai clic su Crea. In questo tutorial viene fatto riferimento al nome del progetto selezionato come HL7V2_PROJ_ID.

  2. Per abilitare l'API Cloud Healthcare nel progetto, esegui questo comando:

    gcloud services enable healthcare.googleapis.com \
    --project=HL7V2_PROJ_ID

  3. Per creare un set di dati per archiviare l'archivio HL7v2, esegui questo comando:

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

  4. Per creare l'archivio HL7v2, esegui questo comando:

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

Creazione di una nota Artifact Analysis

Il progetto di nota è proprietario della nota Artifact Analysis.

Per creare una nota Artifact Analysis, completa i seguenti passaggi:

  1. Crea il progetto di nota completando i seguenti passaggi:

    1. Nella console Google Cloud, vai alla pagina Nuovo progetto.

      Vai al nuovo progetto

    2. Compila il modulo e fai clic su Crea. In questo tutorial viene fatto riferimento al nome del progetto selezionato come NOTE_PROJ_ID.

  2. Per abilitare l'API Artifact Analysis sul progetto di note, esegui questo comando:

    gcloud services enable containeranalysis.googleapis.com \
     --project=NOTE_PROJ_ID

  3. Per salvare il payload della nota di esempio in un file denominato ./tmp/note_payload.json, esegui questo comando:

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

  4. Per creare una nota Artifact Analysis nel progetto di nota, esegui il comando seguente:

    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. Per verificare che la nota sia stata creata, esegui questo comando:

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

Creazione e configurazione di un attestatore

Il progetto di attestatore archivia gli attestatori, che verificano o attestano che un'immagine container è pronta per il deployment.

Per creare e configurare un attestatore, completa i seguenti passaggi:

  1. Per creare il progetto di attestatore, completa i seguenti passaggi:

    1. Nella console Google Cloud, vai alla pagina Nuovo progetto.

      Vai al nuovo progetto

    2. Compila il modulo e fai clic su Crea. In questo tutorial viene fatto riferimento al nome del progetto selezionato come ATTESTOR_PROJ_ID.

  2. Per abilitare le API Autorizzazione binaria e Cloud KMS nel progetto attestatore, esegui questi comandi:

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

  3. Per creare un attestatore sul progetto di attestatore, esegui questo comando. L'attestatore utilizza la nota creata nel progetto di nota per l'attestazione.

    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. Per verificare che l'attestatore sia stato creato, esegui questo comando:

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

  5. Effettua le seguenti sostituzioni, quindi salva il JSON di esempio in un file con nome ./tmp/iam_request.json eseguendo questo comando:

    • Utilizza i valori NOTE_PROJ_ID e NOTE_ID della sezione Creazione di una nota Artifact Analysis.

    • Per trovare ATTESTOR_PROJECT_NUM, completa i seguenti passaggi:

      1. Vai alla pagina Dashboard nella console Google Cloud.

        Vai alla pagina Dashboard

      2. Fai clic sull'elenco a discesa Seleziona da nella parte superiore della pagina. Nella finestra Seleziona da visualizzata, seleziona il progetto di attestatore.

      Il numero del progetto viene visualizzato nella scheda Informazioni sul progetto della dashboard del progetto.

    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. Per concedere l'autorizzazione all'account di servizio di Autorizzazione binaria del progetto di attestatore per leggere le occorrenze della nota Artifact Analysis nel progetto nota, esegui questo 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. Per aggiungere all'attestatore la chiave generata nel progetto Cloud KMS, esegui questo 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

Creazione di un'attestazione

Il progetto di attestazione archivia le attestazioni. Un'attestazione è una dichiarazione di un attestatore che indica che un processo richiesto nella pipeline è completo e che il deployment di un'immagine container è autorizzato.

Per creare un'attestazione, completa i seguenti passaggi:

  1. Per creare il progetto di attestazione, completa i seguenti passaggi:

    1. Nella console Google Cloud, vai alla pagina Nuovo progetto.

      Vai al nuovo progetto

    2. Compila il modulo e fai clic su Crea. In questo tutorial viene fatto riferimento al nome del progetto selezionato come ATTESTATION_PROJ_ID.

  2. Per abilitare l'API Binary Authorization sul progetto di attestazione, esegui questo comando:

    gcloud services enable binaryauthorization.googleapis.com \
    --project=ATTESTATION_PROJ_ID

  3. Per firmare e creare l'attestazione, esegui questo comando, dove IMAGE_SIGNED è la posizione dell' immagine dell'adattatore MLLP firmata, 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

Deployment dell'adattatore MLLP

Il progetto Deployer è proprietario del cluster GKE in cui Autorizzazione binaria viene importata e archiviata.

Per eseguire il deployment dell'adattatore MLLP, completa i seguenti passaggi:

  1. Per creare il progetto del deployment, completa i seguenti passaggi:

    1. Nella console Google Cloud, vai alla pagina Nuovo progetto.

      Vai al nuovo progetto

    2. Compila il modulo e fai clic su Crea. In questo tutorial viene fatto riferimento al nome del progetto selezionato come DEPLOYER_PROJ_ID.

  2. Per abilitare l'API Binary Authorization sul progetto del deployer, esegui questo comando:

    gcloud services enable binaryauthorization.googleapis.com \
    --project=DEPLOYER_PROJ_ID

  3. Per concedere all'account di servizio Autorizzazione binaria l'autorizzazione del progetto deployer per accedere all'attestatore per la verifica dell'attestazione, esegui questo 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. Per creare un cluster con --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE nel progetto deployer, esegui questo comando:

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

  5. Il criterio di deployment di esempio aggiunge origini delle immagini alla lista consentita e imposta una regola predefinita per l'ambito del progetto per bloccare le immagini provenienti da origini che non sono state attestate dall'attestatore. Per salvare il criterio di deployment di esempio in un file denominato ./tmp/policy.yaml, esegui questo 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. Per importare il criterio di deployment nel progetto del deployer, esegui questo comando:

    gcloud beta container binauthz policy import ./tmp/policy.yaml \
    --project=DEPLOYER_PROJ_ID

  7. Per visualizzare i dettagli del criterio, vai alla pagina Autorizzazione binaria nella console Google Cloud.

    Vai alla pagina Autorizzazione binaria

  8. Per verificare le credenziali del cluster GKE, esegui questo comando:

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

  9. Effettua le sostituzioni seguenti e salva il file YAML di esempio in un file denominato ./tmp/deployment.yaml eseguendo questo 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. Per creare un deployment con l'immagine attestata, esegui questo comando:

    kubectl create -f ./tmp/deployment.yaml

  11. Per confermare che il deployment sia riuscito, esegui questi comandi:

    kubectl get pods
kubectl get event

    Il comando get pods mostra un pod in esecuzione, mentre get event mostra Scaled up replica set mllp-adapter-deployment-xxxx to 1.

Dopo aver completato questa sezione, hai eseguito correttamente il deployment di un'immagine adattatore MLLP attestata su Google Kubernetes Engine.

Eliminazione dei progetti

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, puoi eseguire la pulizia delle risorse che hai creato su Google Cloud.

Per eliminare i seguenti progetti creati in questo tutorial:

  • Progetto attestatore
  • Progetto di attestazione
  • Progetto Deployer
  • Progetto nota
  • Progetto Cloud KMS
  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.