Ce tutoriel explique comment utiliser l'autorisation binaire dans le cadre d'un déploiement à l'aide du protocole MLLP (Minimal Lower Layer Protocol) dans une configuration multi-projet. L'autorisation binaire sur Google Kubernetes Engine garantit que l'adaptateur MLLP ne peut être déployé qu'à partir d'une image de conteneur validée et signée.
L'atelier de programmation Open Source d'autorisation binaire pour l'adaptateur MLLP dans GitHub illustre un scénario semblable.
Objectifs
À la fin de ce tutoriel, vous saurez :
- Configurez un certificateur pour attester qu'une image MLLP est prête à être déployée.
- Déployer une image certifiée du binaire de l'adaptateur MLLP
- Utilisez une configuration multiprojet pour isoler la responsabilité de signature d'images de l'environnement de déploiement.
Coûts
Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :
- Cloud Healthcare API
- Google Kubernetes Engine
- Artifact Analysis
- Cloud Key Management Service
- Binary Authorization
Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.
Prérequis
Avant de commencer ce tutoriel, familiarisez-vous avec la documentation conceptuelle du protocole MLLP en consultant la page MLLP et l'adaptateur MLLP Google Cloud. La documentation conceptuelle présente le protocole MLLP, explique comment les systèmes de soins peuvent envoyer et recevoir des messages depuis et vers l'API Cloud Healthcare via une connexion MLLP, et fournit les principes de base du protocole MLLP en termes de sécurité.
Choisir une interface système
Pour réaliser ce tutoriel, vous pouvez utiliser Cloud Shell ou votre interface système locale.
Cloud Shell est un environnement shell permettant de gérer les ressources hébergées sur Google Cloud. Cloud Shell est préinstallé avec Google Cloud CLI et l'outil de ligne de commande kubectl. gcloud CLI fournit l'interface de ligne de commande principale pour Google Cloud. L'outil kubectl fournit l'interface de ligne de commande permettant d'exécuter des commandes sur les clusters Kubernetes.
Si vous préférez utiliser votre shell local, vous devez installer Google Cloud CLI.
Pour ouvrir Cloud Shell ou configurer votre shell local, procédez comme suit :
Cloud Shell
Pour lancer Cloud Shell, procédez comme suit :
Accédez à Google Cloud Console.
Dans le coin supérieur droit de la console, cliquez sur le bouton Activer Google Cloud Shell
.
Une session Cloud Shell s'ouvre dans un cadre en bas de la console. Cette interface système vous permet d'exécuter les commandes gcloud et kubectl.
Shell local
Pour installer gcloud CLI et l'outil kubectl, procédez comme suit :
Installez l'outil de ligne de commande
kubectlen exécutant la commande suivante :gcloud components install kubectl
Projet de conteneur
Le projet de conteneur cloud-healthcare-containers existe déjà. Il contient les images de l'adaptateur MLLP.
Créer un trousseau et une paire de clés
Le projet Cloud KMS fournit une signature (X.509) d'infrastructure à clé publique (PKIX) à l'aide du service Cloud KMS. L'autorisation binaire utilise des clés de chiffrement pour vérifier en toute sécurité l'identité des certificateurs. Ainsi, seules les parties validées peuvent participer à l'autorisation d'une image de conteneur. La paire de clés se compose d'une clé privée, utilisée par le certificateur pour signer numériquement les attestations, et d'une clé publique que vous ajoutez au certificateur telle qu'elle est stockée par le service d'autorisation binaire.
Si vous souhaitez gérer les paires de clés privées et publiques localement, le projet Cloud KMS n'est pas nécessaire. Pour en savoir plus, consultez la section Utiliser des clés de chiffrement gérées par le client.
Pour créer un trousseau et une paire de clés, procédez comme suit:
Créez le projet Cloud KMS en procédant comme suit:
Dans la console Google Cloud, accédez à la page "Nouveau projet".
Remplissez le formulaire, puis cliquez sur Créer. Le nom du projet que vous sélectionnez est référencé par KMS_PROJ_ID dans ce tutoriel.
Pour en savoir plus sur la création de projets, consultez la page Créer et gérer des projets.
Pour activer l'API Cloud KMS sur le projet Cloud KMS, exécutez la commande suivante:
gcloud services enable cloudkms.googleapis.com \ --project=KMS_PROJ_ID
Pour créer un trousseau, exécutez la commande suivante, où KEY_RING est un nom unique pour le trousseau et KEY_RING_LOCATION une région telle que
us-central-1:gcloud kms keyrings create KEY_RING \ --project=KMS_PROJ_ID \ --location=KEY_RING_LOCATION
Pour créer une paire de clés, exécutez la commande suivante:
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"
Pour vérifier la version de clé sur le projet Cloud KMS, exécutez la commande suivante. La version de clé doit être
1.gcloud kms keys versions list \ --project=KMS_PROJ_ID \ --location=KEY_RING_LOCATION \ --key=KEY \ --keyring=KEY_RING
Créer et configurer le projet HL7v2, l'ensemble de données et le magasin HL7v2
Pour créer et configurer le projet HL7v2, l'ensemble de données et le magasin HL7v2, procédez comme suit:
Pour créer le projet HL7v2, procédez comme suit:
Dans la console Google Cloud, accédez à la page "Nouveau projet".
Remplissez le formulaire, puis cliquez sur Créer. Le nom du projet que vous sélectionnez est référencé par HL7V2_PROJ_ID dans ce tutoriel.
Pour activer l'API Cloud Healthcare sur le projet, exécutez la commande suivante:
gcloud services enable healthcare.googleapis.com \ --project=HL7V2_PROJ_ID
Pour créer un ensemble de données dans lequel stocker le magasin HL7v2, exécutez la commande suivante:
gcloud healthcare datasets create DATASET_ID \ --location=HL7V2_STORE_LOCATION \ --project=HL7V2_PROJ_ID
Pour créer le magasin HL7v2, exécutez la commande suivante:
gcloud healthcare hl7v2-stores create HL7V2_STORE_ID \ --dataset=DATASET_ID \ --location=HL7V2_STORE_LOCATION \ --project=HL7V2_PROJ_ID
Créer une note Artifact Analysis
Le projet de note est propriétaire de la note Artifact Analysis.
Pour créer une note Artifact Analysis, procédez comme suit:
Créez le projet de note en procédant comme suit:
- Dans la console Google Cloud, accédez à la page "Nouveau projet".
- Remplissez le formulaire, puis cliquez sur Créer. Le nom du projet que vous sélectionnez est référencé par NOTE_PROJ_ID dans ce tutoriel.
Pour activer l'API Artifact Analysis sur le projet de note, exécutez la commande suivante:
gcloud services enable containeranalysis.googleapis.com \ --project=NOTE_PROJ_ID
Pour enregistrer l'exemple de charge utile de note dans un fichier nommé
./tmp/note_payload.json, exécutez la commande suivante:cat > ./tmp/note_payload.json << EOM { "name": "projects/NOTE_PROJ_ID/notes/NOTE_ID", "attestation": { "hint": { "human_readable_name": "Attestor note" } } } EOM
Pour créer une note Artifact Analysis dans le projet de note, exécutez la commande suivante:
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"
Pour vérifier que la note a été créée, exécutez la commande suivante:
curl \ -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \ "https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/NOTE_ID"
Créer et configurer un certificateur
Le projet certifiant stocke les certificateurs qui vérifient ou attestent qu'une image de conteneur est prête à être déployée.
Pour créer et configurer un certificateur, procédez comme suit:
Pour créer le projet certifiant, procédez comme suit:
- Dans la console Google Cloud, accédez à la page "Nouveau projet".
- Remplissez le formulaire, puis cliquez sur Créer. Le nom du projet que vous sélectionnez est référencé par ATTESTOR_PROJ_ID dans ce tutoriel.
Pour activer l'autorisation binaire et les API Cloud KMS sur le projet certifiant, exécutez les commandes suivantes:
gcloud services enable binaryauthorization.googleapis.com \ --project=ATTESTOR_PROJ_ID gcloud services enable cloudkms.googleapis.com \ --project=ATTESTOR_PROJ_ID
Pour créer un certificateur sur le projet certifiant , exécutez la commande suivante. Le certificateur utilise la note créée dans le projet de note.
gcloud beta container binauthz attestors create ATTESTOR_ID \ --project=ATTESTOR_PROJ_ID \ --attestation-authority-note=NOTE_ID \ --attestation-authority-note-project=NOTE_PROJ_ID
Pour vérifier que le certificateur a été créé, exécutez la commande suivante:
gcloud beta container binauthz attestors list \ --project=ATTESTOR_PROJ_ID
Effectuez les substitutions suivantes, puis enregistrez l'exemple JSON dans un fichier nommé
./tmp/iam_request.jsonen exécutant la commande suivante:- Utilisez les valeurs NOTE_PROJ_ID et NOTE_ID de la section Créer une note Artifact Analysis.
Pour trouver le ATTESTOR_PROJECT_NUM, procédez comme suit:
Accédez à la page Tableau de bord de la console Google Cloud.
Cliquez sur la liste déroulante Sélectionner située en haut de la page. Dans la fenêtre Select from (Sélectionner à partir de) qui s'affiche, sélectionnez le projet certifiant.
Le numéro de projet est affiché sur la fiche Informations sur le projet du tableau de bord du projet.
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
Pour accorder au compte de service d'autorisation binaire du projet certifiant l'autorisation de lire les occurrences de notes Artifact Analysis dans le projet de note, exécutez la commande suivante:
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"
Pour ajouter la clé générée dans le projet Cloud KMS au certificateur, exécutez la commande suivante:
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
Créer une attestation
Le projet d'attestation stocke les attestations. Une attestation est une déclaration d'un certificateur qu'un processus requis dans votre pipeline est terminé et qu'une image de conteneur est autorisée pour le déploiement.
Pour créer un certificat, procédez comme suit:
Pour créer le projet d'attestation, procédez comme suit:
- Dans la console Google Cloud, accédez à la page "Nouveau projet".
- Remplissez le formulaire, puis cliquez sur Créer. Le nom du projet que vous sélectionnez est référencé par ATTESTATION_PROJ_ID dans ce tutoriel.
Pour activer l'API d'autorisation binaire sur le projet d'attestation, exécutez la commande suivante:
gcloud services enable binaryauthorization.googleapis.com \ --project=ATTESTATION_PROJ_ID
Pour signer et créer l'attestation, exécutez la commande suivante, où IMAGE_SIGNED correspond à l'emplacement de l'image de l'adaptateur MLLP signé,
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
Déployer l'adaptateur MLLP
Le projet déployant est propriétaire du cluster GKE dans lequel l'autorisation binaire est importée et stockée.
Pour déployer l'adaptateur MLLP, procédez comme suit:
Pour créer le projet déployant, procédez comme suit:
- Dans la console Google Cloud, accédez à la page "Nouveau projet".
- Remplissez le formulaire, puis cliquez sur Créer. Le nom du projet que vous sélectionnez est référencé par DEPLOYER_PROJ_ID dans ce tutoriel.
Pour activer l'API d'autorisation binaire sur le projet déployant, exécutez la commande suivante:
gcloud services enable binaryauthorization.googleapis.com \ --project=DEPLOYER_PROJ_ID
Pour autoriser le compte de service d'autorisation binaire du projet déployant à accéder au certificateur de vérification d'attestation, exécutez la commande suivante:
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
Pour créer un cluster avec
--binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCEdans le projet déployant, exécutez la commande suivante:gcloud beta container clusters create CLUSTER_NAME \ --project=DEPLOYER_PROJ_ID \ --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \ --zone CLUSTER_ZONE
L'exemple de règle de déploiement ajoute les sources d'image à la liste d'autorisation et définit une règle de champ d'application du projet par défaut pour bloquer les images provenant de sources qui n'ont pas été testées par le certificateur. Pour enregistrer l'exemple de règle de déploiement dans un fichier nommé
./tmp/policy.yaml, exécutez la commande suivante: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
Pour importer la règle de déploiement dans le projet déployant, exécutez la commande suivante:
gcloud beta container binauthz policy import ./tmp/policy.yaml \ --project=DEPLOYER_PROJ_ID
Pour afficher les détails de la stratégie, accédez à la page "Autorisation binaire" de Google Cloud Console.
Pour vérifier les identifiants du cluster GKE, exécutez la commande suivante:
gcloud container clusters get-credentials \ --project=DEPLOYER_PROJ_ID \ --zone CLUSTER_ZONE CLUSTER_NAME
Effectuez les remplacements suivants, puis enregistrez l'exemple YAML dans un fichier nommé
./tmp/deployment.yamlen exécutant la commande suivante:- IMAGE_SIGNED est l'emplacement de l'image de l'adaptateur MLLP signé,
gcr.io/cloud-healthcare-containers/mllp-adapter@sha256:231b073df13db0c65e57b0e1d526ab6816a73c37262e25c18bcca99bf4b4b185. - Utilisez les valeurs HL7V2_PROJ_ID, HL7V2_STORE_LOCATION, DATASET_ID et HL7V2_STORE_ID utilisées dans la section Créer et configurer le projet, l'ensemble de données et le magasin 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 est l'emplacement de l'image de l'adaptateur MLLP signé,
Pour créer un déploiement avec l'image certifiée, exécutez la commande suivante:
kubectl create -f ./tmp/deployment.yaml
Pour vérifier que le déploiement a réussi, exécutez les commandes suivantes:
kubectl get pods kubectl get event
La commande
get podsaffiche un pod en cours d'exécution et la commandeget eventafficheScaled up replica set mllp-adapter-deployment-xxxx to 1.
Une fois cette section terminée, vous avez déployé de manière sécurisée une image d'adaptateur MLLP certifiée sur Google Kubernetes Engine.
Supprimer les projets
Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, vous pouvez nettoyer les ressources créées sur Google Cloud.
Suivez les étapes ci-dessous pour supprimer les projets suivants que vous avez créés dans ce tutoriel:
- Projet certifiant
- Projet d'attestation
- Projet déployant
- Projet de note
- Projet 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.