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

Questo tutorial fornisce istruzioni per l'utilizzo di Autorizzazione binaria come parte di un deployment del protocollo di livello inferiore minimo (MLLP) in una configurazione multi-progetto. L'utilizzo di Autorizzazione binaria su Google Kubernetes Engine garantisce che l'adattatore MLLP possa essere sottoposto a deployment solo da un'immagine container verificata e firmata.

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

Obiettivi

Al termine di questo tutorial, saprai come:

  • Configurare un attestatore per attestare quando un'immagine MLLP è pronta per il deployment.
  • Eseguire il deployment di un'immagine attestata del file binario dell'adattatore MLLP.
  • Utilizzare una configurazione multi-progetto 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:

  • Cloud Healthcare API
  • Google Kubernetes Engine
  • Artifact Analysis
  • Cloud Key Management Service
  • Binary Authorization

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi Google Cloud utenti potrebbero avere diritto a una prova senza costi.

Prerequisiti

Prima di iniziare questo tutorial, familiarizza con la documentazione concettuale su MLLP esaminando MLLP e l'adattatore Google Cloud MLLP. La documentazione concettuale fornisce 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 delle nozioni di base sulla sicurezza MLLP.

Scegliere 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. Cloud Shell include l'interfaccia a riga di comando Google Cloud CLI e lo strumento a riga di comando kubectl. gcloud CLI fornisce l'interfaccia a riga di comando principale per 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 shell locale, devi installare Google Cloud CLI.

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

Cloud Shell

Per avviare Cloud Shell, completa i seguenti passaggi:

  1. Vai alla Google Cloud console.

    Google Cloud console

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

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

Shell locale

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

  1. Installa e inizializza gcloud CLI.

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

    gcloud components install kubectl

Progetto container

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

Creare una chiave automatizzata 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 è costituita da una chiave privata, che l'attestatore utilizza per firmare digitalmente le attestazioni, e da una chiave pubblica, che aggiungi all'attestatore come archiviata dal servizio Autorizzazione binaria.

Se vuoi gestire le coppie di chiavi private e pubbliche localmente, il progetto Cloud KMS non è obbligatorio. Per saperne di più, vedi Utilizzare le chiavi di crittografia gestite dal cliente.

Per creare una chiave automatizzata e una coppia di chiavi, completa i seguenti passaggi:

  1. Crea il progetto Cloud KMS completando i seguenti passaggi:

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

      Vai a Nuovo progetto

    2. Compila il modulo e fai clic su Crea. Il nome del progetto selezionato viene indicato come KMS_PROJ_ID in questo tutorial.

    Per saperne di più sulla creazione di progetti, vedi Creare e gestire progetti.

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

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

  3. Per creare una chiave automatizzata, esegui il comando seguente, dove KEY_RING è un nome univoco per la chiave automatizzata e KEY_RING_LOCATION è una regione 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 il comando seguente:

    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 il comando seguente. 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

Creare e configurare il progetto, il set di dati e l'archivio HL7v2

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

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

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

      Vai a Nuovo progetto

    2. Compila il modulo e fai clic su Crea. Il nome del progetto selezionato viene indicato come HL7V2_PROJ_ID in questo tutorial.

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

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

  3. Per creare un set di dati per archiviare il datastore HL7v2, esegui il comando seguente:

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

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

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

Creare una nota di Artifact Analysis

Il progetto della nota è proprietario della nota di Artifact Analysis.

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

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

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

      Vai a Nuovo progetto

    2. Compila il modulo e fai clic su Crea. Il nome del progetto selezionato viene indicato come NOTE_PROJ_ID in questo tutorial.

  2. Per abilitare l'API Artifact Analysis nel progetto della nota, esegui il comando seguente:

    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 il comando seguente:

    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 di Artifact Analysis nel progetto della 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 il comando seguente:

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

Creare e configurare un attestatore

Il progetto dell'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 dell'attestatore, completa i seguenti passaggi:

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

      Vai a Nuovo progetto

    2. Compila il modulo e fai clic su Crea. Il nome del progetto selezionato viene indicato come ATTESTOR_PROJ_ID in questo tutorial.

  2. Per abilitare le API Autorizzazione binaria e Cloud KMS nel progetto dell'attestatore, esegui i comandi seguenti:

    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 nel progetto dell'attestatore, esegui il comando seguente. L'attestatore utilizza la nota creata nel progetto della 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 il comando seguente:

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

  5. Esegui le seguenti sostituzioni, quindi salva il JSON di esempio in un file denominato ./tmp/iam_request.json eseguendo il comando seguente:

    • Utilizza i valori di NOTE_PROJ_ID e NOTE_ID da Creare una nota di Artifact Analysis.

    • Per trovare ATTESTOR_PROJECT_NUM, completa i seguenti passaggi:

      1. Vai alla pagina Dashboard nella Google Cloud console.

        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 dell'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 al account di servizio Autorizzazione binaria del progetto dell'attestatore l'autorizzazione a leggere le occorrenze delle note di Artifact Analysis nel progetto della 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/iam_request.json \
"https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/NOTE_ID:setIamPolicy"

  7. Per aggiungere la chiave generata nel progetto Cloud KMS all'attestatore, esegui il comando seguente:

    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

Creare un'attestazione

Il progetto di attestazione archivia le attestazioni. Un'attestazione è una dichiarazione di un attestatore che indica che un processo obbligatorio nella pipeline è stato completato e che un'immagine container è autorizzata per il deployment.

Per creare un'attestazione, completa i seguenti passaggi:

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

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

      Vai a Nuovo progetto

    2. Compila il modulo e fai clic su Crea. Il nome del progetto selezionato viene indicato come ATTESTATION_PROJ_ID in questo tutorial.

  2. Per abilitare l'API Autorizzazione binaria nel progetto di attestazione, esegui il comando seguente:

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

  3. Per firmare e creare l'attestazione, esegui il comando seguente, 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

Eseguire il deployment dell'adattatore MLLP

Il progetto del deployer è proprietario del cluster GKE in cui viene importata e archiviata l'autorizzazione binaria.

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

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

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

      Vai a Nuovo progetto

    2. Compila il modulo e fai clic su Crea. Il nome del progetto selezionato viene indicato come DEPLOYER_PROJ_ID in questo tutorial.

  2. Per abilitare l'API Autorizzazione binaria nel progetto del deployer, esegui il comando seguente:

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

  3. Per concedere al account di servizio Autorizzazione binaria nel progetto del deployer l'autorizzazione ad accedere all'attestatore per la verifica dell'attestazione, esegui il comando seguente:

    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 del deployer, esegui il comando seguente:

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

  5. La policy di deployment di esempio aggiunge le origini delle immagini all'allowlist e imposta una regola predefinita con ambito progetto per bloccare le immagini provenienti da origini che non sono state attestate dall'attestatore. Per salvare la policy di deployment di esempio in un file denominato ./tmp/policy.yaml, esegui il comando seguente:

    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 la policy di deployment nel progetto del deployer, esegui il comando seguente:

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

  7. Per visualizzare i dettagli della policy, vai alla pagina Autorizzazione binaria in the Google Cloud console.

    Vai alla pagina Autorizzazione binaria

  8. Per estrarre le credenziali del cluster GKE, esegui il comando seguente:

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

  9. Esegui le seguenti sostituzioni, quindi salva il YAML di esempio in un file denominato ./tmp/deployment.yaml eseguendo il comando seguente:

    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 il comando seguente:

    kubectl create -f ./tmp/deployment.yaml

  11. Per verificare che il deployment sia andato a buon fine, esegui i comandi seguenti:

    kubectl get pods
kubectl get event

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

Al termine di questa sezione, hai eseguito il deployment sicuro di un'immagine dell'adattatore MLLP attestata su Google Kubernetes Engine.

Eliminare i progetti

Per evitare che al tuo Google Cloud account vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, puoi liberare spazio dalle risorse che hai creato su Google Cloud.

Segui i passaggi riportati di seguito per eliminare i seguenti progetti che hai creato in questo tutorial:

  • Progetto dell'attestatore
  • Progetto di attestazione
  • Progetto del deployer
  • Progetto della nota
  • Progetto Cloud KMS
  1. Nella Google Cloud console, 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 progetto, quindi fai clic su Chiudi per eliminare il progetto.