Wählen Sie Ihre Cookie-Einstellungen aus

Wir verwenden essentielle Cookies und ähnliche Tools, die für die Bereitstellung unserer Website und Services erforderlich sind. Wir verwenden Performance-Cookies, um anonyme Statistiken zu sammeln, damit wir verstehen können, wie Kunden unsere Website nutzen, und Verbesserungen vornehmen können. Essentielle Cookies können nicht deaktiviert werden, aber Sie können auf „Anpassen“ oder „Ablehnen“ klicken, um Performance-Cookies abzulehnen.

Wenn Sie damit einverstanden sind, verwenden AWS und zugelassene Drittanbieter auch Cookies, um nützliche Features der Website bereitzustellen, Ihre Präferenzen zu speichern und relevante Inhalte, einschließlich relevanter Werbung, anzuzeigen. Um alle nicht notwendigen Cookies zu akzeptieren oder abzulehnen, klicken Sie auf „Akzeptieren“ oder „Ablehnen“. Um detailliertere Entscheidungen zu treffen, klicken Sie auf „Anpassen“.

Erstellen Sie eine Managed Service für Apache Flink-Anwendung und führen Sie sie aus

Fokusmodus
Erstellen Sie eine Managed Service für Apache Flink-Anwendung und führen Sie sie aus - Amazon-Kinesis-Data-Streams

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

In dieser Übung erstellen Sie eine Anwendung von Managed Service für Apache Flink mit Datenströmen als Quelle und Senke.

Erstellen Sie zwei Amazon Kinesis Kinesis-Datenstreams

Bevor Sie für diese Übung einen Amazon Managed Service für Apache Flink erstellen, erstellen Sie zwei Kinesis-Datenstreams (ExampleInputStreamundExampleOutputStream). Ihre Anwendung verwendet diese Streams für die Quell- und Ziel-Streams der Anwendung.

Sie können diese Streams entweder mit der Amazon Kinesis Kinesis-Konsole oder wie folgt erstellen: AWS CLI Befehl. Detaillierte Konsolenanweisungen finden Sie unter Erstellen und Aktualisieren von Daten-Streams.

Um die Datenströme zu erstellen (AWS CLI)
  1. Verwenden Sie den folgenden Amazon Kinesis, um den ersten Stream (ExampleInputStream) zu erstellen create-stream AWS CLI Befehl.

    $ aws kinesis create-stream \ --stream-name ExampleInputStream \ --shard-count 1 \ --region us-west-2 \ --profile adminuser
  2. Um den zweiten Stream zu erstellen, den die Anwendung zum Schreiben der Ausgabe verwendet, führen Sie denselben Befehl aus und ändern den Stream-Namen in ExampleOutputStream.

    $ aws kinesis create-stream \ --stream-name ExampleOutputStream \ --shard-count 1 \ --region us-west-2 \ --profile adminuser

Schreiben Sie Beispieldatensätze in den Eingabe-Stream

In diesem Abschnitt verwenden Sie ein Python-Skript zum Schreiben von Datensätzen in den Stream für die zu verarbeitende Anwendung.

Anmerkung

Dieser Abschnitt erfordert die AWS SDK for Python (Boto).

  1. Erstellen Sie eine Datei stock.py mit dem folgenden Inhalt:

    import datetime import json import random import boto3 STREAM_NAME = "ExampleInputStream" def get_data(): return { "EVENT_TIME": datetime.datetime.now().isoformat(), "TICKER": random.choice(["AAPL", "AMZN", "MSFT", "INTC", "TBV"]), "PRICE": round(random.random() * 100, 2), } def generate(stream_name, kinesis_client): while True: data = get_data() print(data) kinesis_client.put_record( StreamName=stream_name, Data=json.dumps(data), PartitionKey="partitionkey" ) if __name__ == "__main__": generate(STREAM_NAME, boto3.client("kinesis"))
  2. Im weiteren Verlauf des Tutorials führen Sie das stock.py-Skript zum Senden von Daten an die Anwendung aus.

    $ python stock.py

Laden Sie den Apache Flink-Streaming-Java-Code herunter und untersuchen Sie ihn

Der Java-Anwendungscode für diese Beispiele ist verfügbar unter GitHub. Zum Herunterladen des Anwendungscodes gehen Sie wie folgt vor:

  1. Klonen Sie das Remote-Repository mit dem folgenden Befehl:

    git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-java-examples.git
  2. Navigieren Sie zum GettingStarted Verzeichnis .

Der Anwendungscode befindet sich in den Dateien CloudWatchLogSink.java und CustomSinkStreamingJob.java. Beachten Sie Folgendes zum Anwendungscode:

  • Die Anwendung verwendet eine Kinesis-Quelle zum Lesen aus dem Quell-Stream. Der folgende Codeausschnitt erstellt die Kinesis-Senke:

    return env.addSource(new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(), inputProperties));

Kompilieren Sie den Anwendungscode

In diesem Abschnitt verwenden Sie den Apache Maven-Compiler zum Erstellen des Java-Codes für die Anwendung. Hinweise zur Installation von Apache Maven und dem Java Development Kit (JDK) finden Sie unterVoraussetzungen für das Abschließen der Übungen.

Ihre Java-Anwendung erfordert die folgenden Komponenten:

  • Eine Projektobjektmodell (pom.xml)-Datei. Diese Datei enthält Informationen zur Konfiguration und zu den Abhängigkeiten der Anwendung, einschließlich der Amazon Managed Service for Apache Flink-Bibliotheken.

  • Eine main-Methode, die die Logik der Anwendung enthält.

Anmerkung

Um den Kinesis-Konnektor für die folgende Anwendung zu verwenden, müssen Sie den Quellcode für den Konnektor herunterladen und ihn wie in der Apache Flink-Dokumentation beschrieben erstellen.

So erstellen und kompilieren Sie den Anwendungscode
  1. Erstellen Sie eine Java/Maven-Anwendung in Ihrer Entwicklungsumgebung. Weitere Informationen zum Erstellen einer Anwendung finden Sie in der Dokumentation für Ihre Entwicklungsumgebung:

  2. Verwenden Sie den folgenden Code für eine Datei mit dem Namen StreamingJob.java.

    package com.amazonaws.services.kinesisanalytics; import com.amazonaws.services.kinesisanalytics.runtime.KinesisAnalyticsRuntime; import org.apache.flink.api.common.serialization.SimpleStringSchema; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; import org.apache.flink.streaming.connectors.kinesis.FlinkKinesisConsumer; import org.apache.flink.streaming.connectors.kinesis.FlinkKinesisProducer; import org.apache.flink.streaming.connectors.kinesis.config.ConsumerConfigConstants; import java.io.IOException; import java.util.Map; import java.util.Properties; public class StreamingJob { private static final String region = "us-east-1"; private static final String inputStreamName = "ExampleInputStream"; private static final String outputStreamName = "ExampleOutputStream"; private static DataStream<String> createSourceFromStaticConfig(StreamExecutionEnvironment env) { Properties inputProperties = new Properties(); inputProperties.setProperty(ConsumerConfigConstants.AWS_REGION, region); inputProperties.setProperty(ConsumerConfigConstants.STREAM_INITIAL_POSITION, "LATEST"); return env.addSource(new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(), inputProperties)); } private static DataStream<String> createSourceFromApplicationProperties(StreamExecutionEnvironment env) throws IOException { Map<String, Properties> applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties(); return env.addSource(new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(), applicationProperties.get("ConsumerConfigProperties"))); } private static FlinkKinesisProducer<String> createSinkFromStaticConfig() { Properties outputProperties = new Properties(); outputProperties.setProperty(ConsumerConfigConstants.AWS_REGION, region); outputProperties.setProperty("AggregationEnabled", "false"); FlinkKinesisProducer<String> sink = new FlinkKinesisProducer<>(new SimpleStringSchema(), outputProperties); sink.setDefaultStream(outputStreamName); sink.setDefaultPartition("0"); return sink; } private static FlinkKinesisProducer<String> createSinkFromApplicationProperties() throws IOException { Map<String, Properties> applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties(); FlinkKinesisProducer<String> sink = new FlinkKinesisProducer<>(new SimpleStringSchema(), applicationProperties.get("ProducerConfigProperties")); sink.setDefaultStream(outputStreamName); sink.setDefaultPartition("0"); return sink; } public static void main(String[] args) throws Exception { // set up the streaming execution environment final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); /* * if you would like to use runtime configuration properties, uncomment the * lines below * DataStream<String> input = createSourceFromApplicationProperties(env); */ DataStream<String> input = createSourceFromStaticConfig(env); /* * if you would like to use runtime configuration properties, uncomment the * lines below * input.addSink(createSinkFromApplicationProperties()) */ input.addSink(createSinkFromStaticConfig()); env.execute("Flink Streaming Java API Skeleton"); } }

    Beachten Sie die folgenden Informationen zum vorherigen Codebeispiel:

    • Diese Datei enthält die main-Methode, die die Funktionalität der Anwendung definiert.

    • Ihre Anwendung erstellt Quell- und Senkenkonnektoren für den Zugriff auf externe Ressourcen, indem ein StreamExecutionEnvironment-Objekt verwendet wird.

    • Die Anwendung erstellt Quell- und Senkenkonnektoren mit statischen Eigenschaften. Zum Verwenden dynamischer Anwendungseigenschaften verwenden Sie die Methoden createSourceFromApplicationProperties und createSinkFromApplicationProperties, um die Konnektoren zu erstellen. Diese Methoden lesen die Eigenschaften der Anwendung zum Konfigurieren der Konnektoren.

  3. Um Ihren Anwendungscode zu verwenden, kompilieren Sie ihn und packen ihn in eine JAR Datei. Sie können Ihren Code auf zwei Arten kompilieren und packen:

    • Verwenden Sie das Befehlszeilen-Maven-Tool. Erstellen Sie Ihre JAR Datei, indem Sie den folgenden Befehl in dem Verzeichnis ausführen, das die pom.xml Datei enthält:

      mvn package
    • Verwenden Sie Ihre Entwicklungsumgebung. Weitere Informationen finden Sie in der Dokumentation Ihrer Entwicklungsumgebung.

    Sie können Ihr Paket entweder als JAR Datei hochladen oder Sie können Ihr Paket komprimieren und als ZIP Datei hochladen. Wenn Sie Ihre Anwendung mit dem erstellen AWS CLI, geben Sie Ihren Codeinhaltstyp (JARoderZIP) an.

  4. Wenn während der Erstellung Fehler aufgetreten sind, überprüfen Sie, ob Ihre JAVA_HOME-Umgebungsvariable richtig eingestellt ist.

Wenn die Anwendung erfolgreich kompiliert wurde, wird die folgende Datei erstellt:

target/java-getting-started-1.0.jar

Laden Sie den Apache Flink-Streaming-Java-Code hoch

In diesem Abschnitt erstellen Sie einen Amazon Simple Storage Service (Amazon S3)-Bucket und laden Ihren Anwendungscode hoch.

So laden Sie den Anwendungscode hoch
  1. Öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

  2. Wählen Sie Bucket erstellen aus.

  3. Geben Sie ka-app-code-<username> im Feld Bucket-Name ein. Fügen Sie dem Bucket-Namen ein Suffix hinzu, wie z. B. Ihren Benutzernamen, damit er global eindeutig ist. Wählen Sie Weiter.

  4. Lassen Sie im Schritt Optionen konfigurieren die Einstellungen unverändert und klicken Sie auf Weiter.

  5. Lassen Sie im Schritt Berechtigungen festlegen die Einstellungen unverändert und klicken Sie auf Weiter.

  6. Wählen Sie Bucket erstellen aus.

  7. Wählen Sie in der Amazon S3 S3-Konsole die Option ka-app-code -<username>Bucket und wählen Sie Upload.

  8. Klicken Sie im Schritt Auswählen von Dateien auf Hinzufügen von Dateien. Navigieren Sie zu der java-getting-started-1.0.jarDatei, die Sie im vorherigen Schritt erstellt haben. Wählen Sie Weiter.

  9. Lassen Sie im Schritt Berechtigungen festlegen die Einstellungen unverändert. Wählen Sie Weiter.

  10. Lassen Sie im Schritt Eigenschaften festlegen die Einstellungen unverändert. Klicken Sie auf Hochladen.

Ihr Anwendungscode ist jetzt in einem Amazon-S3-Bucket gespeichert, in dem Ihre Anwendung darauf zugreifen kann.

Erstellen Sie die Anwendung Managed Service for Apache Flink und führen Sie sie aus

Sie können eine Managed Service for Apache Flink-Anwendung entweder mit der Konsole oder dem AWS CLI.

Anmerkung

Wenn Sie die Anwendung mithilfe der Konsole erstellen, AWS Identity and Access Management (IAM) und Amazon CloudWatch Logs-Ressourcen werden für Sie erstellt. Wenn Sie die Anwendung mit dem erstellen AWS CLI, Sie erstellen diese Ressourcen separat.

Erstellen Sie die Anwendung und führen Sie sie aus (Konsole)

Befolgen Sie diese Schritte, um die Anwendung über die Konsole zu erstellen, zu konfigurieren, zu aktualisieren und auszuführen.

Erstellen der Anwendung

  1. Öffnen Sie die Kinesis-Konsole unter https://console.aws.amazon.com/kinesis.

  2. Wählen Sie auf dem Amazon-Kinesis-Dashboard die Option Create analytics application (Analyseanwendung erstellen) aus.

  3. Geben Sie auf der Seite Kinesis Analytics – Anwendung erstellen die Anwendungsdetails wie folgt an:

    • Geben Sie als Anwendungsname ein MyApplication.

    • Geben Sie für Beschreibung den Text My java test app ein.

    • Wählen Sie für Runtime (Laufzeit) die Option Apache Flink 1.6 aus.

  4. Wählen Sie für Zugriffsberechtigungen die Option Rolle erstellen/aktualisieren aus. IAM kinesis-analytics-MyApplication-us-west-2

  5. Wählen Sie Create application aus.

Anmerkung

Wenn Sie mithilfe der Konsole eine Amazon Managed Service for Apache Flink-Anwendung erstellen, haben Sie die Möglichkeit, eine IAM Rolle und Richtlinie für Ihre Anwendung erstellen zu lassen. Ihre Anwendung verwendet diese Rolle und Richtlinie für den Zugriff auf ihre abhängigen Ressourcen. Diese IAM Ressourcen werden anhand Ihres Anwendungsnamens und Ihrer Region wie folgt benannt:

  • Richtlinie: kinesis-analytics-service-MyApplication-us-west-2

  • Rolle: kinesis-analytics-MyApplication-us-west-2

Bearbeiten Sie die IAM Richtlinie

Bearbeiten Sie die IAM Richtlinie, um Berechtigungen für den Zugriff auf die Kinesis-Datenstreams hinzuzufügen.

  1. Öffnen Sie die IAM Konsole unter. https://console.aws.amazon.com/iam/

  2. Wählen Sie Policies (Richtlinien). Wählen Sie die kinesis-analytics-service-MyApplication-us-west-2-Richtlinie aus, die die Konsole im vorherigen Abschnitt für Sie erstellt hat.

  3. Wählen Sie auf der Seite Summary (Übersicht) die Option Edit policy (Richtlinie bearbeiten) aus. Wählen Sie die JSONRegisterkarte.

  4. Fügen Sie den markierten Abschnitt der folgenden Beispielrichtlinie der Richtlinie hinzu. Ersetzen Sie das Beispielkonto IDs (012345678901) durch Ihre Konto-ID.

    { "Version": "2012-10-17", "Statement": [ { "Sid": "ReadCode", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Resource": [ "arn:aws:s3:::ka-app-code-username/java-getting-started-1.0.jar" ] }, { "Sid": "ListCloudwatchLogGroups", "Effect": "Allow", "Action": [ "logs:DescribeLogGroups" ], "Resource": [ "arn:aws:logs:us-west-2:012345678901:log-group:*" ] }, { "Sid": "ListCloudwatchLogStreams", "Effect": "Allow", "Action": [ "logs:DescribeLogStreams" ], "Resource": [ "arn:aws:logs:us-west-2:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*" ] }, { "Sid": "PutCloudwatchLogs", "Effect": "Allow", "Action": [ "logs:PutLogEvents" ], "Resource": [ "arn:aws:logs:us-west-2:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream" ] }, { "Sid": "ReadInputStream", "Effect": "Allow", "Action": "kinesis:*", "Resource": "arn:aws:kinesis:us-west-2:012345678901:stream/ExampleInputStream" }, { "Sid": "WriteOutputStream", "Effect": "Allow", "Action": "kinesis:*", "Resource": "arn:aws:kinesis:us-west-2:012345678901:stream/ExampleOutputStream" } ] }

Konfigurieren Sie die Anwendung

  1. Wählen Sie auf der MyApplicationSeite Configure aus.

  2. Klicken Sie auf der Seite Configure application (Anwendung konfigurieren) auf die Option Code location (Codespeicherort):

    • Geben Sie für Amazon-S3-Bucket ka-app-code-<username> ein.

    • Geben Sie als Pfad zum Amazon-S3-Objekt den Wert java-getting-started-1.0.jar ein.

  3. Wählen Sie unter Zugriff auf Anwendungsressourcen für Zugriffsberechtigungen die Option IAMRolle erstellen/aktualisieren auskinesis-analytics-MyApplication-us-west-2.

  4. Geben Sie unter Eigenschaften für Gruppen-ID den Text ProducerConfigProperties ein.

  5. Geben Sie die folgenden Eigenschaften und Werte der Anwendung ein:

    Schlüssel Wert
    flink.inputstream.initpos LATEST
    aws:region us-west-2
    AggregationEnabled false
  6. Stellen Sie unter Überwachung sicher, dass die Ebene der Überwachungsmetriken auf Anwendung eingestellt ist.

  7. Wählen Sie für die CloudWatch Protokollierung das Kontrollkästchen Aktivieren aus.

  8. Wählen Sie Aktualisieren.

Anmerkung

Wenn Sie die CloudWatch Protokollierung aktivieren möchten, erstellt Managed Service for Apache Flink eine Protokollgruppe und einen Protokollstream für Sie. Die Namen dieser Ressourcen lauten wie folgt:

  • Protokollgruppe: /aws/kinesis-analytics/MyApplication

  • Protokollstream: kinesis-analytics-log-stream

Führen Sie die Anwendung aus.

  1. Wählen Sie auf der MyApplicationSeite die Option Ausführen aus. Bestätigen Sie die Aktion.

  2. Wenn die Anwendung ausgeführt wird, aktualisieren Sie die Seite. Die Konsole zeigt den Application graph (Anwendungs-Graph) an.

Beenden Sie die Anwendung

Wählen Sie auf der MyApplicationSeite Stopp aus. Bestätigen Sie die Aktion.

Aktualisieren der Anwendung

Mithilfe der Konsole können Sie Anwendungseinstellungen wie Anwendungseigenschaften, Überwachungseinstellungen und den Speicherort oder den Dateinamen der Anwendung aktualisierenJAR. Sie können die Anwendung auch JAR aus dem Amazon S3 S3-Bucket neu laden, wenn Sie den Anwendungscode aktualisieren müssen.

Wählen Sie auf der MyApplicationSeite Configure aus. Aktualisieren Sie die Anwendungseinstellungen und klicken Sie auf Aktualisieren.

Erstellen Sie die Anwendung und führen Sie sie aus (AWS CLI)

In diesem Abschnitt verwenden Sie AWS CLI um die Anwendung Managed Service for Apache Flink zu erstellen und auszuführen. Managed Service für Apache Flink verwendet kinesisanalyticsv2 AWS CLI Befehl zum Erstellen von und Interagieren mit Managed Service für Apache Flink-Anwendungen.

Erstellen einer Berechtigungsrichtlinie

Zuerst erstellen Sie eine Berechtigungsrichtlinie mit zwei Anweisungen: eine, die Berechtigungen für die read-Aktion auf den Quell-Stream zulässt, und eine andere, die Berechtigungen für die write-Aktionen auf den Senken-Stream zulässt. Anschließend fügen Sie die Richtlinie einer IAM Rolle hinzu (die Sie im nächsten Abschnitt erstellen). Wenn Managed Service für Apache Flink also die Rolle übernimmt, verfügt der Service über die erforderlichen Berechtigungen zum Lesen aus dem Quell-Stream und zum Schreiben in den Senken-Stream.

Verwenden Sie den folgenden Code zum Erstellen der KAReadSourceStreamWriteSinkStream-Berechtigungsrichtlinie. Ersetzen Sie username durch den Benutzernamen, den Sie verwendet haben, um den Amazon-S3-Bucket zum Speichern des Anwendungscodes zu erstellen. Ersetzen Sie die Konto-ID in den Amazon-Ressourcennamen (ARNs) (012345678901) durch Ihre Konto-ID.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "S3", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Resource": ["arn:aws:s3:::ka-app-code-username", "arn:aws:s3:::ka-app-code-username/*" ] }, { "Sid": "ReadInputStream", "Effect": "Allow", "Action": "kinesis:*", "Resource": "arn:aws:kinesis:us-west-2:012345678901:stream/ExampleInputStream" }, { "Sid": "WriteOutputStream", "Effect": "Allow", "Action": "kinesis:*", "Resource": "arn:aws:kinesis:us-west-2:012345678901:stream/ExampleOutputStream" } ] }

step-by-step Anweisungen zum Erstellen einer Berechtigungsrichtlinie finden Sie unter Tutorial: Erstellen und Anhängen Ihrer ersten vom Kunden verwalteten Richtlinie im IAMBenutzerhandbuch.

Anmerkung

Um auf andere zuzugreifen AWS Dienste können Sie verwenden AWS SDK for Java. Managed Service for Apache Flink setzt automatisch die für die IAM Dienstausführungsrolle erforderlichen Anmeldeinformationen SDK auf die Ihrer Anwendung zugeordnete Dienstausführungsrolle. Es sind keine weiteren Schritte erforderlich.

Erstellen Sie eine IAM-Rolle.

In diesem Abschnitt erstellen Sie eine IAM Rolle, die Managed Service for Apache Flink übernehmen kann, um einen Quellstream zu lesen und in den Sink-Stream zu schreiben.

Managed Service für Apache Flink kann ohne Berechtigungen nicht auf Ihren Stream zugreifen. Sie gewähren diese Berechtigungen über eine IAM Rolle. Jeder IAM Rolle sind zwei Richtlinien zugeordnet. Die Vertrauensrichtlinie erteilt Managed Service für Apache Flink die Berechtigung zum Übernehmen der Rolle und die Berechtigungsrichtlinie bestimmt, was Managed Service für Apache Flink nach Annahme der Rolle tun kann.

Sie können die Berechtigungsrichtlinie, die Sie im vorherigen Abschnitt erstellt haben, dieser Rolle anfügen.

So erstellen Sie eine IAM-Rolle
  1. Öffnen Sie die IAM Konsole unter https://console.aws.amazon.com/iam/.

  2. Wählen Sie im Navigationsbereich Roles (Rollen) und Create Role (Rolle erstellen) aus.

  3. Wählen Sie unter Typ der vertrauenswürdigen Identität auswählen AWS Dienst. Wählen Sie unter Choose the service that will use this role (Wählen Sie den Service aus, der diese Rolle verwendet) die Option Kinesis aus. Wählen Sie unter Select your use case (Wählen Sie Ihren Anwendungsfall aus) die Option Kinesis Analytics aus.

    Wählen Sie Weiter: Berechtigungen aus.

  4. Wählen Sie auf der Seite Attach permissions policies (Berechtigungsrichtlinien hinzufügen) Next: Review (Weiter: Überprüfen) aus. Sie fügen Berechtigungsrichtlinien an, nachdem Sie die Rolle erstellt haben.

  5. Geben Sie auf der Seite Create role (Rolle erstellen) den Text KA-stream-rw-role für Role name (Rollenname) ein. Wählen Sie Rolle erstellen.

    Jetzt haben Sie eine neue IAM Rolle namens erstelltKA-stream-rw-role. Im nächsten Schritt aktualisieren Sie die Vertrauens- und Berechtigungsrichtlinien für die Rolle.

  6. Fügen Sie die Berechtigungsrichtlinie der Rolle an.

    Anmerkung

    Für diese Übung übernimmt Managed Service für Apache Flink diese Rolle sowohl für das Lesen von Daten aus einem Kinesis-Datenstrom (Quelle) als auch zum Schreiben der Ausgabedaten in einen anderen Kinesis-Datenstrom. Daher fügen Sie die Richtlinie an, die Sie im vorherigen Schritt erstellt haben, Erstellen einer Berechtigungsrichtlinie.

    1. Wählen Sie auf der Seite Summary (Übersicht) die Registerkarte Permissions (Berechtigungen) aus.

    2. Wählen Sie Attach Policies (Richtlinien anfügen) aus.

    3. Geben Sie im Suchfeld KAReadSourceStreamWriteSinkStream (die Richtlinie, die Sie im vorhergehenden Abschnitt erstellt haben) ein.

    4. Wählen Sie die KAReadInputStreamWriteOutputStreamRichtlinie aus und klicken Sie auf Richtlinie anhängen.

Sie haben nun die Service-Ausführungsrolle erstellt, die Ihre Anwendung für den Zugriff auf Ressourcen verwendet. Notieren Sie sich die ARN der neuen Rolle.

step-by-step Anweisungen zum Erstellen einer Rolle finden Sie unter Erstellen einer IAM Rolle (Konsole) im IAMBenutzerhandbuch.

Erstellen Sie die Anwendung Managed Service für Apache Flink

  1. Speichern Sie den folgenden JSON Code in einer Datei mit dem Namencreate_request.json. Ersetzen Sie die Beispielrolle ARN durch die ARN für die Rolle, die Sie zuvor erstellt haben. Ersetzen Sie das ARN Bucket-Suffix (username) durch das Suffix, das Sie im vorherigen Abschnitt ausgewählt haben. Ersetzen Sie die beispielhafte Konto-ID (012345678901) in der Service-Ausführungsrolle mit Ihrer Konto-ID.

    { "ApplicationName": "test", "ApplicationDescription": "my java test app", "RuntimeEnvironment": "FLINK-1_6", "ServiceExecutionRole": "arn:aws:iam::012345678901:role/KA-stream-rw-role", "ApplicationConfiguration": { "ApplicationCodeConfiguration": { "CodeContent": { "S3ContentLocation": { "BucketARN": "arn:aws:s3:::ka-app-code-username", "FileKey": "java-getting-started-1.0.jar" } }, "CodeContentType": "ZIPFILE" }, "EnvironmentProperties": { "PropertyGroups": [ { "PropertyGroupId": "ProducerConfigProperties", "PropertyMap" : { "flink.stream.initpos" : "LATEST", "aws.region" : "us-west-2", "AggregationEnabled" : "false" } }, { "PropertyGroupId": "ConsumerConfigProperties", "PropertyMap" : { "aws.region" : "us-west-2" } } ] } } }
  2. Führen Sie die CreateApplication-Aktion mit der vorherigen Anforderung zum Erstellen der Anwendung aus:

    aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json

Die Anwendung wird nun erstellt. Sie starten die Anwendung im nächsten Schritt.

Starten der Anwendung

In diesem Abschnitt verwenden Sie die StartApplication-Aktion, um die Anwendung zu starten.

So starten Sie die Anwendung
  1. Speichern Sie den folgenden JSON Code in einer Datei mit dem Namen. start_request.json

    { "ApplicationName": "test", "RunConfiguration": { "ApplicationRestoreConfiguration": { "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT" } } }
  2. Führen Sie die StartApplication-Aktion mit der vorherigen Anforderung zum Starten der Anwendung aus:

    aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json

Die Anwendung wird jetzt ausgeführt. Sie können die Kennzahlen Managed Service for Apache Flink auf der CloudWatch Amazon-Konsole überprüfen, um sicherzustellen, dass die Anwendung funktioniert.

Stoppen der Anwendung

In diesem Abschnitt verwenden Sie die StopApplication-Aktion, um die Anwendung zu stoppen.

So stoppen Sie die Anwendung
  1. Speichern Sie den folgenden JSON Code in einer Datei mit dem Namenstop_request.json.

    {"ApplicationName": "test" }
  2. Führen Sie die StopApplication-Aktion mit der folgenden Anforderung zum Stoppen der Anwendung aus:

    aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json

Die Anwendung wird nun gestoppt.

DatenschutzNutzungsbedingungen für die WebsiteCookie-Einstellungen
© 2025, Amazon Web Services, Inc. oder Tochtergesellschaften. Alle Rechte vorbehalten.