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

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

Il codelab di autorizzazione binaria dell'adattatore MLLP open source su GitHub mostra in dettaglio uno scenario simile.

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 file binario dell'adattatore MLLP.
  • Utilizza una configurazione multi-progetto per separare la responsabilità della firma delle immagini dall'ambiente di deployment.

Costi

In questo documento utilizzi 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 utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

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 fornisce una panoramica di MLLP, di come i sistemi sanitari possono inviare e ricevere messaggi da e verso l'API Cloud Healthcare tramite una connessione MLLP e le 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 e lo strumento a riga di comando kubectl. Google Cloud CLI fornisce l'interfaccia a riga di comando principale 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 console Google Cloud.

    Console Google Cloud

  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 la gcloud CLI.

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

    gcloud components install kubectl

Progetto container

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

Creazione di un keyring e di una coppia di chiavi

Il progetto Cloud KMS fornisce una firma PKIX (Public Key Infrastructure) (X.509) utilizzando Cloud KMS. L'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 contenitore. La coppia di chiavi è composta da una chiave privata, utilizzata dall'attestatore per firmare digitalmente le attestazioni, e da una chiave pubblica, che aggiungi all'attestatore come memorizzata dal servizio di autorizzazione binaria.

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

Per creare un keyring e una coppia di chiavi, completa i seguenti passaggi:

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

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

      Vai a Nuovo progetto

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

    Per scoprire di più sulla creazione dei progetti, consulta la pagina Creare e gestire progetti.

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

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

  3. Per creare un portachiavi, esegui il seguente comando, dove KEY_RING è un nome univoco per il portachiavi 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 seguente 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 il seguente 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, del set di dati e dell'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 console Google Cloud, vai alla pagina Nuovo progetto.

      Vai a Nuovo progetto

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

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

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

  3. Per creare un set di dati in cui archiviare l'archivio HL7v2, esegui il seguente comando:

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

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

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

Creazione di una nota di Artifact Analysis

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

Per creare una nota di Artifact Analysis:

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

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

      Vai a Nuovo progetto

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

  2. Per attivare l'API Artifact Analysis nel progetto di note, esegui il seguente 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 il seguente 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 di Artifact Analysis nel progetto di note, esegui il seguente 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. Per verificare che la nota sia stata creata, esegui il seguente 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 memorizza gli attestatori, che verificano o attestano che un'immagine del contenitore è pronta per il deployment.

Per creare e configurare un attestatore:

  1. Per creare il progetto di attestatore:

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

      Vai a Nuovo progetto

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

  2. Per abilitare le API Autorizzazione binaria e Cloud KMS nel progetto di attestatore, esegui i seguenti 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 nel progetto attestatore, esegui il comando seguente. L'attestatore utilizza la nota creata nel progetto di note 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 seguente comando:

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

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

    • Utilizza i valori di NOTE_PROJ_ID e NOTE_ID descritti in Creare una Artifact Analysis elementi.

    • Per trovare ATTESTOR_PROJECT_NUM, segui questi 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 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 all'account di servizio di autorizzazione binaria del progetto di attestazione l'autorizzazione di lettura delle occorrenze della nota di Artifact Analysis nel progetto della nota, esegui il seguente 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 la chiave generata nel progetto Cloud KMS all'attestatore, esegui il seguente 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 memorizza le attestazioni. Un'attestazione è una dichiarazione di un attestatore che attesta che una procedura richiesta nella pipeline è completata e che un'immagine del contenitore è autorizzata per il deployment.

Per creare un'attestazione:

  1. Per creare il progetto di attestazione:

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

      Vai a Nuovo progetto

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

  2. Per attivare l'API Binary Authorization nel progetto di attestazione, esegui il seguente comando:

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

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

Eseguire il deployment dell'adattatore MLLP

Il progetto di deployment è 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 di deployment:

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

      Vai a Nuovo progetto

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

  2. Per abilitare l'API Binary Authorization nel progetto di deployment, esegui il seguente comando:

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

  3. Per concedere all'account di servizio Autorizzazione binaria nel progetto di deployment l'autorizzazione di accesso all'attestatore per la verifica dell'attestazione, esegui il seguente 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 di deployment, esegui il seguente 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 le 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 chiamato ./tmp/policy.yaml, esegui il seguente 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 di deployment, esegui il seguente 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 controllare le credenziali del cluster GKE, esegui il seguente comando:

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

  9. Apporta le seguenti sostituzioni, quindi salva il file YAML di esempio in un file chiamato ./tmp/deployment.yaml eseguendo il seguente 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 il comando seguente:

    kubectl create -f ./tmp/deployment.yaml

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

    kubectl get pods
kubectl get event

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

Dopo aver completato questa sezione, avrai eseguito correttamente il deployment sicuro di un'immagine dell'adattatore MLLP autenticato in 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 eliminare le 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 di attestatore
  • Progetto di attestazione
  • Progetto del deployer
  • Progetto di note
  • Progetto Cloud KMS
  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.