

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.

# Suchen nach Gesichtern in einer Sammlung im Streaming-Video
<a name="collections-streaming"></a>

Sie können Amazon Rekognition Video verwenden, um Gesichter aus einer Sammlung in Streaming-Videos zu entdecken und zu erkennen. Mit Amazon Rekognition Video können Sie einen Stream-Prozessor ([CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)) erstellen, um die Analyse von Streaming-Videos zu starten und zu verwalten. 

Um ein bekanntes Gesicht in einem Videostrom zu erkennen (Gesichtssuche), verwendet Amazon Rekognition Video Amazon Kinesis Video Streams, um einen Videostrom zu empfangen und zu verarbeiten. Die Analyseergebnisse werden von Amazon Rekognition Video in einen Kinesis-Datenstrom ausgegeben und dann von Ihrer Client-Anwendung gelesen. 

Um Amazon Rekognition Video mit Streaming-Videos verwenden zu können, muss Ihre Anwendung das Folgende implementieren:
+ Ein Kinesis-Videostrom zum Senden von Streaming-Videos an Amazon Rekognition Video. Weitere Informationen Sie im [Entwicklerleitfaden für Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html). 
+ Einen Amazon-Rekognition-Video-Stromprozessor zur Verwaltung der Analyse des Streaming-Videos. Weitere Informationen finden Sie unter [Überblick über den Betrieb des Amazon-Rekognition-Video-Stromprozessors](streaming-video.md#using-rekognition-video-stream-processor).
+ Ein Kinesis-Datenstrom-Benutzer zum Lesen der Analyseergebnisse, die Amazon Rekognition Video an den Kinesis-Datenstrom sendet. Weitere Informationen finden Sie unter [Kinesis- Datenströme-Verbraucher](https://docs.aws.amazon.com/streams/latest/dev/amazon-kinesis-consumers.html). 

Dieser Abschnitt enthält Informationen zum Schreiben einer Anwendung, die den Kinesis-Videostrom und andere erforderliche Ressourcen erstellt, Videos in Amazon Rekognition Video streamt und die Analyseergebnisse empfängt.

**Topics**
+ [Einrichtung Ihrer Amazon-Rekognition-Video- und Amazon-Kinesis-Ressourcen](setting-up-your-amazon-rekognition-streaming-video-resources.md)
+ [Suche nach Gesichtern in einem Streaming-Video](rekognition-video-stream-processor-search-faces.md)
+ [Streaming mit einem GStreamer Plugin](streaming-using-gstreamer-plugin.md)
+ [Fehlerbehebung beim Streamen von Videos](streaming-video-troubleshooting.md)

# Einrichtung Ihrer Amazon-Rekognition-Video- und Amazon-Kinesis-Ressourcen
<a name="setting-up-your-amazon-rekognition-streaming-video-resources"></a>

 In den folgenden Verfahren werden die Schritte beschrieben, die Sie ergreifen, um den Kinesis-Videostrom und andere Ressourcen bereitzustellen, die zur Erkennung von Gesichtern in einem Streaming-Video verwendet werden.

## Voraussetzungen
<a name="streaming-video-prerequisites"></a>

Um dieses Verfahren ausführen zu können, müssen Sie den installiert haben. AWS SDK für Java Weitere Informationen finden Sie unter [Erste Schritte mit Amazon Rekognition](getting-started.md). Die von AWS-Konto Ihnen verwendete Person muss über Zugriffsberechtigungen für die Amazon Rekognition API verfügen. Weitere Informationen finden Sie unter [Von Amazon Rekognition definierte Aktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions) im *IAM-Benutzerhandbuch*. 

**So erkennen Sie Gesichter in einem Videostrom (AWS-SDK)**

1. Falls Sie dies noch nicht getan haben, erstellen Sie eine IAM-Servicerolle, um Amazon Rekognition Video Zugriff auf Ihre Kinesis-Videoströme und Ihre Kinesis-Datenströme zu gewähren. Notieren Sie den ARN. Weitere Informationen finden Sie unter [Zugriff auf Streams gewähren mit AmazonRekognitionServiceRole](api-streaming-video-roles.md#api-streaming-video-roles-all-stream).

1. [Erstellen Sie eine Sammlung](create-collection-procedure.md) und notieren Sie sich die ID der Sammlung, die Sie verwendet haben.

1. [Indizieren Sie die Gesichter](add-faces-to-collection-procedure.md), nach denen Sie suchen möchten, in die Sammlung, die Sie in Schritt 2 erstellt haben.

1. [Erstellen Sie einen Kinesis-Videostrom](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html) und notieren Sie sich den Amazon-Ressourcennamen (ARN) des Streams.

1. [Erstellen Sie einen Kinesis-Datenstrom](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html). Stellen Sie dem Stream-Namen den ARN des Streams voran *AmazonRekognition*und notieren Sie sich diesen.

Anschließend können Sie [den Gesichtssuche-Stromprozessor erstellen](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor) und den [Stromprozessor mit dem von Ihnen ausgewählten Stromprozessornamen starten](rekognition-video-stream-processor-search-faces.md#streaming-video-starting-stream-processor).

**Anmerkung**  
 Sie sollten den Stromprozessor erst starten, nachdem Sie sich vergewissert haben, dass Sie Medien in den Kinesis-Videostrom aufnehmen können. 

## Streaming-Video von Amazon Rekognition Video
<a name="video-streaming-kinesisvideostreams-stream"></a>

Um Video in Amazon Rekognition Video zu streamen, verwenden Sie das Amazon Kinesis Video Streams SDK, um einen Kinesis-Videostrom zu erstellen und zu verwenden. Die `PutMedia`-Operation schreibt Videodaten*fragmente* in einen Kinesis-Videostrom, der von Amazon Rekognition Video genutzt wird. Jedes Videodatenfragment ist typischerweise 2–10 Sekunden lang und enthält eine in sich geschlossene Sequenz von Videobildern. Amazon Rekognition Video unterstützt H.264-kodierte Videos, die drei Arten von Frames (I, B und P) enthalten können. Weitere Informationen finden Sie unter [Inter Frame](https://en.wikipedia.org/wiki/Inter_frame). Der erste Frame im Fragment muss ein I-Frame sein. Ein I-Frame kann unabhängig von anderen Frames entschlüsselt werden. 

Wenn Videodaten im Kinesis-Videostrom ankommen, weist Kinesis Video Streams dem Fragment eine eindeutige Nummer zu. Ein Beispiel finden Sie unter [PutMedia API-Beispiel](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html).
+  Wenn Sie von einer Matroska (MKV) -codierten Quelle streamen, verwenden Sie den [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)Vorgang, um das Quellvideo in den Kinesis-Videostream zu streamen, den Sie erstellt haben. [Weitere Informationen finden Sie unter API-Beispiel. PutMedia ](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html) 
+  Wenn Sie von einer Gerätekamera streamen, finden Sie weitere Informationen unter [Streaming mit einem GStreamer Plugin](streaming-using-gstreamer-plugin.md).

# Gewähren von Zugriff auf Ihre Ressourcen für Amazon Rekognition Video
<a name="api-streaming-video-roles"></a>

Sie verwenden eine AWS Identity and Access Management (IAM) -Servicerolle, um Amazon Rekognition Video Lesezugriff auf Kinesis-Videostreams zu gewähren. Wenn Sie einen Gesichts-Stromprozessor verwenden, verwenden Sie eine IAM-Servicerolle, um Amazon Rekognition Video Schreibzugriff auf Kinesis-Datenströme zu gewähren. Wenn Sie einen Stromprozessor für die Sicherheitsüberwachung verwenden, verwenden Sie IAM-Rollen, um Amazon Rekognition Video Zugriff auf Ihren Amazon-S3-Bucket und auf ein Amazon-SNS-Thema zu gewähren.

## Zugriff für Gesichtssuche-Stromprozessoren gewähren
<a name="api-streaming-video-roles-single-stream"></a>

Sie können eine Berechtigungsrichtlinie erstellen, die Amazon Rekognition Video den Zugriff auf einzelne Kinesis-Videoströme und Kinesis-Datenströme ermöglicht.

**Um Amazon Rekognition Video Zugriff auf einen Stromprozessor für die Gesichtssuche zu gewähren**

1. [ Erstellen Sie mit dem IAM JSON Policy Editor](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) eine neue Berechtigungsrichtlinie und verwenden Sie die folgende Richtlinie. Ersetzen Sie `video-arn` durch den ARN des gewünschten Kinesis-Videostroms. Wenn Sie einen Gesichtssuche-Stromprozessor verwenden, ersetzen Sie `data-arn` durch den ARN des gewünschten Kinesis-Datenstroms.

1. [Erstellen Sie ein IAM-Servicerolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console) oder aktualisieren Sie eine bestehende IAM-Servicerolle. Verwenden Sie die folgenden Informationen, um die IAM-Servicerolle zu erstellen:

   1. Wählen Sie **Rekognition** als Servicenamen.

   1. Wählen Sie **Rekognition** für den Anwendungsfall der Service-Rolle.

   1. Fügen Sie die Berechtigungsrichtlinie hinzu, die Sie in Schritt 1 erstellt haben.

1. Notieren Sie den ARN der Service-Rolle. Sie benötigen ihn, um Videoanalyse-Operationen zu starten.

## Zugriff auf Streams gewähren mit AmazonRekognitionServiceRole
<a name="api-streaming-video-roles-all-stream"></a>

 Als alternative Option für die Einrichtung des Zugriffs auf Kinesis-Videoströme und Datenströme können Sie die `AmazonRekognitionServiceRole`-Berechtigungsrichtlinie verwenden. IAM bietet den Anwendungsfall der *Rekognition*-Servicerolle, die in Verbindung mit der `AmazonRekognitionServiceRole`-Berechtigungsrichtlinie in mehrere Kinesis-Datenströme schreiben und aus allen Ihren Kinesis-Videoströmen lesen kann. Um Amazon Rekognition Video Schreibzugriff auf mehrere Kinesis-Datenstreams zu gewähren, können Sie den Namen der Kinesis-Datenstreams Folgendes voranstellen — zum Beispiel. *AmazonRekognition*`AmazonRekognitionMyDataStreamName` 

**Um Amazon Rekognition Video Zugriff auf Ihren Kinesis-Videostrom und Kinesis-Datenstrom zu gewähren**

1. [Erstellen Sie eine IAM-Servicerolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console). Verwenden Sie die folgenden Informationen, um die IAM-Servicerolle zu erstellen:

   1. Wählen Sie **Rekognition** als Servicenamen.

   1. Wählen Sie **Rekognition** für den Anwendungsfall der Service-Rolle.

   1. Wählen Sie die **AmazonRekognitionServiceRole**Berechtigungsrichtlinie, die Amazon Rekognition Video Schreibzugriff auf Kinesis-Datenstreams mit Präfix *AmazonRekognition*und Lesezugriff auf all Ihre Kinesis-Videostreams gewährt.

1. Um sicherzustellen, AWS-Konto dass Sie sicher sind, beschränken Sie den Zugriff von Rekognition auf die Ressourcen, die Sie verwenden. Dies kann erreicht werden, indem Sie Ihrer IAM-Servicerolle eine Vertrauensrichtlinie hinzufügen. Weitere Informationen hierzu finden Sie unter [Serviceübergreifende Confused-Deputy-Prävention](cross-service-confused-deputy-prevention.md).

1. Notieren Sie sich den Amazon-Ressourcennamen (ARN) der Service-Rolle. Sie benötigen ihn, um Videoanalyse-Operationen zu starten.

# Suche nach Gesichtern in einem Streaming-Video
<a name="rekognition-video-stream-processor-search-faces"></a>

Amazon Rekognition Video kann Gesichter in einer Sammlung suchen, die mit Gesichtern übereinstimmen, die in einem Streaming-Video erkannt werden. Weitere Informationen über Sammlungen finden Sie unter [Gesichtssuche in einer Sammlung](collections.md).

**Topics**
+ [Erstellen des Amazon-Rekognition-Video-Gesichtssuche-Stromprozessors](#streaming-video-creating-stream-processor)
+ [Starten des Amazon-Rekognition-Video-Gesichtssuche-Stromprozessors](#streaming-video-starting-stream-processor)
+ [Verwendung von Stromprozessoren für die Gesichtssuche (Beispiel Java V2)](#using-stream-processors-v2)
+ [Verwendung von Stromprozessoren für die Gesichtssuche (Beispiel Java V1)](#using-stream-processors)
+ [Lesen von Streaming-Video-Analyseergebnissen](streaming-video-kinesis-output.md)
+ [Lokales Anzeigen von Rekognition-Ergebnissen mit Kinesis Video Streams](displaying-rekognition-results-locally.md)
+ [Den JSON-Frame-Datensatz für Kinesis-Gesichtserkennung verstehen](streaming-video-kinesis-output-reference.md)

Das folgende Diagramm zeigt, wie Amazon Rekognition Video Gesichter in einem Streaming-Video entdeckt und erkennt.

![\[Diagramm des Workflows für die Verwendung von Amazon Rekognition Video zur Verarbeitung von Videostreams von Amazon Kinesis.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/VideoRekognitionStream.png)


## Erstellen des Amazon-Rekognition-Video-Gesichtssuche-Stromprozessors
<a name="streaming-video-creating-stream-processor"></a>

Bevor Sie ein Streaming-Video analysieren können, erstellen Sie einen Amazon Rekognition Video Video-Stream-Prozessor () [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html). Der Stromprozessor enthält Informationen über den Kinesis-Datenstrom und den Kinesis-Videostrom. Enthalten ist auch die ID für die Sammlung der Gesichter, die Sie im bereitgestellten Streaming-Video erkennen möchten. Außerdem geben Sie einen Namen für den Stromprozessor an. Im Folgenden sehen Sie ein JSON-Beispiel für die Anforderung von `CreateStreamProcessor`.

```
{
       "Name": "streamProcessorForCam",
       "Input": {
              "KinesisVideoStream": {
                     "Arn": "arn:aws:kinesisvideo:us-east-1:nnnnnnnnnnnn:stream/inputVideo"
              }
       },
       "Output": {
              "KinesisDataStream": {
                     "Arn": "arn:aws:kinesis:us-east-1:nnnnnnnnnnnn:stream/outputData"
              }
       },
       "RoleArn": "arn:aws:iam::nnnnnnnnnnn:role/roleWithKinesisPermission",
       "Settings": {
              "FaceSearch": {
                     "CollectionId": "collection-with-100-faces",
                     "FaceMatchThreshold": 85.5
              }
       }
}
```

Das folgende Beispiel ist eine Antwort von `CreateStreamProcessor`.

```
{
       “StreamProcessorArn”: “arn:aws:rekognition:us-east-1:nnnnnnnnnnnn:streamprocessor/streamProcessorForCam”
}
```

## Starten des Amazon-Rekognition-Video-Gesichtssuche-Stromprozessors
<a name="streaming-video-starting-stream-processor"></a>

Sie beginnen die Analyse des Streaming-Videos, indem Sie [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) mit dem Streaming-Prozessor-Namen aufrufen, den Sie in `CreateStreamProcessor` festgelegt haben. Im Folgenden sehen Sie ein JSON-Beispiel für die Anforderung von `StartStreamProcessor`.

```
{
       "Name": "streamProcessorForCam"
}
```

Wenn der Stromprozessor erfolgreich beginnt, wird eine HTTP-200-Antwort zurückgegeben, zusammen mit einem leeren JSON-Text.

## Verwendung von Stromprozessoren für die Gesichtssuche (Beispiel Java V2)
<a name="using-stream-processors-v2"></a>

Der folgende Beispielcode zeigt, wie verschiedene Streamprozessor-Operationen, wie [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)und [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html), mit dem AWS SDK for Java Version 2 aufgerufen werden.

Dieser Code stammt aus dem AWS Documentation SDK Examples GitHub Repository. Das vollständige Beispiel finden Sie [hier](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/CreateStreamProcessor.java).

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.CreateStreamProcessorResponse;
import software.amazon.awssdk.services.rekognition.model.FaceSearchSettings;
import software.amazon.awssdk.services.rekognition.model.KinesisDataStream;
import software.amazon.awssdk.services.rekognition.model.KinesisVideoStream;
import software.amazon.awssdk.services.rekognition.model.ListStreamProcessorsRequest;
import software.amazon.awssdk.services.rekognition.model.ListStreamProcessorsResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.StreamProcessor;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorInput;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorSettings;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorOutput;
import software.amazon.awssdk.services.rekognition.model.StartStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeStreamProcessorResponse;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 * <p>
 * For more information, see the following documentation topic:
 * <p>
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class CreateStreamProcessor {
    public static void main(String[] args) {
        final String usage = """
                
                Usage:    <role> <kinInputStream> <kinOutputStream> <collectionName> <StreamProcessorName>
                
                Where:
                   role - The ARN of the AWS Identity and Access Management (IAM) role to use. \s
                   kinInputStream - The ARN of the Kinesis video stream.\s
                   kinOutputStream - The ARN of the Kinesis data stream.\s
                   collectionName - The name of the collection to use that contains content. \s
                   StreamProcessorName - The name of the Stream Processor. \s
                """;

        if (args.length != 5) {
            System.out.println(usage);
            System.exit(1);
        }

        String role = args[0];
        String kinInputStream = args[1];
        String kinOutputStream = args[2];
        String collectionName = args[3];
        String streamProcessorName = args[4];

        Region region = Region.US_EAST_1;
        RekognitionClient rekClient = RekognitionClient.builder()
                .region(region)
                .build();

        processCollection(rekClient, streamProcessorName, kinInputStream, kinOutputStream, collectionName,
                role);
        startSpecificStreamProcessor(rekClient, streamProcessorName);
        listStreamProcessors(rekClient);
        describeStreamProcessor(rekClient, streamProcessorName);
        deleteSpecificStreamProcessor(rekClient, streamProcessorName);
    }

    public static void listStreamProcessors(RekognitionClient rekClient) {
        ListStreamProcessorsRequest request = ListStreamProcessorsRequest.builder()
                .maxResults(15)
                .build();

        ListStreamProcessorsResponse listStreamProcessorsResult = rekClient.listStreamProcessors(request);
        for (StreamProcessor streamProcessor : listStreamProcessorsResult.streamProcessors()) {
            System.out.println("StreamProcessor name - " + streamProcessor.name());
            System.out.println("Status - " + streamProcessor.status());
        }
    }

    private static void describeStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
        DescribeStreamProcessorRequest streamProcessorRequest = DescribeStreamProcessorRequest.builder()
                .name(StreamProcessorName)
                .build();

        DescribeStreamProcessorResponse describeStreamProcessorResult = rekClient
                .describeStreamProcessor(streamProcessorRequest);
        System.out.println("Arn - " + describeStreamProcessorResult.streamProcessorArn());
        System.out.println("Input kinesisVideo stream - "
                + describeStreamProcessorResult.input().kinesisVideoStream().arn());
        System.out.println("Output kinesisData stream - "
                + describeStreamProcessorResult.output().kinesisDataStream().arn());
        System.out.println("RoleArn - " + describeStreamProcessorResult.roleArn());
        System.out.println(
                "CollectionId - "
                        + describeStreamProcessorResult.settings().faceSearch().collectionId());
        System.out.println("Status - " + describeStreamProcessorResult.status());
        System.out.println("Status message - " + describeStreamProcessorResult.statusMessage());
        System.out.println("Creation timestamp - " + describeStreamProcessorResult.creationTimestamp());
        System.out.println("Last update timestamp - " + describeStreamProcessorResult.lastUpdateTimestamp());
    }

    private static void startSpecificStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
        try {
            StartStreamProcessorRequest streamProcessorRequest = StartStreamProcessorRequest.builder()
                    .name(StreamProcessorName)
                    .build();

            rekClient.startStreamProcessor(streamProcessorRequest);
            System.out.println("Stream Processor " + StreamProcessorName + " started.");

        } catch (RekognitionException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }

    private static void processCollection(RekognitionClient rekClient, String StreamProcessorName,
                                          String kinInputStream, String kinOutputStream, String collectionName, String role) {
        try {
            KinesisVideoStream videoStream = KinesisVideoStream.builder()
                    .arn(kinInputStream)
                    .build();

            KinesisDataStream dataStream = KinesisDataStream.builder()
                    .arn(kinOutputStream)
                    .build();

            StreamProcessorOutput processorOutput = StreamProcessorOutput.builder()
                    .kinesisDataStream(dataStream)
                    .build();

            StreamProcessorInput processorInput = StreamProcessorInput.builder()
                    .kinesisVideoStream(videoStream)
                    .build();

            FaceSearchSettings searchSettings = FaceSearchSettings.builder()
                    .faceMatchThreshold(75f)
                    .collectionId(collectionName)
                    .build();

            StreamProcessorSettings processorSettings = StreamProcessorSettings.builder()
                    .faceSearch(searchSettings)
                    .build();

            CreateStreamProcessorRequest processorRequest = CreateStreamProcessorRequest.builder()
                    .name(StreamProcessorName)
                    .input(processorInput)
                    .output(processorOutput)
                    .roleArn(role)
                    .settings(processorSettings)
                    .build();

            CreateStreamProcessorResponse response = rekClient.createStreamProcessor(processorRequest);
            System.out.println("The ARN for the newly create stream processor is "
                    + response.streamProcessorArn());

        } catch (RekognitionException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }

    private static void deleteSpecificStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
        rekClient.stopStreamProcessor(a -> a.name(StreamProcessorName));
        rekClient.deleteStreamProcessor(a -> a.name(StreamProcessorName));
        System.out.println("Stream Processor " + StreamProcessorName + " deleted.");
    }
}
```

## Verwendung von Stromprozessoren für die Gesichtssuche (Beispiel Java V1)
<a name="using-stream-processors"></a>

Der folgende Beispielcode zeigt, wie verschiedene Streamprozessor-Operationen wie [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)und [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html)mit Java V1 aufgerufen werden. Das Beispiel beinhaltet eine Streamprozessor-Manager-Klasse (StreamManager), die Methoden zum Aufrufen von Streamprozessor-Operationen bereitstellt. Die Starterklasse (Starter) erstellt ein StreamManager Objekt und ruft verschiedene Operationen auf. 

**So konfigurieren Sie das Beispiel:**

1. Legen Sie die Werte der Mitgliedsfelder der Starterklasse auf Ihre gewünschten Werte fest.

1. Entfernen Sie den gewünschten Funktionsaufruf in der Starterklassenfunktion `main`.

### Starterklasse
<a name="streaming-started"></a>

```
//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

// Starter class. Use to create a StreamManager class
// and call stream processor operations.
package com.amazonaws.samples;
import com.amazonaws.samples.*;

public class Starter {

	public static void main(String[] args) {
		
		
    	String streamProcessorName="Stream Processor Name";
    	String kinesisVideoStreamArn="Kinesis Video Stream Arn";
    	String kinesisDataStreamArn="Kinesis Data Stream Arn";
    	String roleArn="Role Arn";
    	String collectionId="Collection ID";
    	Float matchThreshold=50F;

		try {
			StreamManager sm= new StreamManager(streamProcessorName,
					kinesisVideoStreamArn,
					kinesisDataStreamArn,
					roleArn,
					collectionId,
					matchThreshold);
			//sm.createStreamProcessor();
			//sm.startStreamProcessor();
			//sm.deleteStreamProcessor();
			//sm.deleteStreamProcessor();
			//sm.stopStreamProcessor();
			//sm.listStreamProcessors();
			//sm.describeStreamProcessor();
		}
		catch(Exception e){
			System.out.println(e.getMessage());
		}
	}
}
```

### StreamManager Klasse
<a name="streaming-manager"></a>

```
//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

// Stream manager class. Provides methods for calling
// Stream Processor operations.
package com.amazonaws.samples;

import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.CreateStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.CreateStreamProcessorResult;
import com.amazonaws.services.rekognition.model.DeleteStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.DeleteStreamProcessorResult;
import com.amazonaws.services.rekognition.model.DescribeStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.DescribeStreamProcessorResult;
import com.amazonaws.services.rekognition.model.FaceSearchSettings;
import com.amazonaws.services.rekognition.model.KinesisDataStream;
import com.amazonaws.services.rekognition.model.KinesisVideoStream;
import com.amazonaws.services.rekognition.model.ListStreamProcessorsRequest;
import com.amazonaws.services.rekognition.model.ListStreamProcessorsResult;
import com.amazonaws.services.rekognition.model.StartStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.StartStreamProcessorResult;
import com.amazonaws.services.rekognition.model.StopStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.StopStreamProcessorResult;
import com.amazonaws.services.rekognition.model.StreamProcessor;
import com.amazonaws.services.rekognition.model.StreamProcessorInput;
import com.amazonaws.services.rekognition.model.StreamProcessorOutput;
import com.amazonaws.services.rekognition.model.StreamProcessorSettings;

public class StreamManager {

    private String streamProcessorName;
    private String kinesisVideoStreamArn;
    private String kinesisDataStreamArn;
    private String roleArn;
    private String collectionId;
    private float matchThreshold;

    private AmazonRekognition rekognitionClient;
    

    public StreamManager(String spName,
    		String kvStreamArn,
    		String kdStreamArn,
    		String iamRoleArn,
    		String collId,
    		Float threshold){
    	streamProcessorName=spName;
    	kinesisVideoStreamArn=kvStreamArn;
    	kinesisDataStreamArn=kdStreamArn;
    	roleArn=iamRoleArn;
    	collectionId=collId;
    	matchThreshold=threshold;
    	rekognitionClient=AmazonRekognitionClientBuilder.defaultClient();
    	
    }
    
    public void createStreamProcessor() {
    	//Setup input parameters
        KinesisVideoStream kinesisVideoStream = new KinesisVideoStream().withArn(kinesisVideoStreamArn);
        StreamProcessorInput streamProcessorInput =
                new StreamProcessorInput().withKinesisVideoStream(kinesisVideoStream);
        KinesisDataStream kinesisDataStream = new KinesisDataStream().withArn(kinesisDataStreamArn);
        StreamProcessorOutput streamProcessorOutput =
                new StreamProcessorOutput().withKinesisDataStream(kinesisDataStream);
        FaceSearchSettings faceSearchSettings =
                new FaceSearchSettings().withCollectionId(collectionId).withFaceMatchThreshold(matchThreshold);
        StreamProcessorSettings streamProcessorSettings =
                new StreamProcessorSettings().withFaceSearch(faceSearchSettings);

        //Create the stream processor
        CreateStreamProcessorResult createStreamProcessorResult = rekognitionClient.createStreamProcessor(
                new CreateStreamProcessorRequest().withInput(streamProcessorInput).withOutput(streamProcessorOutput)
                        .withSettings(streamProcessorSettings).withRoleArn(roleArn).withName(streamProcessorName));

        //Display result
        System.out.println("Stream Processor " + streamProcessorName + " created.");
        System.out.println("StreamProcessorArn - " + createStreamProcessorResult.getStreamProcessorArn());
    }

    public void startStreamProcessor() {
        StartStreamProcessorResult startStreamProcessorResult =
                rekognitionClient.startStreamProcessor(new StartStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " started.");
    }

    public void stopStreamProcessor() {
        StopStreamProcessorResult stopStreamProcessorResult =
                rekognitionClient.stopStreamProcessor(new StopStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " stopped.");
    }

    public void deleteStreamProcessor() {
        DeleteStreamProcessorResult deleteStreamProcessorResult = rekognitionClient
                .deleteStreamProcessor(new DeleteStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " deleted.");
    }

    public void describeStreamProcessor() {
        DescribeStreamProcessorResult describeStreamProcessorResult = rekognitionClient
                .describeStreamProcessor(new DescribeStreamProcessorRequest().withName(streamProcessorName));

        //Display various stream processor attributes.
        System.out.println("Arn - " + describeStreamProcessorResult.getStreamProcessorArn());
        System.out.println("Input kinesisVideo stream - "
                + describeStreamProcessorResult.getInput().getKinesisVideoStream().getArn());
        System.out.println("Output kinesisData stream - "
                + describeStreamProcessorResult.getOutput().getKinesisDataStream().getArn());
        System.out.println("RoleArn - " + describeStreamProcessorResult.getRoleArn());
        System.out.println(
                "CollectionId - " + describeStreamProcessorResult.getSettings().getFaceSearch().getCollectionId());
        System.out.println("Status - " + describeStreamProcessorResult.getStatus());
        System.out.println("Status message - " + describeStreamProcessorResult.getStatusMessage());
        System.out.println("Creation timestamp - " + describeStreamProcessorResult.getCreationTimestamp());
        System.out.println("Last update timestamp - " + describeStreamProcessorResult.getLastUpdateTimestamp());
    }

    public void listStreamProcessors() {
        ListStreamProcessorsResult listStreamProcessorsResult =
                rekognitionClient.listStreamProcessors(new ListStreamProcessorsRequest().withMaxResults(100));

        //List all stream processors (and state) returned from Rekognition
        for (StreamProcessor streamProcessor : listStreamProcessorsResult.getStreamProcessors()) {
            System.out.println("StreamProcessor name - " + streamProcessor.getName());
            System.out.println("Status - " + streamProcessor.getStatus());
        }
    }
}
```

# Lesen von Streaming-Video-Analyseergebnissen
<a name="streaming-video-kinesis-output"></a>

Sie können die Amazon-Kinesis-Data-Streams-Client-Bibliothek verwenden, um Analyseergebnisse zu verwenden, die an den Amazon-Kinesis-Data-Streams-Ausgabestrom gesendet werden. Weitere Informationen finden Sie unter [Lesen von Daten aus einem Kinesis-Datenstrom](https://docs.aws.amazon.com/streams/latest/dev/building-consumers.html). Amazon Rekognition Video stellt für jeden analysierten Frame einen JSON-Frame-Datensatz in den Kinesis-Ausgabestrom. Amazon Rekognition Video analysiert nicht jedes Bild, das über den Kinesis-Videostrom an Amazon Rekognition Video weitergegeben wird. 

Ein Frame-Datensatz, der an einen Kinesis-Datenstrom gesendet wird, enthält Informationen darüber, in welchem Kinesis-Videostrom-Fragment sich der Frame befindet, wo im Fragment der Frame ist und die Gesichter, die im Frame erkannt werden. Es sind auch Statusinformationen für den Stromprozessor enthalten. Weitere Informationen finden Sie unter [Den JSON-Frame-Datensatz für Kinesis-Gesichtserkennung verstehen](streaming-video-kinesis-output-reference.md).

Die Amazon-Kinesis-Video-Streams-Parser-Bibliothek enthält Beispieltests, die Amazon-Rekognition-Video-Ergebnisse verwenden, und integriert sie in den ursprünglichen Kinesis-Videostrom. Weitere Informationen finden Sie unter [Lokales Anzeigen von Rekognition-Ergebnissen mit Kinesis Video Streams](displaying-rekognition-results-locally.md).

Amazon Rekognition Video streamt Analyseinformationen von Amazon Rekognition Video in den Kinesis-Datenstrom. Im Folgenden sehen Sie ein JSON-Beispiel für eine einzelne Aufzeichnung. 

```
{
  "InputInformation": {
    "KinesisVideo": {
      "StreamArn": "arn:aws:kinesisvideo:us-west-2:nnnnnnnnnnnn:stream/stream-name",
      "FragmentNumber": "91343852333289682796718532614445757584843717598",
      "ServerTimestamp": 1510552593.455,
      "ProducerTimestamp": 1510552593.193,
      "FrameOffsetInSeconds": 2
    }
  },
  "StreamProcessorInformation": {
    "Status": "RUNNING"
  },
  "FaceSearchResponse": [
    {
      "DetectedFace": {
        "BoundingBox": {
          "Height": 0.075,
          "Width": 0.05625,
          "Left": 0.428125,
          "Top": 0.40833333
        },
        "Confidence": 99.975174,
        "Landmarks": [
          {
            "X": 0.4452057,
            "Y": 0.4395594,
            "Type": "eyeLeft"
          },
          {
            "X": 0.46340984,
            "Y": 0.43744427,
            "Type": "eyeRight"
          },
          {
            "X": 0.45960626,
            "Y": 0.4526856,
            "Type": "nose"
          },
          {
            "X": 0.44958648,
            "Y": 0.4696949,
            "Type": "mouthLeft"
          },
          {
            "X": 0.46409217,
            "Y": 0.46704912,
            "Type": "mouthRight"
          }
        ],
        "Pose": {
          "Pitch": 2.9691637,
          "Roll": -6.8904796,
          "Yaw": 23.84388
        },
        "Quality": {
          "Brightness": 40.592964,
          "Sharpness": 96.09616
        }
      },
      "MatchedFaces": [
        {
          "Similarity": 88.863960,
          "Face": {
            "BoundingBox": {
              "Height": 0.557692,
              "Width": 0.749838,
              "Left": 0.103426,
              "Top": 0.206731
            },
            "FaceId": "ed1b560f-d6af-5158-989a-ff586c931545",
            "Confidence": 99.999201,
            "ImageId": "70e09693-2114-57e1-807c-50b6d61fa4dc",
            "ExternalImageId": "matchedImage.jpeg"
          }
        }
      ]
    }
  ]
}
```

Beachten Sie im JSON-Beispiel Folgendes:
+ **InputInformation**— Informationen über den Kinesis-Videostream, der zum Streamen von Videos in Amazon Rekognition Video verwendet wird. Weitere Informationen finden Sie unter [InputInformation](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-inputinformation).
+ **StreamProcessorInformation**— Statusinformationen für den Amazon Rekognition Video Video-Stream-Prozessor. Der einzige mögliche Wert für das Feld `Status` ist RUNNING. Weitere Informationen finden Sie unter [StreamProcessorInformation](streaming-video-kinesis-output-reference-streamprocessorinformation.md).
+ **FaceSearchResponse**— Enthält Informationen zu Gesichtern im Streaming-Video, die mit Gesichtern in der Eingabesammlung übereinstimmen. [FaceSearchResponse](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facesearchresponse)enthält ein [DetectedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-detectedface) Objekt, bei dem es sich um ein Gesicht handelt, das im analysierten Videoframe erkannt wurde. Für jedes erkannte Gesicht enthält das Array `MatchedFaces` ein Array mit übereinstimmenden Gesichtsobjekten ([MatchedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facematch)), die in der Eingabesammlung gefunden wurden, ebenso wie einen Ähnlichkeitswert. 

## Zuweisen des Kinesis-Videoströme zum Kinesis-Datenstrom
<a name="mapping-streams"></a>

Möglicherweise möchten Sie die Bilder des Kinesis-Videostroms den analysierten Bildern zuordnen, die an den Kinesis-Datenstrom gesendet werden. Beispielsweise möchten Sie während der Anzeige eines Streaming-Videos vielleicht, dass die Gesichter erkannter Personen eingerahmt werden. Die Begrenzungsrahmen-Koordinaten werden als Teil des Kinesis-Gesichtserkennungsdatensatzes an den Kinesis-Datenstrom gesendet. Damit der Begrenzungsrahmen richtig angezeigt wird, müssen Sie die Zeitinformationen, die zusammen mit der Kinesis-Gesichtserkennungsaufzeichnung gesendet werden, den entsprechenden Frames im Quell-Kinesis-Videostrom zuordnen.

Welche Methode Sie für die Zuweisung des Kinesis-Videostroms zum Kinesis-Datenstrom verwenden, hängt davon ab, ob Live-Medien (z. B. ein Live-Streaming-Video) oder archivierte Medien (z. B. ein gespeichertes Video) gestromt werden.

### Zuweisung beim Streamen von Live-Medien
<a name="mapping-streaming-video"></a>

**So ordnen Sie einen Kinesis-Videostrom-Frame einem Kinesis-Datenstrom-Frame zu**

1. Stellen Sie den Eingabeparameter `FragmentTimeCodeType` der [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)Operation auf ein`RELATIVE`. 

1. Rufen Sie `PutMedia` an, um Live-Medien in den Kinesis-Videostrom zu übertragen.

1. Wenn Sie einen Kinesis-Gesichtserkennungsdatensatz aus dem Kinesis-Datenstrom erhalten, speichern Sie die Werte von `ProducerTimestamp` und `FrameOffsetInSeconds` aus dem [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo)-Feld.

1. Berechnen Sie den Zeitstempel, der dem Kinesis-Videostrom-Frame entspricht, indem Sie die `ProducerTimestamp`- und `FrameOffsetInSeconds`-Feldwerte addieren. 

### Zuweisung beim Streamen archivierter Medien
<a name="map-stored-video"></a>

**So ordnen Sie einen Kinesis-Videostrom-Frame einem Kinesis-Datenstrom-Frame zu**

1. Rufen Sie [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)an, um archivierte Medien in den Kinesis-Videostream zu übertragen.

1. Wenn Sie als Antwort auf die `Acknowledgement`-Operation ein `PutMedia`-Objekt erhalten, speichern Sie den `FragmentNumber`-Wert aus dem Feld [Nutzlast](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html#API_dataplane_PutMedia_ResponseSyntax). `FragmentNumber` ist die Fragmentnummer des MKV-Clusters. 

1. Wenn Sie einen Kinesis-Gesichtserkennungsdatensatz aus dem Kinesis-Datenstrom erhalten, speichern Sie den `FrameOffsetInSeconds`-Feldwert aus dem [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo)-Feld. 

1. Berechnen Sie die Zuweisung anhand der von Ihnen in den Schritten 2 und 3 gespeicherten Werte von `FrameOffsetInSeconds` und `FragmentNumber`. `FrameOffsetInSeconds` ist der Versatz innerhalb des Fragments mit der spezifischen `FragmentNumber`, die zum für Amazon-Kinesis-Datenstrom gesendet wurde. Weitere Informationen zum Abrufen der Video-Frames für eine bestimmte Fragmentnummer finden Sie im Thema zu [Archivierte Medien in Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_Operations_Amazon_Kinesis_Video_Streams_Archived_Media.html).

# Lokales Anzeigen von Rekognition-Ergebnissen mit Kinesis Video Streams
<a name="displaying-rekognition-results-locally"></a>

 [Sie können die Ergebnisse von Amazon Rekognition Video in Ihrem Feed von Amazon Kinesis Video Streams anhand der Beispieltests der Amazon Kinesis Video Streams Parser Library sehen, die Sie unter — Rekognition Examples finden. KinesisVideo ](https://github.com/aws/amazon-kinesis-video-streams-parser-library#kinesisvideo---rekognition-examples) `KinesisVideoRekognitionIntegrationExample`Zeigt Begrenzungsrahmen über erkannten Gesichtern an und rendert das Video lokal durch. JFrame Diese Operation setzt voraus, dass Sie erfolgreich eine Medieneingabe von einer Gerätekamera mit einem Kinesis-Videostrom verbunden und einen Amazon-Rekognition-Stromprozessor gestartet haben. Weitere Informationen finden Sie unter [Streaming mit einem GStreamer Plugin](streaming-using-gstreamer-plugin.md). 

## Schritt 1: Installieren der Kinesis-Videostrom-Parser-Bibliothek
<a name="step-1-install-parser-library"></a>

 Um ein Verzeichnis zu erstellen und das GitHub-Repository herunterzuladen, führen Sie den folgenden Befehl aus: 

```
$ git clone https://github.com/aws/amazon-kinesis-video-streams-parser-library.git
```

 Navigieren Sie zum Bibliotheksverzeichnis und führen Sie den folgenden Maven-Befehl aus, um eine Neuinstallation durchzuführen: 

```
$ mvn clean install
```

## Schritt 2: Konfiguration des Beispieltests zur Integration von Kinesis-Videoströmen und Rekognition
<a name="step-2-configure-kinesis-video-rekognition-example-test"></a>

 Öffnen Sie die `KinesisVideoRekognitionIntegrationExampleTest.java` Datei. Entfernen Sie das `@Ignore` gleich nach dem Klassen-Header. Füllen Sie die Datenfelder mit den Informationen aus Ihren Amazon-Kinesis- und Amazon-Rekognition-Ressourcen. Weitere Informationen finden Sie unter [Einrichtung Ihrer Amazon-Rekognition-Video- und Amazon-Kinesis-Ressourcen](setting-up-your-amazon-rekognition-streaming-video-resources.md). Wenn Sie Video in Ihren Kinesis-Videostrom streamen, entfernen Sie den `inputStream`-Parameter. 

 Beachten Sie hierzu das folgende Codebeispiel: 

```
RekognitionInput rekognitionInput = RekognitionInput.builder()
  .kinesisVideoStreamArn("arn:aws:kinesisvideo:us-east-1:123456789012:stream/rekognition-test-video-stream")
  .kinesisDataStreamArn("arn:aws:kinesis:us-east-1:123456789012:stream/AmazonRekognition-rekognition-test-data-stream")
  .streamingProcessorName("rekognition-test-stream-processor")
  // Refer how to add face collection :
  // https://docs.aws.amazon.com/rekognition/latest/dg/add-faces-to-collection-procedure.html
  .faceCollectionId("rekognition-test-face-collection")
  .iamRoleArn("rekognition-test-IAM-role")
  .matchThreshold(0.95f)
  .build();                
            
KinesisVideoRekognitionIntegrationExample example = KinesisVideoRekognitionIntegrationExample.builder()
  .region(Regions.US_EAST_1)
  .kvsStreamName("rekognition-test-video-stream")
  .kdsStreamName("AmazonRekognition-rekognition-test-data-stream")
  .rekognitionInput(rekognitionInput)
  .credentialsProvider(new ProfileCredentialsProvider())
  // NOTE: Comment out or delete the inputStream parameter if you are streaming video, otherwise
  // the test will use a sample video. 
  //.inputStream(TestResourceUtil.getTestInputStream("bezos_vogels.mkv"))
  .build();
```

## Schritt 3: Ausführen des Beispieltests zur Integration von Kinesis-Videoströmen und Rekognition
<a name="step-3-run-kinesis-video-rekognition-example-test"></a>

 Stellen Sie sicher, dass Ihr Kinesis-Videostrom Medieneingaben empfängt, wenn Sie zu ihm streamen, und beginnen Sie mit der Analyse Ihres Streams, während ein Amazon-Rekognition-Video-Stromprozessor läuft. Weitere Informationen finden Sie unter [Überblick über den Betrieb des Amazon-Rekognition-Video-Stromprozessors](streaming-video.md#using-rekognition-video-stream-processor). Führen Sie den `KinesisVideoRekognitionIntegrationExampleTest` Kurs als Test aus. JUnit Nach einer kurzen Verzögerung öffnet sich ein neues Fenster mit einem Video-Feed aus Ihrem Kinesis-Videostrom mit Begrenzungsrahmen, die über erkannten Gesichtern gezogen werden. 

**Anmerkung**  
 Für die Gesichter in der in diesem Beispiel verwendeten Sammlung muss die externe Bild-ID (der Dateiname) in diesem Format angegeben sein, damit Begrenzungsfeldbeschriftungen aussagekräftigen Text anzeigen können: PersonName 1-Trusted, PersonName 2-Intruder, PersonName 3-Neutral usw. Die Beschriftungen können auch farblich gekennzeichnet werden und sind in der Java-Datei anpassbar. FaceType 

# Den JSON-Frame-Datensatz für Kinesis-Gesichtserkennung verstehen
<a name="streaming-video-kinesis-output-reference"></a>

Amazon Rekognition Video kann Gesichter in einem Streaming-Video erkennen. Für jedes analysierte Bild gibt Amazon Rekognition Video einen JSON-Bilddatensatz an einen Kinesis-Datenstrom aus. Amazon Rekognition Video analysiert nicht jedes Bild, das über den Kinesis-Videostrom an Amazon Rekognition Video weitergegeben wird. 

Der JSON-Frame-Datensatz enthält Informationen über den Input- und Output-Stream, den Status des Stromprozessors und Informationen über Gesichter, die im analysierten Frame erkannt wurden. Dieser Abschnitt enthält Referenzinformationen für den JSON-Frame-Datensatz.

Im Folgenden finden Sie die JSON-Syntax für einen Kinesis-Datenstromdatensatz. Weitere Informationen finden Sie unter [Arbeiten mit Streaming-Videoereignissen](streaming-video.md).

**Anmerkung**  
Die Amazon-Rekognition-Video-API vergleicht die Gesichter in Ihrem Eingabestrom mit einer Sammlung von Gesichtern und gibt die größten gefundenen Übereinstimmungen zusammen mit einem Ähnlichkeitswert zurück.

```
{
    "InputInformation": {
        "KinesisVideo": {
            "StreamArn": "string",
            "FragmentNumber": "string",
            "ProducerTimestamp": number,
            "ServerTimestamp": number,
            "FrameOffsetInSeconds": number
        }
    },
    "StreamProcessorInformation": {
        "Status": "RUNNING"
    },
    "FaceSearchResponse": [
        {
            "DetectedFace": {
                "BoundingBox": {
                    "Width": number,
                    "Top": number,
                    "Height": number,
                    "Left": number
                },
                "Confidence": number,
                "Landmarks": [
                    {
                        "Type": "string",
                        "X": number,
                        "Y": number
                    }
                ],
                "Pose": {
                    "Pitch": number,
                    "Roll": number,
                    "Yaw": number
                },
                "Quality": {
                    "Brightness": number,
                    "Sharpness": number
                }
            },
            "MatchedFaces": [
                {
                    "Similarity": number,
                    "Face": {
                        "BoundingBox": {
                            "Width": number,
                            "Top": number,
                            "Height": number,
                            "Left": number
                        },
                        "Confidence": number,
                        "ExternalImageId": "string",
                        "FaceId": "string",
                        "ImageId": "string"
                    }
                }
            ]
        }
    ]
}
```

## JSON-Datensatz
<a name="streaming-video-kinesis-output-reference-processorresult"></a>

Der JSON-Datensatz enthält Informationen über den Frame, der von Amazon Rekognition Video verarbeitet wurde. Der Datensatz enthält Informationen über das Streaming-Video, den Status des analysierten Frames und Informationen über Gesichter, die im analysierten Frame erkannt wurden.

**InputInformation**

Informationen über den Kinesis-Videostrom, der zum Streamen von Videos in Amazon Rekognition Video verwendet wird.

Typ: [InputInformation](#streaming-video-kinesis-output-reference-inputinformation) Objekt

**StreamProcessorInformation**

Informationen über den Amazon-Rekognition-Video-Stromprozessor. Dies umfasst Statusinformationen über den aktuellen Status des Stromprozessors.

Typ: [StreamProcessorInformation](streaming-video-kinesis-output-reference-streamprocessorinformation.md) Objekt 

**FaceSearchResponse**

Informationen über die erkannten Gesichter in einem Streaming-Video-Frame und die übereinstimmenden Gesichter, die in der Eingabesammlung gefunden wurden.

Typ: [FaceSearchResponse](#streaming-video-kinesis-output-reference-facesearchresponse) Objekt-Array

## InputInformation
<a name="streaming-video-kinesis-output-reference-inputinformation"></a>

Informationen über einen Quellvideostrom, der von Amazon Rekognition Video verwendet wird. Weitere Informationen finden Sie unter [Arbeiten mit Streaming-Videoereignissen](streaming-video.md).

**KinesisVideo**

Typ: [KinesisVideo](#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo) Objekt

## KinesisVideo
<a name="streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo"></a>

Informationen über den Kinesis-Videostrom, der das Quellvideo in Amazon Rekognition Video streamt. Weitere Informationen finden Sie unter [Arbeiten mit Streaming-Videoereignissen](streaming-video.md).

**StreamArn**

Der Amazon-Ressourcenname (ARN) des Kinesis-Videostroms.

Typ: Zeichenfolge 

**FragmentNumber**

Das Fragment des Streaming-Videos, das den Frame enthält, den dieser Datensatz darstellt.

Typ: Zeichenfolge

**ProducerTimestamp**

Der produzentenseitige Unix-Zeitstempel des Fragments. Weitere Informationen finden Sie unter [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Typ: Zahl

**ServerTimestamp**

Der serverseitige Unix-Zeitstempel des Fragments. Weitere Informationen finden Sie unter [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Typ: Zahl

**FrameOffsetInSeconds**

Der Versatz des Frames (in Sekunden) innerhalb des Fragments.

Typ: Zahl 

# StreamProcessorInformation
<a name="streaming-video-kinesis-output-reference-streamprocessorinformation"></a>

Statusinformationen über den Stromprozessor.

**Status**

Der aktuelle Status des Stromprozessors. Der einzig mögliche Wert ist RUNNING.

Typ: Zeichenfolge

## FaceSearchResponse
<a name="streaming-video-kinesis-output-reference-facesearchresponse"></a>

Informationen über ein erkanntes Gesicht in einem Streaming-Video-Frame und die Gesichter in einer Eingabesammlung, die mit dem erkannten Gesicht übereinstimmen. Sie geben die Sammlung in einem Aufruf von [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html) an. Weitere Informationen finden Sie unter [Arbeiten mit Streaming-Videoereignissen](streaming-video.md). 

**DetectedFace**

Gesichtsdetails zu einem in einem analysierten Video-Frame erkannten Gesicht.

Typ: [DetectedFace](#streaming-video-kinesis-output-reference-detectedface) Objekt

**MatchedFaces**

Ein Array von Gesichtsdetails für Gesichter in einer Sammlung, die mit dem in `DetectedFace` erkannten Gesicht übereinstimmen.

Typ: [MatchedFace](#streaming-video-kinesis-output-reference-facematch) Objekt-Array

## DetectedFace
<a name="streaming-video-kinesis-output-reference-detectedface"></a>

Informationen über ein Gesicht, das in einem Streaming-Video-Frame erkannt wurde. Übereinstimmende Gesichter in der Eingabesammlung stehen im [MatchedFace](#streaming-video-kinesis-output-reference-facematch)-Objektfeld zur Verfügung.

**BoundingBox**

Der Begrenzungsrahmen liefert die Koordinaten für ein Gesicht, das in einem analysierten Videobild erkannt wird. Das BoundingBox Objekt hat dieselben Eigenschaften wie das BoundingBox Objekt, das für die Bildanalyse verwendet wird.

Typ: [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html) Objekt 

**Wahrscheinlichkeit**

Das Zuverlässigkeitsniveau (1–100) von Amazon Rekognition Video, dass es sich bei dem erkannten Gesicht tatsächlich um ein Gesicht handelt. 1 ist das niedrigste Zuverlässigkeitsniveau, 100 das höchste.

Typ: Zahl

**Erkennungszeichen**

Ein Array von Gesichtsmerkmalen.

Typ: [Merkmal](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Landmark.html)-Objekt-Array

**Pose**

Gibt die Pose des Gesichts an, die durch Nicken, Neigen und Drehen bestimmt ist.

Typ: [Pose](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Pose.html)-Objekt

**Qualität**

Gibt die Helligkeit und Schärfe des Gesichtsbilds an. 

Typ: [ImageQuality](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ImageQuality.html) Objekt

## MatchedFace
<a name="streaming-video-kinesis-output-reference-facematch"></a>

Informationen über ein Gesicht, das mit einem in einem analysierten Video-Frame erkannten Gesicht übereinstimmt.

**Gesicht**

Informationen zur Gesichtsübereinstimmung für ein Gesicht in der Eingabesammlung, das mit dem Gesicht übereinstimmt, das im [DetectedFace](#streaming-video-kinesis-output-reference-detectedface)-Objekt erkannt wurde. 

Typ: [Gesichts](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Face.html)-Objekt 

**Ähnlichkeit**

Das Zuverlässigkeitsniveau (1–100), dem die Gesichter entsprechen. 1 ist das niedrigste Zuverlässigkeitsniveau, 100 das höchste.

Typ: Zahl 

# Streaming mit einem GStreamer Plugin
<a name="streaming-using-gstreamer-plugin"></a>

Amazon Rekognition Video kann ein Live-Streaming-Video von einer Gerätekamera analysieren. Um auf Medieneingaben von einer Gerätequelle zuzugreifen, müssen Sie installieren GStreamer. GStreamer ist eine Multimedia-Framework-Software eines Drittanbieters, die Medienquellen und Verarbeitungstools in Workflow-Pipelines miteinander verbindet. Sie müssen auch das [Amazon Kinesis Video Streams Producer Plug-In](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) für GStreamer installieren. Diese Operation setzt voraus, dass Sie Ihre Amazon-Rekognition-Video- und Amazon-Kinesis-Ressourcen erfolgreich eingerichtet haben. Weitere Informationen finden Sie unter [Einrichtung Ihrer Amazon-Rekognition-Video- und Amazon-Kinesis-Ressourcen](setting-up-your-amazon-rekognition-streaming-video-resources.md).

## Schritt 1: Installieren von GStreamer
<a name="step-1-install-gstreamer"></a>

 Laden Sie GStreamer, eine Multimedia-Plattform-Software eines Drittanbieters, herunter und installieren Sie es. Sie können eine Paketverwaltungssoftware wie Homebrew ([GStreamer on Homebrew](https://formulae.brew.sh/formula/gstreamer)) verwenden oder sie direkt von der [Freedesktop-Website](https://gstreamer.freedesktop.org/download/) herunterladen. 

 Überprüfen Sie die erfolgreiche Installation von GStreamer, indem Sie von Ihrem Befehlszeilenterminal aus einen Video-Feed mit einer Testquelle starten. 

```
$ gst-launch-1.0 videotestsrc ! autovideosink
```

## Schritt 2: Installieren Sie das Kinesis Video Streams Producer Plug-In
<a name="step-2-install-kinesis-video-plugin"></a>

 In diesem Abschnitt laden Sie die [Amazon Kinesis Video Streams Producer Bibliothek](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) herunter und installieren das Kinesis Video Streams GStreamer Plug-In. 

 Erstellen Sie ein Verzeichnis und klonen Sie den Quellcode aus dem GitHub-Repository. Stellen Sie sicher, dass Sie den `--recursive`-Parameter angeben. 

```
$ git clone --recursive https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git
```

Folgen Sie den [Anweisungen der Bibliothek](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/README.md), um das Projekt zu konfigurieren und zu erstellen. Stellen Sie sicher, dass Sie die plattformspezifischen Befehle für Ihr Betriebssystem verwenden. Verwenden Sie den `-DBUILD_GSTREAMER_PLUGIN=ON`-Parameter, wenn Sie `cmake` ausführen, um das Kinesis Video Streams GStreamer Plug-In zu installieren. Für dieses Projekt sind die folgenden zusätzlichen Pakete erforderlich, die in der Installation enthalten sind: GCC oder Clang, Curl, Openssl und Log4CPlus. Wenn Ihr Build aufgrund eines fehlenden Pakets fehlschlägt, überprüfen Sie, ob das Paket installiert ist und sich in Ihrem PATH befindet. Wenn Sie beim Erstellen auf den Fehler „C-kompiliertes Programm kann nicht ausgeführt werden“ stoßen, führen Sie den Build-Befehl erneut aus. Manchmal wird der richtige C-Compiler nicht gefunden. 

 Überprüfen Sie die Installation des Kinesis Video Streams Plug-Ins, indem Sie den folgenden Befehl ausführen. 

```
$ gst-inspect-1.0 kvssink
```

 Die folgenden Informationen, wie z. B. die Fabrik- und Plug-In-Details, sollten erscheinen: 

```
Factory Details:
  Rank                     primary + 10 (266)
  Long-name                KVS Sink
  Klass                    Sink/Video/Network
  Description              GStreamer AWS KVS plugin
  Author                   AWS KVS <kinesis-video-support@amazon.com>
                
Plugin Details:
  Name                     kvssink
  Description              GStreamer AWS KVS plugin
  Filename                 /Users/YOUR_USER/amazon-kinesis-video-streams-producer-sdk-cpp/build/libgstkvssink.so
  Version                  1.0
  License                  Proprietary
  Source module            kvssinkpackage
  Binary package           GStreamer
  Origin URL               http://gstreamer.net/
  
  ...
```

## Schritt 3: GStreamer mit dem Kinesis Video Streams Plug-In ausführen
<a name="step-3-run-gstreamer-with-kinesis-video-plugin"></a>

 Bevor Sie mit dem Streaming von einer Gerätekamera zu Kinesis Video Streams beginnen, müssen Sie möglicherweise die Medienquelle in einen akzeptablen Codec für Kinesis Video Streams konvertieren. Um die Spezifikationen und Formatfunktionen der Geräte zu ermitteln, die derzeit an Ihr Gerät angeschlossen sind, führen Sie den folgenden Befehl aus.

```
$ gst-device-monitor-1.0
```

 Um mit dem Streaming zu beginnen, starten Sie GStreamer mit dem folgenden Beispielbefehl und fügen Sie Ihre Anmeldeinformationen und Amazon-Kinesis-Video-Streams-Informationen hinzu. Sie sollten die Zugriffsschlüssel und die Region für die IAM-Servicerolle verwenden, die Sie erstellt haben, während Sie [Amazon Rekognition Zugriff auf Ihre Kinesis-Streams gewähren](https://docs.aws.amazon.com/rekognition/latest/dg/api-streaming-video-roles.html#api-streaming-video-roles-all-stream). Weitere Information über IAM-Zugriffsschlüssel finden Sie unter [Verwalten von Zugriffsschlüsseln für IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) im *IAM-Benutzerhandbuch*. Außerdem können Sie die Parameter für das Videoformat so anpassen, wie es Ihre Nutzung erfordert und auf Ihrem Gerät verfügbar ist. 

```
$ gst-launch-1.0 autovideosrc device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=640,height=480,framerate=30/1 ! 
                x264enc bframes=0 key-int-max=45 bitrate=500 ! video/x-h264,stream-format=avc,alignment=au,profile=baseline ! 
                kvssink stream-name="YOUR_STREAM_NAME" storage-size=512 access-key="YOUR_ACCESS_KEY" secret-key="YOUR_SECRET_ACCESS_KEY" aws-region="YOUR_AWS_REGION"
```

 Weitere Startbefehle finden Sie unter [Beispiel für GStreamer Startbefehle](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-gstreamer-plugin.html#examples-gstreamer-plugin-launch). 

**Anmerkung**  
 Wenn Ihr Startbefehl mit einem Fehler endet, bei dem es sich nicht um eine Verhandlung handelt, überprüfen Sie die Ausgabe des Gerätemonitors und stellen Sie sicher, dass es sich bei den `videoconvert`-Parameterwerten um gültige Funktionen Ihres Geräts handelt. 

 Nach einigen Sekunden wird in Ihrem Kinesis-Videostrom ein Video-Feed von Ihrer Gerätekamera angezeigt. Um mit der Erkennung und Zuordnung von Gesichtern mit Amazon Rekognition zu beginnen, starten Sie Ihren Amazon-Rekognition-Video-Stromprozessor. Weitere Informationen finden Sie unter [Überblick über den Betrieb des Amazon-Rekognition-Video-Stromprozessors](streaming-video.md#using-rekognition-video-stream-processor). 

# Fehlerbehebung beim Streamen von Videos
<a name="streaming-video-troubleshooting"></a>

Dieses Thema enthält Informationen zur Fehlerbehebung beim Streamen von Videos mit Amazon Rekognition Video.

**Topics**
+ [Ich weiß nicht, ob mein Stromprozessor erfolgreich erstellt wurde](#ts-streaming-video-create-sp)
+ [Ich weiß nicht, ob mein Stromprozessor korrekt konfiguriert ist](#ts-configured-sp)
+ [Mein Stromprozessor gibt keine Ergebnisse zurück](#ts-streaming-video-no-results-from-sp)
+ [Der Status meines Stromprozessors lautet FAILED](#ts-failed-state)
+ [Mein Stromprozessor gibt nicht die erwarteten Ergebnisse zurück](#w2aac27c79c27c15)

## Ich weiß nicht, ob mein Stromprozessor erfolgreich erstellt wurde
<a name="ts-streaming-video-create-sp"></a>

Verwenden Sie den folgenden AWS CLI Befehl, um eine Liste der Stream-Prozessoren und deren aktuellen Status abzurufen.

```
aws rekognition list-stream-processors
```

Mit dem folgenden AWS CLI Befehl können Sie weitere Details abrufen. Ersetzen Sie `stream-processor-name` durch den Namen des erforderlichen Stromprozessors.

```
aws rekognition describe-stream-processor --name stream-processor-name
```

## Ich weiß nicht, ob mein Stromprozessor korrekt konfiguriert ist
<a name="ts-configured-sp"></a>

Wenn Ihr Code nicht die Analyseergebnisse von Amazon Rekognition Video ausgibt, ist Ihr Stromprozessor möglicherweise nicht korrekt konfiguriert. Führen Sie die folgenden Schritte aus, um zu bestätigen, dass Ihr Stromprozessor korrekt konfiguriert ist und Ergebnisse herstellen kann.

**So stellen Sie fest, ob Ihre Lösung ordnungsgemäß konfiguriert ist**

1. Führen Sie den folgenden Befehl aus, um zu bestätigen, dass Ihr Stromprozessor ausgeführt wird. Ändern Sie `stream-processor-name` in den Namen Ihres Stromprozessors. Der Stromprozessor wird ausgeführt, wenn `Status` den Wert `RUNNING` aufweist. Wenn der Status `RUNNING` lautet und Sie keine Ergebnisse erhalten, siehe [Mein Stromprozessor gibt keine Ergebnisse zurück](#ts-streaming-video-no-results-from-sp). Wenn der Status `FAILED` lautet, finden Sie unter [Der Status meines Stromprozessors lautet FAILED](#ts-failed-state) Informationen dazu.

   ```
   aws rekognition describe-stream-processor --name stream-processor-name
   ```

1. Wenn Ihr Stream-Prozessor läuft, führen Sie die folgende Bash oder den folgenden PowerShell Befehl aus, um Daten aus dem Kinesis-Ausgabedatenstream zu lesen. 

   **Bash**

   ```
   SHARD_ITERATOR=$(aws kinesis get-shard-iterator --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON --stream-name kinesis-data-stream-name --query 'ShardIterator')
                           aws kinesis get-records --shard-iterator $SHARD_ITERATOR
   ```

   **PowerShell**

   ```
   aws kinesis get-records --shard-iterator ((aws kinesis get-shard-iterator --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON --stream-name kinesis-data-stream-name).split('"')[4])
   ```

1. Mit dem [Decodierungstool](https://www.base64decode.org/) auf der Website „Base64 Decode“ können Sie die Ausgabe in eine für Menschen lesbare Zeichenfolge decodieren. Weitere Informationen finden Sie unter [Schritt 3: Rufen Sie den Datensatz ab](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#get-records).

1. Wenn die Befehle funktionieren und im Kinesis-Datenstrom Ergebnisse der Gesichtserkennung angezeigt werden, ist Ihre Lösung ordnungsgemäß konfiguriert. Bei einem Befehlsfehler prüfen Sie die anderen Vorschläge zur Problembehandlung und sehen Sie sich die Informationen unter [Gewähren von Zugriff auf Ihre Ressourcen für Amazon Rekognition Video](api-streaming-video-roles.md)an.

Alternativ können Sie den AWS Lambda Blueprint "kinesis-process-record" verwenden, um Nachrichten aus dem Kinesis-Datenstrom CloudWatch zur kontinuierlichen Visualisierung zu protokollieren. Dadurch entstehen zusätzliche Kosten für und. AWS Lambda CloudWatch 

## Mein Stromprozessor gibt keine Ergebnisse zurück
<a name="ts-streaming-video-no-results-from-sp"></a>

Ihr Stromprozessor gibt möglicherweise aus verschiedenen Gründen keine Ergebnisse zurück. 

### Grund 1: Der Stromprozessor ist nicht korrekt konfiguriert
<a name="w2aac27c79c27c11b5"></a>

Ihr Stromprozessor ist möglicherweise nicht korrekt konfiguriert. Weitere Informationen finden Sie unter [Ich weiß nicht, ob mein Stromprozessor korrekt konfiguriert ist](#ts-configured-sp).

### Grund 2: Ihr Stromprozessor weist nicht den Status RUNNING auf
<a name="w2aac27c79c27c11b7"></a>

**So beheben Sie Statusfehler des Stromprozessors**

1. Überprüfen Sie den Status des Stream-Prozessors mit dem folgenden AWS CLI Befehl.

   ```
   aws rekognition describe-stream-processor --name stream-processor-name
   ```

1. Wenn `Status` den Wert `STOPPED`aufweist, starten Sie Ihren Stromprozessor mit dem folgenden Befehl:

   ```
   aws rekognition start-stream-processor --name stream-processor-name
   ```

1. Wenn `Status` den Wert `FAILED` aufweist, finden Sie weitere Informationen unter [Der Status meines Stromprozessors lautet FAILED](#ts-failed-state).

1. Wenn `Status` den Wert `STARTING` aufweist, warten Sie 2 Minuten und überprüfen Sie den Status, indem Sie Schritt 1 wiederholen. Wenn der Status noch den Wert `STARTING` aufweist, gehen Sie wie folgt vor:

   1. Löschen Sie den Stromprozessor mit dem folgenden Befehl.

      ```
      aws rekognition delete-stream-processor --name stream-processor-name
      ```

   1. Erstellen Sie einen neuen Stromprozessor mit der gleichen Konfiguration. Weitere Informationen finden Sie unter [Arbeiten mit Streaming-Videoereignissen](streaming-video.md).

   1. Wenn Sie weiterhin Probleme haben, wenden Sie sich an den AWS Support.

1. Wenn `Status` den Wert `RUNNING` aufweist, finden Sie weitere Informationen unter [Grund 3: Es sind keine aktiven Daten im Kinesis-Videostrom vorhanden](#ts-no-data).

### Grund 3: Es sind keine aktiven Daten im Kinesis-Videostrom vorhanden
<a name="ts-no-data"></a>

**Um zu überprüfen, ob der Kinesis-Videostrom aktive Daten enthält**

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Kinesis Video Streams Streams-Konsole unter [https://console.aws.amazon.com/kinesisvideo/](https://console.aws.amazon.com/kinesisvideo/).

1. Wählen Sie den Kinesis-Videostrom aus, der die Eingabe für den Amazon-Rekognition-Stromprozessor ist.

1. Wenn die Vorschau **Keine Daten im Strom** angibt, befinden sich keine Daten zur Verarbeitung durch Amazon Rekognition Video im Eingabestrom.

Informationen zur Videoproduktion mit Kinesis Video Streams finden Sie unter [Kinesis Video Streams Producer Libraries](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk.html). 

## Der Status meines Stromprozessors lautet FAILED
<a name="ts-failed-state"></a>

Sie können den Status eines Stream-Prozessors mit dem folgenden AWS CLI Befehl überprüfen.

```
aws rekognition describe-stream-processor --name stream-processor-name
```

Wenn der Status den Wert FAILED aufweist, überprüfen Sie die Informationen zur Fehlerbehebung für die folgenden Fehlermeldungen.

### Fehler: „Der Rolle wird der Zugriff verweigert“
<a name="w2aac27c79c27c13b9"></a>

Die vom Stromprozessor verwendete IAM-Rolle ist nicht vorhanden oder Amazon Rekognition Video verfügt nicht über die Berechtigung, die Rolle anzunehmen.

**So beheben Sie Probleme mit dem Zugriff auf die IAM-Rolle**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Klicken Sie im linken Navigationsbereich auf **Rollen** und bestätigen Sie, dass die Rolle vorhanden ist. 

1. Wenn die Rolle vorhanden ist, überprüfen Sie, ob für die Rolle die *AmazonRekognitionServiceRole*Berechtigungsrichtlinie gilt.

1. Wenn die Rolle nicht vorhanden ist oder nicht über die erforderlichen Berechtigungen verfügt, siehe [Gewähren von Zugriff auf Ihre Ressourcen für Amazon Rekognition Video](api-streaming-video-roles.md).

1. Starten Sie den Stream-Prozessor mit dem folgenden AWS CLI Befehl.

   ```
   aws rekognition start-stream-processor --name stream-processor-name
   ```

### Fehler: „Kein Zugriff auf Kinesis Video *oder* Zugriff auf Kinesis-Daten verweigert“
<a name="w2aac27c79c27c13c11"></a>

Die Rolle hat keinen Zugriff auf die Kinesis-Video-Streams-API-Operationen `GetMedia` und `GetDataEndpoint`. Möglicherweise hat es auch keinen Zugriff auf die Kinesis-Data-Streams-API-Operationen `PutRecord` und `PutRecords`. 

**So beheben Sie Probleme mit API-Berechtigungen**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Öffnen Sie die Rolle und stellen Sie sicher, dass die folgende Berechtigungsrichtlinie angefügt ist.

1. Wenn eine der Berechtigungen fehlt, aktualisieren Sie die Richtlinie. Weitere Informationen finden Sie unter [Gewähren von Zugriff auf Ihre Ressourcen für Amazon Rekognition Video](api-streaming-video-roles.md).

### Fehler: „Stream *input-video-stream-name* existiert nicht“
<a name="w2aac27c79c27c13c13"></a>

Die Kinesis–Videostrom-Eingabedaten für den Stromprozessor sind nicht vorhanden oder nicht korrekt konfiguriert. 

**So beheben Sie Probleme mit dem Kinesis-Videostrom**

1. Mit dem folgenden Befehl können Sie bestätigen, dass der Stream vorhanden ist. 

   ```
   aws kinesisvideo list-streams
   ```

1. Wenn der Stream vorhanden ist, überprüfen Sie Folgendes.
   + Der Amazon-Ressourcenname (ARN) ist identisch mit dem ARN des Eingabestroms für den Stromprozessor.
   + Der Kinesis-Videostrom befindet sich in derselben Region wie der Stromprozessor.

   Wenn der Stream-Prozessor nicht korrekt konfiguriert ist, löschen Sie ihn mit dem folgenden AWS CLI Befehl.

   ```
   aws rekognition delete-stream-processor --name stream-processor-name
   ```

1. Erstellen Sie einen neuen Stromprozessor mit dem beabsichtigten Kinesis Video Stream. Weitere Informationen finden Sie unter [Erstellen des Amazon-Rekognition-Video-Gesichtssuche-Stromprozessors](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor).

### Fehler: „Sammlung nicht gefunden“
<a name="w2aac27c79c27c13c15"></a>

Die vom Stromprozessor für die Gesichtsprüfung verwendete Amazon-Rekognition-Sammlung ist nicht vorhanden, oder die falsche Sammlung wird verwendet.

**So bestätigen Sie die Sammlung**

1. Verwenden Sie den folgenden AWS CLI Befehl, um festzustellen, ob die erforderliche Sammlung vorhanden ist. Wechseln Sie `region` zu der AWS Region, in der Sie Ihren Stream-Prozessor ausführen.

   ```
   aws rekognition list-collections --region region
   ```

   Wenn die erforderliche Sammlung nicht vorhanden ist, erstellen Sie eine neue Sammlung und fügen Sie Gesichtsinformationen hinzu. Weitere Informationen finden Sie unter [Gesichtssuche in einer Sammlung](collections.md).

1. Überprüfen Sie in Ihrem [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)-Aufruf, dass der Wert des `CollectionId`-Eingabeparameters korrekt ist.

1. Starten Sie den Stream-Prozessor mit dem folgenden AWS CLI Befehl.

   ```
   aws rekognition start-stream-processor --name stream-processor-name
   ```

### Fehler: „Stream *output-kinesis-data-stream-name* unter Konto *account-id* nicht gefunden“
<a name="w2aac27c79c27c13c17"></a>

Der Kinesis-Ausgabedatenstream, der vom Stream-Prozessor verwendet wird, ist in Ihrer Region nicht vorhanden AWS-Konto oder befindet sich nicht in derselben AWS Region wie Ihr Stream-Prozessor.

**So beheben Sie Probleme mit dem Kinesis-Datenstrom**

1. Verwenden Sie den folgenden AWS CLI Befehl, um festzustellen, ob der Kinesis-Datenstrom vorhanden ist. Wechseln Sie `region` zu der AWS Region, in der Sie Ihren Stream-Prozessor verwenden.

   ```
   aws kinesis list-streams --region region
   ```

1. Wenn der Kinesis-Datenstrom vorhanden ist, überprüfen Sie, ob der Name des Kinesis-Datenstroms dem des Ausgabestroms entspricht, der vom Stromprozessor verwendet wird.

1. Wenn der Kinesis-Datenstream nicht existiert, ist er möglicherweise in einer anderen AWS Region vorhanden. Der Kinesis-Datenstrom muss sich in derselben Region wie der Stromprozessor befinden.

1. Erstellen Sie bei Bedarf einen neuen Kinesis-Datenstrom. 

   1. Erstellen Sie einen Kinesis-Datenstrom mit demselben Namen wie dem des Stromprozessors. Weitere Informationen finden Sie unter [Schritt 1: Erstellen eines Datenstroms](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html).

   1. Starten Sie den Stream-Prozessor mit dem folgenden AWS CLI Befehl.

      ```
      aws rekognition start-stream-processor --name stream-processor-name
      ```

## Mein Stromprozessor gibt nicht die erwarteten Ergebnisse zurück
<a name="w2aac27c79c27c15"></a>

Wenn Ihr Stromprozessor nicht die erwarteten Gesichtstreffer zurückgibt, verwenden Sie die folgenden Informationen.
+ [Gesichtssuche in einer Sammlung](collections.md)
+ [Empfehlungen für die Kameraeinrichtung (Videostreaming)](recommendations-camera-streaming-video.md)