Transmettre des messages HL7v2 via des connexions TCP/IP à l'aide d'une image MLLP signée

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 :

API Cloud Healthcare
Google Kubernetes Engine
Artifact Analysis
Cloud Key Management Service
Autorisation binaire

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

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.

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.

Interface système locale

Pour installer gcloud CLI et l'outil kubectl, procédez comme suit :

Installez et initialisez gcloud CLI.
Installez l'outil de ligne de commande kubectl en 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:
1. Dans la console Google Cloud, accédez à la page "Nouveau projet".
  Accéder à "Nouveau projet"
2. 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:
1. Dans la console Google Cloud, accédez à la page "Nouveau projet".
  Accéder à "Nouveau projet"
2. 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:
1. Dans la console Google Cloud, accédez à la page "Nouveau projet".
  Accéder à "Nouveau projet"
2. 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:
1. Dans la console Google Cloud, accédez à la page "Nouveau projet".
  Accéder à "Nouveau projet"
2. 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.json en exécutant la commande suivante:
- Utilisez les valeurs de NOTE_PROJ_ID et NOTE_ID provenant de la création d'une note Artifact Analysis.
- Pour trouver le ATTESTOR_PROJECT_NUM, procédez comme suit:
  1. Accédez à la page Tableau de bord de la console Google Cloud.
    Accéder à la page "Tableau de bord"
  2. 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 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/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:
1. Dans la console Google Cloud, accédez à la page "Nouveau projet".
  Accéder à "Nouveau projet"
2. 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:
1. Dans la console Google Cloud, accédez à la page "Nouveau projet".
  Accéder à "Nouveau projet"
2. 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_ENFORCE dans 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 la console Google Cloud.

Accéder à la page "Autorisation binaire"

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.yaml en 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

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 pods affiche un pod en cours d'exécution et la commande get event affiche Scaled 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

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.