Diese Seite wurde von der Cloud Translation API übersetzt.

HL7v2-Nachrichten über TCP/IP-Verbindungen mithilfe eines signierten MLLP-Images übertragen

Diese Anleitung enthält Anweisungen zur Verwendung der Binärautorisierung als Teil einer minimalen MLLP-Bereitstellung (Minimal Lower Layer Protocol) in einer Einrichtung mit mehreren Projekten. Die Verwendung der Binärautorisierung in Google Kubernetes Engine sorgt dafür, dass der MLLP-Adapter nur aus einem verifizierten und signierten Container-Image bereitgestellt werden kann.

Das Open-Source-Codelab für die Binärautorisierung des MLLP-Adapters in GitHub zeigt, wie ein Google Cloud-Projekt pro Rolle verwendet wird.

Ziele

Nach Abschluss dieser Anleitung beherrschen Sie Folgendes:

Konfigurieren Sie einen Attestierer, um zu bestätigen, dass ein MLLP-Image bereit für die Bereitstellung ist.
Stellen Sie ein attestiertes Image der Binärdatei des MLLP-Adapters bereit.
Verwenden Sie eine Einrichtung mit mehreren Projekten, um die Verantwortung für das Signieren von Images von der Bereitstellungsumgebung zu trennen.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Cloud Healthcare API
Google Kubernetes Engine
Artifact Analysis
Cloud Key Management Service
Binary Authorization

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Vorbereitung

Bevor Sie mit dieser Anleitung beginnen, machen Sie sich mit der Konzeptdokumentation zu MLLP vertraut, indem Sie MLLP und den Google Cloud MLLP-Adapter lesen. Die Konzeptdokumentation bietet einen Überblick über MLLP, wie Pflegesysteme Nachrichten über eine MLLP-Verbindung an die Cloud Healthcare API senden und von ihr empfangen können, sowie die Grundlagen der MLLP-Sicherheit.

Shell auswählen

Für diese Anleitung können Sie Cloud Shell oder Ihre lokale Shell verwenden.

Cloud Shell ist eine Shell-Umgebung für die Verwaltung von Ressourcen, die in Google Cloud gehostet werden. Cloud Shell bietet Google Cloud CLI und kubectl Befehlszeilentool. Die gcloud CLI bietet die primäre Befehlszeile für Google Cloud. Das kubectl-Tool bietet die Befehlszeilenschnittstelle zum Ausführen von Befehlen für Kubernetes-Cluster.

Wenn Sie Ihre lokale Shell bevorzugen, müssen Sie die Google Cloud-CLI installieren.

So öffnen Sie Cloud Shell oder konfigurieren Ihre lokale Shell:

Cloud Shell

So starten Sie Cloud Shell:

Rufen Sie die Google Cloud Console auf.

Google Cloud Console
Klicken Sie in der oberen rechten Ecke der Console auf die Schaltfläche Google Cloud Shell aktivieren:

Im unteren Bereich der Konsole wird ein Frame für die Cloud Shell-Sitzung geöffnet. In dieser Shell führen Sie gcloud- und kubectl-Befehle aus.

Lokale Shell

So installieren Sie die gcloud CLI und das kubectl-Tool:

Installieren und initialisieren Sie die gcloud CLI.
Installieren Sie das kubectl-Befehlszeilentool mit dem folgenden Befehl:
```
gcloud components install kubectl
```

Containerprojekt

Das Containerprojekt cloud-healthcare-containers ist bereits vorhanden. Sie enthält die MLLP-Adapter-Images.

Schlüsselbund und Schlüsselpaar erstellen

Das Cloud KMS-Projekt bietet eine Cloud Key-Signatur (Public Key Infrastructure, X.509) mit Cloud KMS. Die Binärautorisierung verwendet kryptografische Schlüssel, um die Identität von Attestierern sicher zu bestätigen. Dadurch wird sichergestellt, dass nur bestätigte Parteien an der Autorisierung eines Container-Images teilnehmen können. Das Schlüsselpaar besteht aus einem privaten Schlüssel, mit dem der Attestierer Attestierungen digital signiert, und einem öffentlichen Schlüssel, den Sie dem Attestierer hinzufügen, wie er vom Binärautorisierungsdienst gespeichert wurde.

Wenn Sie private und öffentliche Schlüsselpaare lokal verwalten möchten, ist das Cloud KMS-Projekt nicht erforderlich. Weitere Informationen finden Sie unter vom Kunden verwaltete Verschlüsselungsschlüssel verwenden.

So erstellen Sie einen Schlüsselbund und ein Schlüsselpaar:

Erstellen Sie das Cloud KMS-Projekt, indem Sie die folgenden Schritte ausführen:
1. Rufen Sie in der Google Cloud Console die Seite "Neues Projekt" auf
  Zur Seite "Neues Projekt"
2. Füllen Sie das Formular aus und klicken Sie auf Erstellen. Der ausgewählte Projektname wird in dieser Anleitung als KMS_PROJ_ID bezeichnet.
Weitere Informationen zum Erstellen von Projekten finden Sie unter Projekte erstellen und verwalten.
Führen Sie den folgenden Befehl aus, um die Cloud KMS API im Cloud KMS-Projekt zu aktivieren:
```
gcloud services enable cloudkms.googleapis.com \
    --project=KMS_PROJ_ID
```
Führen Sie den folgenden Befehl aus, um einen Schlüsselbund zu erstellen. Dabei ist KEY_RING ein eindeutiger Name für den Schlüsselbund und KEY_RING_LOCATION eine Region wie us-central-1:
```
gcloud kms keyrings create KEY_RING \
    --project=KMS_PROJ_ID \
    --location=KEY_RING_LOCATION
```

Führen Sie den folgenden Befehl aus, um ein Schlüsselpaar zu erstellen:

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"

Führen Sie den folgenden Befehl aus, um die Schlüsselversion im Cloud KMS-Projekt zu überprüfen. Die Schlüsselversion sollte 1 sein.

gcloud kms keys versions list \
    --project=KMS_PROJ_ID \
    --location=KEY_RING_LOCATION \
    --key=KEY \
    --keyring=KEY_RING

HL7v2-Projekt, Dataset und HL7v2-Speicher erstellen und konfigurieren

So erstellen und konfigurieren Sie das HL7v2-Projekt, das Dataset und den HL7v2-Speicher:

So erstellen Sie das HL7v2-Projekt:
1. Rufen Sie in der Google Cloud Console die Seite "Neues Projekt" auf
  Zur Seite "Neues Projekt"
2. Füllen Sie das Formular aus und klicken Sie auf Erstellen. Der ausgewählte Projektname wird in dieser Anleitung als HL7V2_PROJ_ID bezeichnet.
Führen Sie den folgenden Befehl aus, um die Cloud Healthcare API für das Projekt zu aktivieren:
```
gcloud services enable healthcare.googleapis.com \
    --project=HL7V2_PROJ_ID
```

Führen Sie den folgenden Befehl aus, um ein Dataset zum Speichern des HL7v2-Speichers zu erstellen:

gcloud healthcare datasets create DATASET_ID \
    --location=HL7V2_STORE_LOCATION \
    --project=HL7V2_PROJ_ID

Führen Sie den folgenden Befehl aus, um den HL7v2-Speicher zu erstellen:

gcloud healthcare hl7v2-stores create HL7V2_STORE_ID \
    --dataset=DATASET_ID \
    --location=HL7V2_STORE_LOCATION \
    --project=HL7V2_PROJ_ID

Artefaktanalyse-Notiz erstellen

Das Notizenprojekt ist Inhaber der Artefaktanalysenotiz.

So erstellen Sie einen Artefaktanalyse-Hinweis:

Erstellen Sie das Notizprojekt, indem Sie die folgenden Schritte ausführen:
1. Rufen Sie in der Google Cloud Console die Seite "Neues Projekt" auf
  Zur Seite "Neues Projekt"
2. Füllen Sie das Formular aus und klicken Sie auf Erstellen. Der ausgewählte Projektname wird in dieser Anleitung als NOTE_PROJ_ID bezeichnet.
Führen Sie den folgenden Befehl aus, um die Artifact Analysis API für das Notizprojekt zu aktivieren folgenden Befehl:
```
gcloud services enable containeranalysis.googleapis.com \
     --project=NOTE_PROJ_ID
```

Führen Sie den folgenden Befehl aus, um die Beispielnutzlast in einer Datei mit dem Namen ./tmp/note_payload.json zu speichern:

cat > ./tmp/note_payload.json << EOM
{
  "name": "projects/NOTE_PROJ_ID/notes/NOTE_ID",
  "attestation": {
    "hint": {
      "human_readable_name": "Attestor note"
    }
  }
}
EOM

Führen Sie den folgenden Befehl aus, um eine Artefaktanalysenotiz im Notizenprojekt zu erstellen: folgenden Befehl:

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"

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Notiz erstellt wurde:

curl \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
"https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/NOTE_ID"

Attestierer erstellen und konfigurieren

Das Attestierungsprojekt speichert Attestierer, die bestätigen oder bestätigen, dass ein Container-Image bereit für die Bereitstellung ist.

So erstellen und konfigurieren Sie einen Attestierer:

So erstellen Sie das Attestiererprojekt:
1. Rufen Sie in der Google Cloud Console die Seite "Neues Projekt" auf
  Zur Seite "Neues Projekt"
2. Füllen Sie das Formular aus und klicken Sie auf Erstellen. Der ausgewählte Projektname wird in dieser Anleitung als ATTESTOR_PROJ_ID bezeichnet.

Führen Sie die folgenden Befehle aus, um die Binärautorisierung und die Cloud KMS APIs im Attestiererprojekt zu aktivieren:

gcloud services enable binaryauthorization.googleapis.com \
    --project=ATTESTOR_PROJ_ID
gcloud services enable cloudkms.googleapis.com \
    --project=ATTESTOR_PROJ_ID

Führen Sie den folgenden Befehl aus, um einen Attestierer im Attestiererprojekt zu erstellen. Der Attestierer verwendet die im Notizprojekt erstellte Notiz zur Bestätigung.

gcloud beta container binauthz attestors create ATTESTOR_ID \
    --project=ATTESTOR_PROJ_ID \
    --attestation-authority-note=NOTE_ID \
    --attestation-authority-note-project=NOTE_PROJ_ID

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob der Attestierer erstellt wurde:
```
gcloud beta container binauthz attestors list \
    --project=ATTESTOR_PROJ_ID
```
Nehmen Sie die folgenden Ersetzungen vor und speichern Sie die JSON-Beispieldatei in einer Datei mit dem Namen ./tmp/iam_request.json. Führen Sie dazu den folgenden Befehl aus:
- Verwenden Sie die Werte NOTE_PROJ_ID und NOTE_ID aus Artefaktanalyse-Hinweis erstellen.
- So finden Sie ATTESTOR_PROJECT_NUM:
  1. Wechseln Sie in der Google Cloud Console zur Seite Dashboard.
    Zur Seite "Dashboard"
  2. Klicken Sie oben auf der Seite auf die Drop-down-Liste Auswählen aus. Wählen Sie im angezeigten Fenster Auswählen aus das Attestiererprojekt aus.
  Die Projektnummer wird auf der Karte Projektinformationen des Projekt-Dashboards angezeigt.
```
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
```

So gewähren Sie dem Dienstkonto für die Binärautorisierung des Attestiererprojekts Berechtigung zum Lesen der Artefaktanalyse-Hinweisvorkommen im führen Sie den folgenden Befehl aus:

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"

Führen Sie den folgenden Befehl aus, um den im Cloud KMS-Projekt generierten Schlüssel zum Attestierer hinzuzufügen:

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

Attestierung erstellen

Das Attestierungsprojekt speichert Attestierungen. Eine Attestierung ist eine Erklärung eines Attestierers, dass ein erforderlicher Prozess in Ihrer Pipeline abgeschlossen ist und ein Container-Image für die Bereitstellung autorisiert ist.

So erstellen Sie eine Attestierung:

So erstellen Sie das Attestierungsprojekt:
1. Rufen Sie in der Google Cloud Console die Seite "Neues Projekt" auf
  Zur Seite "Neues Projekt"
2. Füllen Sie das Formular aus und klicken Sie auf Erstellen. Der ausgewählte Projektname wird in dieser Anleitung als ATTESTATION_PROJ_ID bezeichnet.
Führen Sie den folgenden Befehl aus, um die Binärautorisierungs-API im Attestierungsprojekt zu aktivieren:
```
gcloud services enable binaryauthorization.googleapis.com \
    --project=ATTESTATION_PROJ_ID
```

Führen Sie den folgenden Befehl aus, um die Attestierung zu signieren und zu erstellen. Dabei ist IMAGE_SIGNED der Speicherort des signierten MLLP-Adapter-Images 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

MLLP-Adapter bereitstellen

Das Deployment-Projekt besitzt den GKE-Cluster, in den die Binärautorisierung importiert und gespeichert wird.

Führen Sie die folgenden Schritte aus, um den MLLP-Adapter bereitzustellen:

So erstellen Sie das Deployer-Projekt:
1. Rufen Sie in der Google Cloud Console die Seite "Neues Projekt" auf
  Zur Seite "Neues Projekt"
2. Füllen Sie das Formular aus und klicken Sie auf Erstellen. Der ausgewählte Projektname wird in dieser Anleitung als DEPLOYER_PROJ_ID bezeichnet.
Führen Sie den folgenden Befehl aus, um die Binärautorisierungs-API im Deployment-Projekt zu aktivieren:
```
gcloud services enable binaryauthorization.googleapis.com \
    --project=DEPLOYER_PROJ_ID
```

Führen Sie den folgenden Befehl aus, um dem Dienstkonto der Binärautorisierung für das Deployer-Projekt die Berechtigung zum Zugriff auf den Attestierer für die Bestätigung zu erteilen:

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

Führen Sie den folgenden Befehl aus, um einen Cluster mit --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE im Deployment-Projekt zu erstellen:

gcloud beta container clusters create CLUSTER_NAME \
    --project=DEPLOYER_PROJ_ID \
    --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
    --zone CLUSTER_ZONE

Die Beispielbereitstellungsrichtlinie fügt Bildquellen zur Zulassungsliste hinzu und legt eine Standardregel für den Projektumfang fest, um Bilder von Quellen zu blockieren, die nicht vom Attestierer bestätigt wurden. Führen Sie den folgenden Befehl aus, um die Beispielbereitstellungsrichtlinie in einer Datei mit dem Namen ./tmp/policy.yaml zu speichern:

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

Führen Sie den folgenden Befehl aus, um die Bereitstellungsrichtlinie in das Bereitstellungsprojekt zu importieren:
```
gcloud beta container binauthz policy import ./tmp/policy.yaml \
    --project=DEPLOYER_PROJ_ID
```
Details zur Richtlinie finden Sie auf der Seite „Binärautorisierung“ in in der Google Cloud Console.

Zur Seite "Binärautorisierung"

Führen Sie den folgenden Befehl aus, um die Anmeldedaten des GKE-Clusters zu überprüfen:

gcloud container clusters get-credentials \
    --project=DEPLOYER_PROJ_ID \
    --zone CLUSTER_ZONE CLUSTER_NAME

Nehmen Sie die folgenden Ersetzungen vor und speichern Sie die Beispiel-YAML mit dem folgenden Befehl in einer Datei mit dem Namen ./tmp/deployment.yaml:

IMAGE_SIGNED ist der Speicherort des signierten MLLP-Adapter-Images gcr.io/cloud-healthcare-containers/mllp-adapter@sha256:231b073df13db0c65e57b0e1d526ab6816a73c37262e25c18bcca99bf4b4b185.
Verwenden Sie die Werte von HL7V2_PROJ_ID, HL7V2_STORE_LOCATION, DATASET_ID und HL7V2_STORE_ID, die Sie unter HL7v2-Projekt, Dataset und Speicher erstellen und konfigurieren verwendet haben.

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

Führen Sie den folgenden Befehl aus, um eine Bereitstellung mit dem bestätigten Image zu erstellen:
```
kubectl create -f ./tmp/deployment.yaml
```
Führen Sie die folgenden Befehle aus, um zu bestätigen, dass die Bereitstellung erfolgreich war:
```
kubectl get pods
kubectl get event
```
Der Befehl get pods zeigt einen ausgeführten Pod und get event zeigt Scaled up replica set mllp-adapter-deployment-xxxx to 1 an.

Nach Bearbeitung dieses Abschnitts haben Sie ein zertifiziertes MLLP-Adapter-Image sicher in Google Kubernetes Engine bereitgestellt.

Projekte löschen

Um zu vermeiden, dass Ihrem Google Cloud-Konto die in dieser Kurzanleitung verwendeten Ressourcen in Rechnung gestellt werden, können Sie die in Google Cloud erstellten Ressourcen bereinigen.

Führen Sie die folgenden Schritte aus, um die folgenden Projekte zu löschen, die Sie in dieser Anleitung erstellt haben:

Attestierer-Projekt
Attestierungsprojekt
Deployer-Projekt
Notieren Sie sich das Projekt
Cloud KMS-Projekt

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
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.