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 il deployment minimo del protocollo MLLP (Low Layer Protocol) in una configurazione multiprogetto. Utilizzo Autorizzazione binaria su Google Kubernetes Engine assicura che l'adattatore MLLP possa il deployment può essere eseguito solo da un'immagine container verificata e firmata.

Codelab su Autorizzazione binaria per l'adattatore MLLP open source in GitHub mostra nel dettaglio uno scenario simile.

Obiettivi

Dopo aver completato 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 multiprogetto per separare la responsabilità delle immagini di firma dell'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 basata sull'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 i concetti documentazione su MLLP esaminando MLLP e l'adattatore MLLP di Google Cloud. La documentazione concettuale fornisce una panoramica del MLLP, può inviare e ricevere messaggi da e verso l'API Cloud Healthcare tramite connessione MLLP e 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 arriva è preinstallato Google Cloud CLI e kubectl a strumento a riga di comando. Google Cloud CLI fornisce l'interfaccia a riga di comando principale per Google Cloud. Lo strumento kubectl fornisce a interfaccia a riga di comando per eseguire 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 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 su Attiva Google Pulsante Cloud Shell:

Viene aperta una sessione di Cloud Shell all'interno di un frame nella parte inferiore Google Cloud. Utilizza questa shell per eseguire i comandi gcloud e kubectl.

Shell locale

Per installare gcloud CLI e lo strumento kubectl, completa la seguenti 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 di una coppia di chiavi

Il progetto Cloud KMS fornisce un'infrastruttura a chiave pubblica (X.509) (PKIX) mediante Cloud KMS. Usi di Autorizzazione binaria chiavi di crittografia 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, che l'attestatore utilizza per firma digitale delle attestazioni e una chiave pubblica, che aggiungi all'attestatore archiviati dal servizio Autorizzazione binaria.

Se vuoi gestire localmente le coppie di chiavi private e pubbliche, Il progetto Cloud KMS non è obbligatorio. Per ulteriori informazioni, vedi Utilizzo delle 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 al nuovo progetto

    2. Compila il modulo, quindi fai clic su Crea. Il nome del progetto selezionato in questo tutorial viene fatto riferimento a 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 il seguente 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 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 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 la . 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 HL7v2

Per creare e configurare il progetto, il set di dati e l'archivio HL7v2 HL7v2, completare segui questi 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. Compila il modulo, quindi fai clic su Crea. Il nome del progetto selezionato in questo tutorial viene fatto riferimento a 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 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 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 di analisi degli elementi

Il progetto della nota è proprietario della nota di analisi degli elementi.

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

  1. Crea il progetto nota completando i seguenti passaggi:

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

      Vai al nuovo progetto

    2. Compila il modulo, quindi fai clic su Crea. Il nome del progetto selezionato in questo tutorial viene fatto riferimento a NOTE_PROJ_ID.
  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 Artifact Analysis nel progetto 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/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, completa i seguenti passaggi:

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

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

      Vai al nuovo progetto

    2. Compila il modulo, quindi 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 nella directory 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 nel progetto, esegui questo comando. 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 questo comando:

    gcloud beta container binauthz attestors list \
        --project=ATTESTOR_PROJ_ID
  5. Apporta le seguenti sostituzioni e salva il file JSON di esempio in un file denominato ./tmp/iam_request.json eseguendo il comando seguente:

    • Utilizza i valori NOTE_PROJ_ID e NOTE_ID da Creazione di una nota Artifact Analysis.
    • Per trovare l'icona ATTESTOR_PROJECT_NUM, svolgi i seguenti passaggi:

      1. Vai alla pagina Dashboard nella nella console Google Cloud.

        Vai alla pagina Dashboard

      2. Nella parte superiore della pagina, fai clic sull'elenco a discesa Seleziona da. Nella Viene visualizzata la finestra Seleziona da, quindi seleziona il progetto attestatore.

      Il numero del progetto viene visualizzato nella dashboard del progetto Informazioni sul 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 analisi degli elementi 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 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 memorizza le attestazioni. Un'attestazione è una dichiarazione di un attestare che un processo obbligatorio nella pipeline è completo e che l'immagine è 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 console Google Cloud, vai alla pagina Nuovo progetto.

      Vai a Nuovo progetto

    2. Compila il modulo, quindi fai clic su Crea. Il nome del progetto selezionato in questo tutorial viene fatto riferimento a ATTESTATION_PROJ_ID.
  2. Per abilitare 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

Deployment dell'adattatore MLLP

Il progetto deployer è proprietario del cluster GKE in cui è Autorizzazione binaria importati e archiviati.

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

  1. Per creare il progetto deployer, 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 in questo tutorial viene fatto riferimento a DEPLOYER_PROJ_ID.
  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 Binary Authorization 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 deployer, 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 origini immagini alla lista consentita e imposta un valore regola predefinita dell'ambito del progetto per bloccare le immagini provenienti da origini che non sono state attestato dall'attestatore. a 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 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 in la 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. Apporta le seguenti sostituzioni e salva il codice 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 questo comando:

    kubectl create -f ./tmp/deployment.yaml
  11. Per confermare che il deployment è andato a buon fine, 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, avrai eseguito il deployment di un'istanza dell'adattatore MLLP attestata in Google Kubernetes Engine.

Eliminazione dei progetti

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

Segui questi passaggi per eliminare i seguenti progetti che hai creato in questo tutorial:

  • Progetto attestatore
  • Progetto di attestazione
  • Progetto Deployer
  • Progetto nota
  • 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.