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

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • API Cloud Healthcare
  • Google Kubernetes Engine
  • Container 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 Cloud Platform 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 l'outil de ligne de commande gcloud et l'outil de ligne de commande kubectl. L'outil gcloud fournit l'interface de ligne de commande principale pour GCP. 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 interface système locale, vous devez installer le SDK Cloud, qui inclut les outils gcloud et kubectl.

Pour ouvrir Cloud Shell ou configurer votre interface système locale, procédez comme suit :

Cloud Shell

Pour lancer Cloud Shell, procédez comme suit :

  1. Accédez à Google Cloud Console.

    Google Cloud Console

  2. 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 les outils gcloud et kubectl, procédez comme suit :

  1. Installez et initialisez le SDK Cloud.

  2. 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:

  1. Créez le projet Cloud KMS en procédant comme suit:

    1. Dans Cloud Console, accédez à la page "Nouveau projet".

      Accéder à la page "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.

  2. 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
    
  3. 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
    
  4. 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"
    
  5. 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:

  1. Pour créer le projet HL7v2, procédez comme suit:

    1. Dans Cloud Console, accédez à la page "Nouveau projet".

      Accéder à la page "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.

  2. Pour activer l'API Cloud Healthcare sur le projet, exécutez la commande suivante:

    gcloud services enable healthcare.googleapis.com \
        --project=HL7V2_PROJ_ID
    
  3. 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
    
  4. 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 Container Analysis

Le projet de note est propriétaire de la note Container Analysis.

Pour créer une note Container Analysis, procédez comme suit:

  1. Créez le projet de note en procédant comme suit:

    1. Dans Cloud Console, accédez à la page "Nouveau projet".

      Accéder à la page "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.
  2. Pour activer l'API Container Analysis sur le projet de note, exécutez la commande suivante:

    gcloud services enable containeranalysis.googleapis.com \
         --project=NOTE_PROJ_ID
    
  3. 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
    
  4. Pour créer une note Container 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"
    
  5. 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:

  1. Pour créer le projet certifiant, procédez comme suit:

    1. Dans Cloud Console, accédez à la page "Nouveau projet".

      Accéder à la page "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.
  2. 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
    
  3. 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
    
  4. Pour vérifier que le certificateur a été créé, exécutez la commande suivante:

    gcloud beta container binauthz attestors list \
        --project=ATTESTOR_PROJ_ID
    
  5. 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 NOTE_PROJ_ID et NOTE_ID de la section Créer une note Container Analysis.
    • Pour trouver le ATTESTOR_PROJECT_NUM, procédez comme suit:

      1. Accédez à la page Tableau de bord de Cloud Console.

        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
    
  6. Pour accorder au compte de service d'autorisation binaire du projet certifiant l'autorisation de lire les occurrences de notes Container 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"
    
  7. 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:

  1. Pour créer le projet d'attestation, procédez comme suit:

    1. Dans Cloud Console, accédez à la page "Nouveau projet".

      Accéder à la page "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.
  2. 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
    
  3. 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:

  1. Pour créer le projet déployant, procédez comme suit:

    1. Dans Cloud Console, accédez à la page "Nouveau projet".

      Accéder à la page "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.
  2. 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
    
  3. 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
    
  4. Pour créer un cluster avec --enable-binauthz dans le projet déployant, exécutez la commande suivante:

    gcloud beta container clusters create CLUSTER_NAME \
        --project=DEPLOYER_PROJ_ID \
        --enable-binauthz \
        --zone CLUSTER_ZONE
    
  5. L'exemple de règle de déploiement ajoute les sources d'image à la liste blanche et définit une règle de champ d'application 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
    
  6. 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
    
  7. Pour afficher les détails de la stratégie, accédez à la page "Autorisation binaire" de Google Cloud Console.

    Accéder à la page d'autorisation binaire

  8. 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
    
  9. Effectuez les remplacements suivants, puis enregistrez l'exemple YAML dans un fichier nommé ./tmp/deployment.yaml en exécutant la commande suivante:

    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. Pour créer un déploiement avec l'image certifiée, exécutez la commande suivante:

    kubectl create -f ./tmp/deployment.yaml
    
  11. 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
  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.