Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Python-Producer-Anwendung entwickeln

Hier erfahren Sie, wie Sie eine Python-Producer-Anwendung entwickeln, die sich mit einem Managed Service for Apache Kafka-Cluster mithilfe von Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) authentifiziert. Mit ADC können Anwendungen, die auf Google Cloud ausgeführt werden, automatisch die richtigen Anmeldedaten für die Authentifizierung bei Google Cloud -Diensten finden und verwenden.

Hinweis

Erstellen Sie vor Beginn dieser Anleitung einen neuen Managed Service for Apache Kafka-Cluster. Wenn Sie bereits einen Cluster haben, können Sie diesen Schritt überspringen.

Cluster erstellen

Console

Rufen Sie die Seite Managed Service for Apache Kafka > Cluster auf.
Zu den Clustern
Klicken Sie auf Erstellen.
Geben Sie im Feld Clustername einen Namen für den Cluster ein.
Wählen Sie in der Liste Region einen Standort für den Cluster aus.
Konfigurieren Sie unter Netzwerkkonfiguration das Subnetz, in dem der Cluster zugänglich ist:
1. Wählen Sie unter Projekt Ihr Projekt aus.
2. Wählen Sie unter Netzwerk das VPC-Netzwerk aus.
3. Wählen Sie unter Subnetz das Subnetz aus.
4. Klicken Sie auf Fertig.
Klicken Sie auf Erstellen.

Nachdem Sie auf Erstellen geklickt haben, ist der Clusterstatus Creating. Wenn der Cluster bereit ist, lautet der Status Active.

gcloud

Führen Sie den managed-kafka clusters create Befehl aus, um einen Kafka-Cluster zu erstellen.

gcloud managed-kafka clusters create KAFKA_CLUSTER \
--location=REGION \
--cpu=3 \
--memory=3GiB \
--subnets=projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET_NAME \
--async

Ersetzen Sie Folgendes:

KAFKA_CLUSTER: ein Name für den Kafka-Cluster
REGION: der Standort des Clusters
PROJECT_ID: Ihre Projekt-ID
SUBNET_NAME: das Subnetz, in dem Sie den Cluster erstellen möchten, z. B. default

Informationen zu unterstützten Standorten finden Sie unter Managed Service for Apache Kafka-Standorte.

Der Befehl wird asynchron ausgeführt und gibt eine Vorgangs-ID zurück:

Check operation [projects/PROJECT_ID/locations/REGION/operations/OPERATION_ID] for status.

Verwenden Sie den gcloud managed-kafka operations describe Befehl, um den Fortschritt des Erstellungsvorgangs zu verfolgen:

gcloud managed-kafka operations describe OPERATION_ID \
  --location=REGION

Wenn der Cluster bereit ist, enthält die Ausgabe dieses Befehls den Eintrag state: ACTIVE. Weitere Informationen finden Sie unter Erstellungsvorgang für Cluster überwachen.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Konfigurieren einer Client-VM benötigen:

Compute-Instanzadministrator (Version 1) (roles/compute.instanceAdmin.v1)
Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
Rollenbetrachter (roles/iam.roleViewer)
Dienstkontonutzer (roles/iam.serviceAccountUser)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Client-VM einrichten

Erstellen Sie eine Linux-VM-Instanz (Virtual Machine) in der Compute Engine, die auf den Kafka-Cluster zugreifen kann. Konfigurieren Sie beim Einrichten der VM die folgenden Optionen:

Region Erstellen Sie die VM in derselben Region wie Ihren Kafka-Cluster.
Subnetz Erstellen Sie die VM im selben VPC-Netzwerk wie das Subnetz, das Sie in der Kafka-Clusterkonfiguration verwendet haben. Weitere Informationen finden Sie unter Subnetze eines Clusters ansehen.
Zugriffsbereiche Weisen Sie der VM den https://www.googleapis.com/auth/cloud-platform Zugriffsbereich zu. Mit diesem Bereich kann die VM Anfragen an die Managed Kafka API senden.

In den folgenden Schritten wird gezeigt, wie Sie diese Optionen festlegen.

Console

Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.

Instanz erstellen
Führen Sie im Bereich Maschinenkonfiguration die folgenden Schritte aus:
1. Geben Sie im Feld Name einen Namen für die Instanz an. Weitere Informationen finden Sie unter Namenskonvention für Ressourcen.
2. Wählen Sie in der Liste Region dieselbe Region wie für Ihren Kafka-Cluster aus.
3. Wählen Sie in der Liste Zone eine Zone aus.
Klicken Sie im Navigationsmenü auf Netzwerk. Führen Sie im angezeigten Bereich Netzwerk die folgenden Schritte aus:
1. Gehen Sie zum Abschnitt Netzwerkschnittstellen.
2. Klicken Sie auf den Pfeil, um die Standardnetzwerkschnittstelle zu maximieren.
3. Wählen Sie im Feld Netzwerk das VPC-Netzwerk aus.
4. Wählen Sie in der Liste Subnetzwerk das Subnetz aus.
5. Klicken Sie auf Fertig.
Klicken Sie im Navigationsmenü auf Sicherheit. Führen Sie im angezeigten Bereich Sicherheit die folgenden Schritte aus:
1. Wählen Sie unter Zugriffsbereiche die Option Zugriff für jede API festlegen aus.
2. Suchen Sie in der Liste der Zugriffsbereiche die Drop-down-Liste Cloud Platform und wählen Sie Aktiviert aus.
Klicken Sie auf Erstellen , um die VM zu erstellen.

gcloud

Verwenden Sie den gcloud compute instances create Befehl, um die VM-Instanz zu erstellen.

gcloud compute instances create VM_NAME \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --subnet=projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET \
  --zone=ZONE

Ersetzen Sie Folgendes:

VM_NAME: der Name der VM
PROJECT_ID: Ihre Projekt-ID
REGION: die Region, in der Sie den Kafka Cluster erstellt haben, z. B. us-central1
SUBNET: ein Subnetz im selben VPC -Netzwerk wie das Subnetz, das Sie in der Clusterkonfiguration verwendet haben
ZONE: eine Zone in der Region, in der Sie den Cluster erstellt haben, z. B. us-central1-c

Weitere Informationen zum Erstellen einer VM finden Sie unter VM-Instanz in einem bestimmten Subnetz erstellen.

IAM-Rollen zuweisen

Weisen Sie dem Compute Engine-Standarddienstkonto die folgenden IAM-Rollen (Identity and Access Management) zu:

Managed Kafka Client (roles/managedkafka.client)
Ersteller von Dienstkonto-Token (roles/iam.serviceAccountTokenCreator)
Ersteller von OpenID-Tokens für Dienstkonten (roles/iam.serviceAccountOpenIdTokenCreator)

Console

Rufen Sie in der Google Cloud Console die Seite IAM auf.

IAM aufrufen
Suchen Sie die Zeile für Compute Engine-Standarddienstkonto und klicken Sie auf Prinzipal bearbeiten.
Klicken Sie auf Weitere Rolle hinzufügen und wählen Sie die Rolle Managed Kafka Client aus. Wiederholen Sie diesen Schritt für die Rollen Ersteller von Dienstkonto-Token und Ersteller von OpenID-Tokens für Dienstkonten.
Klicken Sie auf Speichern.

gcloud

Verwenden Sie den gcloud projects add-iam-policy-binding Befehl, um IAM-Rollen zuzuweisen.

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
  --role=roles/managedkafka.client

gcloud projects add-iam-policy-binding PROJECT_ID\
  --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
  --role=roles/iam.serviceAccountTokenCreator

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
  --role=roles/iam.serviceAccountOpenIdTokenCreator

Ersetzen Sie Folgendes:

PROJECT_ID: Ihre Projekt-ID
PROJECT_NUMBER: Ihre Projektnummer

Führen Sie den gcloud projects describe Befehl aus, um die Projektnummer abzurufen:

gcloud projects describe PROJECT_ID

Weitere Informationen finden Sie unter Projektname, -nummer und -ID ermitteln.

Verbindung zur VM herstellen

Stellen Sie über SSH eine Verbindung zur VM-Instanz her.

Console

Rufen Sie die Seite VM-Instanzen auf.

Rufen Sie die Seite VM-Instanzen auf.
Suchen Sie in der Liste der VM-Instanzen den Namen der VM und klicken Sie auf SSH.

gcloud

Verwenden Sie den gcloud compute ssh Befehl, um eine Verbindung zur VM herzustellen.

gcloud compute ssh VM_NAME \
  --project=PROJECT_ID \
  --zone=ZONE

Ersetzen Sie Folgendes:

VM_NAME: der Name der VM
PROJECT_ID: Ihre Projekt-ID
ZONE: die Zone, in der Sie die VM erstellt haben

Bei der ersten Verwendung von SSH ist möglicherweise eine zusätzliche Konfiguration erforderlich. Weitere Informationen finden Sie unter Informationen zu SSH-Verbindungen.

Python-Producer-Anwendung erstellen

Führen Sie in Ihrer SSH-Sitzung die folgenden Befehle aus, um eine Producer-Anwendung zu erstellen.

Installieren Sie pip, einen Python-Paketmanager, und den Manager für virtuelle Umgebungen:
```
sudo apt install python3-pip -y
sudo apt install python3-venv -y
```
Erstellen und aktivieren Sie eine neue virtuelle Umgebung (venv):
```
python3 -m venv kafka
source kafka/bin/activate
```
Installieren Sie den confluent-kafka-Client und andere Abhängigkeiten:
```
pip install confluent-kafka google-auth urllib3 packaging
```

Kopieren Sie den folgenden Producer-Clientcode in eine Datei namens producer.py:

import confluent_kafka
import argparse
from tokenprovider import TokenProvider

parser = argparse.ArgumentParser()
parser.add_argument('-b', '--bootstrap-servers', dest='bootstrap', type=str, required=True)
parser.add_argument('-t', '--topic-name', dest='topic_name', type=str, default='example-topic', required=False)
parser.add_argument('-n', '--num_messages', dest='num_messages', type=int, default=1, required=False)
args = parser.parse_args()

token_provider = TokenProvider()

config = {
    'bootstrap.servers': args.bootstrap,
    'security.protocol': 'SASL_SSL',
    'sasl.mechanisms': 'OAUTHBEARER',
    'oauth_cb': token_provider.get_token,
}

producer = confluent_kafka.Producer(config)

def callback(error, message):
    if error is not None:
        print(error)
        return
    print("Delivered a message to {}[{}]".format(message.topic(), message.partition()))

for i in range(args.num_messages):

  message = f"{i} hello world!".encode('utf-8')
  producer.produce(args.topic_name, message, callback=callback)

producer.flush()

Jetzt benötigen Sie eine Implementierung des OAuth-Tokenanbieters. Speichern Sie den folgenden Code in einer Datei namens tokenprovider.py:

import base64
import datetime
import http.server
import json
import google.auth
from google.auth.transport.urllib3 import Request
import urllib3
import time

def encode(source):
  """Safe base64 encoding."""
  return base64.urlsafe_b64encode(source.encode('utf-8')).decode('utf-8').rstrip('=')

class TokenProvider(object):
  """
  Provides OAuth tokens from Google Cloud Application Default credentials.
  """
  HEADER = json.dumps({'typ':'JWT', 'alg':'GOOG_OAUTH2_TOKEN'})

  def __init__(self, **config):
    self.credentials, _project = google.auth.default()
    self.http_client = urllib3.PoolManager()

  def get_credentials(self):
    if not self.credentials.valid:
      self.credentials.refresh(Request(self.http_client))
    return self.credentials

  def get_jwt(self, creds):
    token_data = dict(
      exp=creds.expiry.replace(tzinfo=datetime.timezone.utc).timestamp(),
      iat=datetime.datetime.now(datetime.timezone.utc).timestamp(),
      iss='Google',
      sub=creds.service_account_email
    )
    return json.dumps(token_data)

  def get_token(self, args):
    creds = self.get_credentials()
    token = '.'.join([
      encode(self.HEADER),
      encode(self.get_jwt(creds)),
      encode(creds.token)
    ])

    # compute expiry time
    expiry_utc = creds.expiry.replace(tzinfo=datetime.timezone.utc)
    now_utc = datetime.datetime.now(datetime.timezone.utc)
    expiry_seconds = (expiry_utc - now_utc).total_seconds()

    return token, time.time() + expiry_seconds

Jetzt können Sie die Anwendung ausführen:

python producer.py -b bootstrap.CLUSTER_ID.REGION.managedkafka.PROJECT_ID.cloud.goog:9092

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud -Konto die auf dieser Seite verwendeten Ressourcen in Rechnung gestellt werden.

Console

Löschen Sie die VM-Instanz.
1. Rufen Sie die Seite VM-Instanzen auf.
  
  Rufen Sie die Seite VM-Instanzen auf.
2. Wählen Sie die VM aus und klicken Sie auf Löschen.
Löschen Sie den Kafka-Cluster.
1. Rufen Sie die Seite Managed Service for Apache Kafka > Cluster auf.
  
  Zu den Clustern
2. Wählen Sie den Kafka-Cluster aus und klicken Sie auf Löschen.

gcloud

Verwenden Sie den gcloud compute instances delete Befehl, um die VM zu löschen.
```
gcloud compute instances delete VM_NAME --zone=ZONE
```
Verwenden Sie den gcloud managed-kafka clusters delete Befehl, um den Kafka-Cluster zu löschen.
```
gcloud managed-kafka clusters delete CLUSTER_ID \
  --location=REGION --async
```

Nächste Schritte

Apache Kafka® ist eine eingetragene Marke der Apache Software Foundation oder ihrer Tochtergesellschaften in den USA und/oder anderen Ländern.