Questo tutorial fornisce istruzioni per l'utilizzo dell'autorizzazione binaria nell'ambito 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 open source Autorizzazione binaria dell'adattatore MLLP su GitHub illustra in 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 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.
Prerequisiti
Prima di iniziare questo tutorial, acquisisci familiarità con la documentazione concettuale su MLLP esaminando MLLP e l'adattatore MLLP. 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 delle nozioni di base sulla sicurezza di 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
preinstallati Google Cloud CLI e
lo strumento a riga di comando kubectl. gcloud CLI fornisce l'interfaccia a riga di comando
principale per Google Cloud. Lo strumento kubectl fornisce l'interfaccia a riga di comando per eseguire 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:
Vai alla Google Cloud console.
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.
Local Shell
Per installare gcloud CLI e lo strumento kubectl, completa i seguenti passaggi:
Installa lo strumento a riga di comando
kubectleseguendo 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 una chiave automatizzata e di 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 memorizzata dal servizio Autorizzazione binaria.
Se vuoi gestire localmente le coppie di chiavi private e pubbliche, il progetto Cloud KMS non è necessario. 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:
Crea il progetto Cloud KMS completando i seguenti passaggi:
Nella console Google Cloud , vai alla pagina Nuovo progetto.
Compila il modulo e fai clic su Crea. Il nome del progetto che selezioni viene indicato come KMS_PROJ_ID in questo tutorial.
Per saperne di più sulla creazione di progetti, consulta la pagina Creare e gestire progetti.
Per abilitare l'API Cloud KMS nel progetto Cloud KMS, esegui il comando seguente:
gcloud services enable cloudkms.googleapis.com \ --project=KMS_PROJ_ID
Per creare un portachiavi, esegui questo 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
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"
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:
Per creare il progetto HL7v2, completa i seguenti passaggi:
Nella console Google Cloud , vai alla pagina Nuovo progetto.
Compila il modulo e fai clic su Crea. Il nome del progetto che selezioni viene indicato come HL7V2_PROJ_ID in questo tutorial.
Per abilitare l'API Cloud Healthcare nel progetto, esegui il seguente comando:
gcloud services enable healthcare.googleapis.com \ --project=HL7V2_PROJ_ID
Per creare un set di dati in cui archiviare l'archivio HL7v2, esegui questo comando:
gcloud healthcare datasets create DATASET_ID \ --location=HL7V2_STORE_LOCATION \ --project=HL7V2_PROJ_ID
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 della nota è proprietario della nota di Artifact Analysis.
Per creare una nota di Artifact Analysis, completa i seguenti passaggi:
Crea il progetto di note completando i seguenti passaggi:
- Nella console Google Cloud , vai alla pagina Nuovo progetto.
- Compila il modulo e fai clic su Crea. Il nome del progetto che selezioni viene indicato come NOTE_PROJ_ID in questo tutorial.
Per abilitare l'API Artifact Analysis nel progetto di note, esegui il seguente comando:
gcloud services enable containeranalysis.googleapis.com \ --project=NOTE_PROJ_ID
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
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"
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 attestatore memorizza gli attestatori, che verificano o attestano che un'immagine container è pronta per il deployment.
Per creare e configurare un attestatore, completa i seguenti passaggi:
Per creare il progetto del firmatario, completa i seguenti passaggi:
- Nella console Google Cloud , vai alla pagina Nuovo progetto.
- Compila il modulo e fai clic su Crea. Il nome del progetto che selezioni viene indicato come ATTESTOR_PROJ_ID in questo tutorial.
Per abilitare le API Autorizzazione binaria e Cloud KMS nel progetto 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
Per creare un attestatore nel progetto attestatore, esegui questo comando. 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
Per verificare che l'attestatore sia stato creato, esegui questo comando:
gcloud beta container binauthz attestors list \ --project=ATTESTOR_PROJ_ID
Esegui le seguenti sostituzioni, quindi salva il JSON di esempio in un file denominato
./tmp/iam_request.jsoneseguendo il comando seguente:- Utilizza i valori di NOTE_PROJ_ID e NOTE_ID da Creazione di un Artifact Analysis artefatti.
Per trovare il ATTESTOR_PROJECT_NUM, completa i seguenti passaggi:
Vai alla pagina Dashboard nella console Google Cloud .
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
Per concedere all'account di servizio di autorizzazione binaria del progetto attestatore l'autorizzazione a leggere le occorrenze delle noteArtifact Analysisi nel progetto note, 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"
Per aggiungere la chiave generata nel progetto Cloud KMS all'attestatore, 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 attesta che una procedura richiesta nella pipeline è completata e che un'immagine container è autorizzata per il deployment.
Per creare un'attestazione, completa i seguenti passaggi:
Per creare il progetto di attestazione, completa i seguenti passaggi:
- Nella console Google Cloud , vai alla pagina Nuovo progetto.
- Compila il modulo e fai clic su Crea. Il nome del progetto che selezioni viene indicato come ATTESTATION_PROJ_ID in questo tutorial.
Per abilitare l'API Binary Authorization nel progetto di attestazione, esegui il seguente comando:
gcloud services enable binaryauthorization.googleapis.com \ --project=ATTESTATION_PROJ_ID
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 di deployment è proprietario del cluster GKE in cui viene importata e archiviata Autorizzazione binaria.
Per eseguire il deployment dell'adattatore MLLP, completa i seguenti passaggi:
Per creare il progetto deployer, completa i seguenti passaggi:
- Nella console Google Cloud , vai alla pagina Nuovo progetto.
- Compila il modulo e fai clic su Crea. Il nome del progetto che selezioni viene indicato come DEPLOYER_PROJ_ID in questo tutorial.
Per abilitare l'API Binary Authorization nel progetto di deployment, esegui questo comando:
gcloud services enable binaryauthorization.googleapis.com \ --project=DEPLOYER_PROJ_ID
Per concedere all'account di servizio di autorizzazione binaria nel progetto deployer l'autorizzazione ad 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
Per creare un cluster con
--binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCEnel progetto di deployment, esegui questo comando:gcloud beta container clusters create CLUSTER_NAME \ --project=DEPLOYER_PROJ_ID \ --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \ --zone CLUSTER_ZONE
La policy di deployment di esempio aggiunge le origini delle immagini alla lista consentita e imposta una regola predefinita dell'ambito del 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 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
Per importare la policy di deployment nel progetto deployer, esegui questo comando:
gcloud beta container binauthz policy import ./tmp/policy.yaml \ --project=DEPLOYER_PROJ_ID
Per visualizzare i dettagli della policy, vai alla pagina Autorizzazione binaria nella console Google Cloud .
Per estrarre le credenziali del cluster GKE, esegui questo comando:
gcloud container clusters get-credentials \ --project=DEPLOYER_PROJ_ID \ --zone CLUSTER_ZONE CLUSTER_NAME
Esegui le seguenti sostituzioni, quindi salva il file YAML di esempio in un file denominato
./tmp/deployment.yamleseguendo il seguente comando:- IMAGE_SIGNED è la posizione dell'immagine dell'adattatore MLLP firmata,
gcr.io/cloud-healthcare-containers/mllp-adapter@sha256:231b073df13db0c65e57b0e1d526ab6816a73c37262e25c18bcca99bf4b4b185. - Utilizza i valori di HL7V2_PROJ_ID, HL7V2_STORE_LOCATION, DATASET_ID e HL7V2_STORE_ID che hai utilizzato in Creazione e configurazione del progetto, del set di dati e dell'archivio HL7v2.
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
- IMAGE_SIGNED è la posizione dell'immagine dell'adattatore MLLP firmata,
Per creare un deployment con l'immagine attestata, esegui questo comando:
kubectl create -f ./tmp/deployment.yaml
Per verificare che il deployment sia andato a buon fine, esegui questi comandi:
kubectl get pods kubectl get event
Il comando
get podsmostra un pod in esecuzione e il comandoget eventmostraScaled up replica set mllp-adapter-deployment-xxxx to 1.
Dopo aver completato questa sezione, hai eseguito il deployment sicuro di un'immagine dell'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 eliminare le risorse che hai creato suGoogle Cloud.
Per eliminare i seguenti progetti che hai creato in questo tutorial:
- Progetto attestatore
- Progetto di attestazione
- Progetto deployer
- Progetto Note
- Progetto Cloud KMS
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.