

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.

# Erste Schritte mit Amazon Transcribe
<a name="getting-started"></a>

Bevor Sie Transkriptionen erstellen können, müssen Sie einige Voraussetzungen erfüllen:
+ [Registrieren Sie sich für ein AWS-Konto](#getting-started-sign-up)
+ [Installieren Sie das AWS CLI und SDKs](#getting-started-api) (wenn Sie das AWS-Managementkonsole für Ihre Transkriptionen verwenden, können Sie diesen Schritt überspringen)
+ [Konfigurieren von IAM -Anmeldeinformationen](#getting-started-iam)
+ [Einen Amazon S3 -Bucket einrichten](#getting-started-s3)
+ [Eine IAM -Richtlinie erstellen](#getting-started-policy)

Sobald Sie diese Voraussetzungen erfüllt haben, sind Sie bereit für die Transkription. Wählen Sie Ihre bevorzugte Transkriptionsmethode aus der folgenden Liste aus, um zu beginnen.
+ [AWS CLI](getting-started-cli.md)
+ [AWS-Managementkonsole](getting-started-console.md)
+ [AWS SDK](getting-started-sdk.md)
+ [HTTP](getting-started-http-websocket.md)
+ [WebSockets](getting-started-http-websocket.md)

**Tipp**  
Wenn Sie mit unseren Funktionen noch nicht vertraut sind Amazon Transcribe oder diese erkunden möchten, empfehlen wir die Verwendung von [AWS-Managementkonsole](https://console.aws.amazon.com/transcribe). Dies ist auch die einfachste Option, wenn Sie einen Stream über das Mikrofon Ihres Computers starten möchten.

Da das Streamen mit HTTP/2 komplizierter WebSockets ist als die anderen Transkriptionsmethoden, empfehlen wir, diesen [Einrichten einer Streaming-Transkription](streaming-setting-up.md) Abschnitt zu lesen, bevor Sie mit diesen Methoden beginnen. **Beachten Sie, dass wir dringend empfehlen, ein SDK für Streaming-Transkriptionen zu verwenden.**

## Melden Sie sich an für ein AWS-Konto
<a name="getting-started-sign-up"></a>

Sie können sich für ein [kostenloses](https://aws.amazon.com/free/) Konto oder ein [kostenpflichtiges Konto](https://portal.aws.amazon.com/gp/aws/developer/registration/index.html) registrieren. Mit beiden Optionen haben Sie Zugriff auf alle AWS-Services. Das kostenlose Kontingent umfasst eine Testphase, in der Sie Ihre Nutzung erkunden AWS-Services und einschätzen können. Nach Ablauf des Testzeitraums können Sie auf ein kostenpflichtiges Konto umsteigen. Gebühren fallen auf einer bestimmten pay-as-you-use Grundlage an. Einzelheiten finden Sie unter [Amazon Transcribe Preise](https://aws.amazon.com/transcribe/pricing/).

**Tipp**  
Notieren Sie sich bei der Einrichtung Ihres Kontos Ihre AWS-Konto ID, da Sie sie zum Erstellen IAM von Entitäten benötigen.

## Installation von AWS CLI und SDKs
<a name="getting-started-api"></a>

Um die Amazon Transcribe API verwenden zu können, müssen Sie zuerst die installieren AWS CLI. Die aktuelle AWS CLI ist Version 2. Installationsanweisungen für [Linux](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2-linux.html), [Mac](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2-mac.html), [Windows](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2-windows.html) und [Docker](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2-docker.html) finden Sie im [https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html). 

Sobald Sie das AWS CLI installiert haben, müssen Sie es für Ihre Sicherheitsanmeldedaten [konfigurieren](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) und AWS-Region.

Wenn Sie es Amazon Transcribe mit einem SDK verwenden möchten, wählen Sie Ihre bevorzugte Sprache für die Installationsanweisungen aus:
+ [.NET](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/quick-start.html)
+ [C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html)
+ [Go](https://aws.github.io/aws-sdk-go-v2/docs/)
+ [Java V2](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html)
+ [JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started.html)
+ [PHP V3](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/getting-started_installation.html)
+ [AWS SDK für Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) (Batch-Transkriptionen)
+ [Python](https://github.com/awslabs/amazon-transcribe-streaming-sdk) (Streaming-Transkriptionen)
+ [Rubin V3](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-install.html)
+ [Rust](https://crates.io/crates/aws-sdk-transcribe) (Batch-Transkriptionen)
+ [Rust](https://crates.io/crates/aws-sdk-transcribestreaming) (Streaming-Transkriptionen)

## IAM Anmeldeinformationen konfigurieren
<a name="getting-started-iam"></a>

Wenn Sie eine erstellen AWS-Konto, beginnen Sie mit einer Anmeldeidentität, die vollständigen Zugriff auf alle AWS Dienste und Ressourcen in Ihrem Konto hat. Diese Identität wird als AWS-Konto Root-Benutzer bezeichnet. Sie können darauf zugreifen, indem Sie sich mit der E-Mail-Adresse und dem Passwort anmelden, mit denen Sie das Konto erstellt haben.

Wir raten ausdrücklich davon ab, den Root-Benutzer für Alltagsaufgaben zu verwenden, auch nicht für administrative Aufgaben. Schützen Sie Ihre Root-Benutzer-Anmeldeinformationen und verwenden Sie diese, um die Aufgaben auszuführen, die nur der Root-Benutzer ausführen kann.

Es hat sich bewährt, dass Benutzer — auch solche, die Administratorzugriff benötigen — den Verbund mit einem Identitätsanbieter verwenden müssen, um mithilfe temporärer Anmeldeinformationen auf AWS Dienste zuzugreifen.

Eine föderierte Identität ist jeder Benutzer, der mithilfe von Anmeldeinformationen, die über eine Identitätsquelle bereitgestellt wurden, auf AWS Dienste zugreift. Wenn Verbundidentitäten auf AWS-Konten zugreifen, übernehmen sie Rollen und die Rollen stellen temporäre Anmeldeinformationen bereit.

Für die zentrale Zugriffsverwaltung empfehlen wir Ihnen, [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) zu verwenden. Sie können Benutzer und Gruppen in IAM Identity Center erstellen. Oder Sie können eine Verbindung zu einer Gruppe von Benutzern und Gruppen in Ihrer eigenen Identitätsquelle herstellen und diese synchronisieren, um sie in all Ihren Anwendungen zu AWS-Konten verwenden. Weitere Informationen finden Sie unter [Identity and Access Management für Amazon Transcribe](security-iam.md).

Weitere Informationen zu IAM bewährten Methoden finden Sie unter [Bewährte Sicherheitsmethoden unter IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html).

## Einen Amazon S3 Bucket erstellen
<a name="getting-started-s3"></a>

Amazon S3 ist ein sicherer Objektspeicherdienst. Amazon S3 speichert Ihre Dateien (*Objekte* genannt) in Containern (sogenannten *Buckets*).

Um eine Batch-Transkription auszuführen, müssen Sie zuerst Ihre Mediendateien in einen Amazon S3 Bucket hochladen. Wenn Sie keinen Amazon S3 Bucket für Ihre Transkriptionsausgabe angeben, wird Ihr Transkript in einem temporären AWS, Amazon Transcribe verwalteten Bucket gespeichert. Amazon S3 Die Transkriptionsausgabe in AWS-verwalteten Buckets wird nach 90 Tagen automatisch gelöscht.

Erfahren Sie, wie Sie [Ihren ersten S3-Bucket erstellen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) und [Ein Objekt in Ihren Bucket hochladen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html).

## Eine Richtlinie erstellen IAM
<a name="getting-started-policy"></a>

Um den Zugriff zu verwalten AWS, müssen Sie Richtlinien erstellen und diese an IAM Identitäten (Benutzer, Gruppen oder Rollen) oder AWS Ressourcen anhängen. Eine Richtlinie definiert die Berechtigungen der Entität, der sie zugeordnet ist. Beispielsweise kann eine Rolle nur dann auf eine Mediendatei zugreifen, die sich in Ihrem Amazon S3 Bucket befindet, wenn Sie dieser Rolle eine Richtlinie angehängt haben, die ihr Zugriff gewährt. Wenn Sie diese Rolle weiter einschränken möchten, können Sie stattdessen ihren Zugriff auf eine bestimmte Datei innerhalb eines Amazon S3 Buckets einschränken.

Weitere Informationen zur Verwendung von AWS Richtlinien finden Sie unter:
+ [Richtlinien und Berechtigungen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html)
+ [Erstellen von IAM -Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html)
+ [Wie Amazon Transcribe funktioniert mit IAM](security_iam_service-with-iam.md)

Richtlinien, die Sie zusammen verwenden können Amazon Transcribe, finden Sie beispielsweise unter[Amazon Transcribe Beispiele für identitätsbasierte Politik](security_iam_id-based-policy-examples.md). Wenn Sie benutzerdefinierte Richtlinien erstellen möchten, sollten Sie den [AWS -Richtlinien-Generator](https://awspolicygen.s3.amazonaws.com/policygen.html) verwenden.

Sie können eine Richtlinie mithilfe des AWS SDK AWS-Managementkonsole AWS CLI, oder hinzufügen. Anweisungen finden Sie unter [Hinzufügen und Entfernen von IAM Identitätsberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policy-api).

Richtlinien haben das Format:

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "my-policy-name",
            "Effect": "Allow",
            "Action": [
                "service:action"
            ],
            "Resource": [
                "amazon-resource-name"
            ]
        }
    ]
}
```

------

Amazon-Ressourcennamen (ARNs) identifizieren eindeutig alle AWS Ressourcen, z. B. einen Amazon S3 Bucket. Sie können dies ARNs in Ihrer Richtlinie verwenden, um Berechtigungen für bestimmte Aktionen zur Nutzung bestimmter Ressourcen zu erteilen. Wenn Sie beispielsweise Lesezugriff auf einen Amazon S3 Bucket und seine Unterordner gewähren möchten, können Sie dem `Statement` Abschnitt Ihrer Vertrauensrichtlinie den folgenden Code hinzufügen:

```
{
        "Effect": "Allow",
        "Action": [
            "s3:GetObject",
            "s3:ListBucket"
        ],
        "Resource": [
            "arn:aws:s3:::amzn-s3-demo-bucket",
            "arn:aws:s3:::amzn-s3-demo-bucket/*"
        ]
}
```

Im Folgenden finden Sie eine Beispielrichtlinie, die einem Amazon S3 Bucket und seinen Unterordnern Amazon Transcribe Lese- (`PutObject`) und Schreibrechte () gewährt: `GetObject` `ListBucket` `amzn-s3-demo-bucket`

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket",
                "arn:aws:s3:::amzn-s3-demo-bucket/*"
            ]
        },
        {
             "Effect": "Allow",
             "Action": [
                 "s3:PutObject"
             ],
             "Resource": [
                 "arn:aws:s3:::amzn-s3-demo-bucket",
                 "arn:aws:s3:::amzn-s3-demo-bucket/*"
             ]
        }
  ]
}
```

------

# Transkribieren mit dem AWS-Managementkonsole
<a name="getting-started-console"></a>

Sie können die AWS Konsole für Batch- und Streaming-Transkriptionen verwenden. Wenn Sie eine Mediendatei transkribieren, die sich in einem Amazon S3 Bucket befindet, führen Sie eine Batch-Transkription durch. Wenn Sie einen Echtzeitstream von Audiodaten transkribieren, führen Sie eine Streaming-Transkription durch.

Bevor Sie eine Batch-Transkription starten, müssen Sie zuerst Ihre Mediendatei in einen Bucket hochladen. Amazon S3 Für Streaming-Transkriptionen mit dem AWS-Managementkonsole müssen Sie Ihr Computermikrofon verwenden.

Informationen zu unterstützten Medienformaten und anderen Medienanforderungen und -beschränkungen finden Sie unter [Dateneingabe und -ausgabe](how-input.md).

In den folgenden Abschnitten finden Sie kurze Erläuterungen zu den einzelnen Transkriptionsmethoden.

# Batch-Transkriptionen
<a name="getting-started-console-batch"></a>

Stellen Sie zunächst sicher, dass Sie die Mediendatei, die Sie transkribieren möchten, in einen Amazon S3 -Bucket hochgeladen haben. Wenn Sie sich nicht sicher sind, wie das geht, lesen Sie das *Amazon S3 -Benutzerhandbuch*: [Hochladen eines Objekts in Ihren Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html).

1. Wählen Sie im [AWS-Managementkonsole](https://console.aws.amazon.com/transcribe) im linken Navigationsbereich **Transkriptionsaufträge**. Dies führt Sie zu einer Liste Ihrer Transkriptionsaufträge.  
![\[Amazon Transcribe Konsolen-Screenshot: Die Seite „Transkriptionsjobs“.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-batch-1.png)

   Wählen Sie **Auftrag erstellen**.

1. Füllen Sie die Felder auf der Seite **Auftragsdetails angeben** aus.  
![\[Amazon Transcribe Konsolen-Screenshot: Die Seite „Auftragsdetails angeben“.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-batch-job-details-1.png)

   Der Eingabeort *muss* ein Objekt in einem Amazon S3 Bucket sein. Als Ausgabespeicherort können Sie einen sicheren, vom Amazon S3 Service verwalteten Bucket wählen oder Sie können Ihren eigenen Amazon S3 Bucket angeben.

   Wenn Sie sich für einen serviceverwalteten Bucket entscheiden, können Sie eine Transkriptvorschau in der AWS-Managementkonsole anzeigen und Ihre Transkription von der Auftragsdetailseite herunterladen (siehe unten).

   Wenn Sie Ihren eigenen Amazon S3 Bucket wählen, wird im Bucket keine Vorschau angezeigt AWS-Managementkonsole und Sie müssen zum Amazon S3 Bucket gehen, um Ihr Transkript herunterzuladen.  
![\[Amazon Transcribe Konsolen-Screenshot: Die Eingabe- und Ausgabedatenbereiche für eine Batch-Transkription.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-batch-job-details-2.png)

   Klicken Sie auf **Weiter**.

1. Wählen Sie auf der Seite **Auftrag konfigurieren** die gewünschten Optionen aus. Wenn Sie [Benutzerdefinierte Vokabulare](custom-vocabulary.md) oder [Benutzerdefinierte Sprachmodelle](custom-language-models.md) für Ihre Transkription verwenden möchten, müssen Sie diese vor Beginn Ihres Transkriptionsauftrags erstellen.  
![\[Amazon Transcribe Konsolen-Screenshot: Die Seite „Job konfigurieren“.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-batch-configure-job.png)

   Wählen Sie **Auftrag erstellen**.

1. Sie befinden sich jetzt auf der Seite für **Transkriptionsaufträge**. Hier können Sie den Status des Transkriptionsauftrags sehen. Wählen Sie anschließend Ihre Transkription aus.  
![\[Amazon Transcribe Bildschirmfoto der Konsole: Die Seite mit der Zusammenfassung der Transkriptionsaufträge.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-batch-transcription-jobs.png)

1. Sie befinden sich jetzt auf der Seite mit den **Auftragsdetails** für Ihre Transkription. Hier können Sie alle Optionen einsehen, die Sie bei der Einrichtung Ihres Transkriptionsauftrags angegeben haben.

   Um Ihr Transkript anzuzeigen, wählen Sie den verlinkten Dateipfad in der rechten Spalte unter **Speicherort der Ausgabedaten**. Dadurch gelangen Sie zu dem von Ihnen angegebenen Amazon S3 Ausgabeordner. Wählen Sie Ihre Ausgabedatei aus, die jetzt die Erweiterung .json hat.  
![\[Amazon Transcribe Konsolen-Screenshot: Übersichtsseite für die abgeschlossene Transkription.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-batch-complete.png)

1. Wie Sie Ihr Transkript herunterladen, hängt davon ab, ob Sie einen vom Service verwalteten Amazon S3 Bucket oder Ihren eigenen Bucket ausgewählt haben. Amazon S3 

   1. Wenn Sie sich für einen serviceverwalteten Bucket entschieden haben, sehen Sie auf der Informationsseite Ihres Transkriptionsauftrags ein **Transkriptionsvorschaufenster** und eine Schaltfläche zum **Herunterladen**.  
![\[Amazon Transcribe Konsolen-Screenshot: Übersichtsseite für die Transkription in einem vom Service verwalteten Bucket.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-batch-output-service-s3.png)

      Wählen Sie **Herunterladen** und wählen Sie **Transkript herunterladen**.

   1. Wenn Sie Ihren eigenen Amazon S3 Bucket ausgewählt haben, wird im Bereich der **Transkriptionsvorschau auf der Informationsseite Ihres Transkriptionsauftrags** kein Text angezeigt. Stattdessen sehen Sie ein blaues Informationsfeld mit einem Link zu dem von Ihnen ausgewählten Amazon S3 Bucket.  
![\[Amazon Transcribe Konsolen-Screenshot: Übersichtsseite für die Transkription in einem selbstverwalteten Bucket.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-batch-output-own-s3.png)

      Um auf Ihr Transkript zuzugreifen, gehen Sie über den Link unter **Speicherort der Ausgabedaten** im Bereich **Jobdetails** oder über den Link **S3-Bucket** im blauen Informationsfeld im Bereich **Transkriptionsvorschau** zum angegebenen Amazon S3 Bucket.

# Streaming-Transkriptionen
<a name="getting-started-console-stream"></a>

1. Wählen Sie unter [AWS-Managementkonsole](https://console.aws.amazon.com/transcribe) im linken Navigationsbereich die Option **Echtzeittranskription**. Dadurch gelangen Sie auf die Hauptseite für das Streaming, auf der Sie Optionen auswählen können, bevor Sie Ihren Stream starten.  
![\[Amazon Transcribe Konsolen-Screenshot: Die Seite „Echtzeit-Transkription“.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-stream-1.png)

1. Unterhalb des Feldes **Transkriptionsausgabe** haben Sie die Möglichkeit, verschiedene Sprach- und Audioeinstellungen zu wählen.  
![\[Amazon Transcribe Konsolen-Screenshot: eine Liste der verfügbaren Transkriptionseinstellungen.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-stream-settings.png)

1. Nachdem Sie die entsprechenden Einstellungen ausgewählt haben, blättern Sie zum oberen Rand der Seite, wählen Sie **Streaming starten** und beginnen Sie, in das Mikrofon Ihres Computers zu sprechen. Sie können sehen, wie Ihre Rede in Echtzeit transkribiert wird.  
![\[Amazon Transcribe Konsolen-Screenshot: Der Bereich „Transkription“ auf der Seite „Transkription in Echtzeit“.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-stream-start.png)

1. Wenn Sie fertig sind, wählen Sie **Streaming beenden**.  
![\[Amazon Transcribe Konsolen-Screenshot: Beispielvorschau für eine Echtzeit-Transkription.\]](http://docs.aws.amazon.com/de_de/transcribe/latest/dg/images/console-stream-stop.png)

   Sie können nun Ihr Zeugnis herunterladen, indem Sie **Vollständige Transkription herunterladen**wählen.

# Transkribieren mit dem AWS CLI
<a name="getting-started-cli"></a>

Wenn Sie den verwenden AWS CLI , um eine Transkription zu starten, können Sie alle Befehle auf CLI-Ebene ausführen. Oder Sie führen den gewünschten Befehl aus, gefolgt von AWS-Region und dem Speicherort einer JSON-Datei, die einen Anforderungstext enthält. In diesem Leitfaden werden beide Methoden anhand von Beispielen dargestellt; dieser Abschnitt konzentriert sich jedoch auf die erste Methode.

Das unterstützt AWS CLI keine Streaming-Transkriptionen.

Bevor Sie fortfahren, vergewissern Sie sich, dass Sie Folgendes getan haben:
+ Sie haben Ihre Mediendatei in einen Amazon S3 Bucket hochgeladen. Wenn Sie sich nicht sicher sind, wie Sie einen Amazon S3 Bucket erstellen oder Ihre Datei hochladen, finden Sie weitere Informationen unter [Erstellen Sie Ihren ersten Amazon S3 Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) und [Laden Sie ein Objekt in Ihren Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) hoch.
+ Installiert die [AWS CLI](getting-started.md#getting-started-api).

Sie finden alle AWS CLI Befehle für Amazon Transcribe in der [AWS CLI Befehlsreferenz](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/transcribe/index.html#cli-aws-transcribe).

## Aufnahme einer neuen Tätigkeit im Bereich der Transkription
<a name="getting-started-cli-start-job"></a>

Um eine neue Transkription zu starten, verwenden Sie den Befehl `start-transcription-job` .

1. Geben Sie in einem Terminalfenster Folgendes ein:

   ```
   aws transcribe start-transcription-job \
   ```

   In der nächsten Zeile erscheint ein „`>`“, und Sie können nun, wie im nächsten Schritt beschrieben, die erforderlichen Parameter hinzufügen.

   Sie können „`\`“ auch weglassen und alle Parameter mit einem Leerzeichen getrennt anhängen.

1. Mit dem Befehl `start-transcription-job` müssen Sie `region`, `transcription-job-name`, `media` und entweder `language-code` oder `identify-language`einschließen.

   Wenn Sie einen Ausgabespeicherort angeben möchten, fügen Sie `output-bucket-name` in Ihre Anfrage ein; wenn Sie einen Unterordner des angegebenen Ausgabebereichs angeben möchten, fügen Sie auch `output-key` ein.

   ```
   aws transcribe start-transcription-job \
    --region us-west-2 \
    --transcription-job-name my-first-transcription-job \
    --media MediaFileUri=s3://amzn-s3-demo-bucket/my-input-files/my-media-file.flac \
    --language-code en-US
   ```

   Wenn alle Parameter angehängt werden, sieht diese Anfrage wie folgt aus:

   ```
   aws transcribe start-transcription-job --region us-west-2 --transcription-job-name my-first-transcription-job --media MediaFileUri=s3://amzn-s3-demo-bucket/my-input-files/my-media-file.flac --language-code en-US
   ```

   Wenn Sie mit `output-bucket-name`keinen Ausgabebereich angeben, legt Amazon Transcribe Ihre Transkriptionsausgabe in einem vom Dienst verwalteten Bereich ab. Die in einem serviceverwalteten Bucket gespeicherten Transkripte laufen nach 90 Tagen ab.

   Amazon Transcribe antwortet mit:

   ```
   {
       "TranscriptionJob": {
           "TranscriptionJobName": "my-first-transcription-job",
           "TranscriptionJobStatus": "IN_PROGRESS",
           "LanguageCode": "en-US",
           "Media": {
               "MediaFileUri": "s3://amzn-s3-demo-bucket/my-input-files/my-media-file.flac"
           },
           "StartTime": "2022-03-07T15:03:44.246000-08:00",
           "CreationTime": "2022-03-07T15:03:44.229000-08:00"
       }
   }
   ```

Ihr Transkriptionsauftrag ist erfolgreich, wenn [https://docs.aws.amazon.com/transcribe/latest/APIReference/API_TranscriptionJob.html#transcribe-Type-TranscriptionJob-TranscriptionJobStatus](https://docs.aws.amazon.com/transcribe/latest/APIReference/API_TranscriptionJob.html#transcribe-Type-TranscriptionJob-TranscriptionJobStatus) von `IN_PROGRESS` auf `COMPLETED` wechselt. Um die aktualisierte [https://docs.aws.amazon.com/transcribe/latest/APIReference/API_TranscriptionJob.html#transcribe-Type-TranscriptionJob-TranscriptionJobStatus](https://docs.aws.amazon.com/transcribe/latest/APIReference/API_TranscriptionJob.html#transcribe-Type-TranscriptionJob-TranscriptionJobStatus) zu sehen, verwenden Sie den Befehl `get-transcription-job` oder `list-transcription-job`, wie im folgenden Abschnitt gezeigt.

## Abrufen des Status eines Transkriptionsauftrags
<a name="getting-started-cli-get-job"></a>

Um Informationen über Ihren Transkriptionsauftrag zu erhalten, verwenden Sie den Befehl `get-transcription-job`.

Die einzigen erforderlichen Parameter für diesen Befehl sind der AWS-Region Speicherort des Auftrags und der Name des Auftrags.

```
aws transcribe get-transcription-job \
 --region us-west-2 \
 --transcription-job-name my-first-transcription-job
```

Amazon Transcribe antwortet mit:

```
{
    "TranscriptionJob": {
        "TranscriptionJobName": "my-first-transcription-job",
        "TranscriptionJobStatus": "COMPLETED",
        "LanguageCode": "en-US",
        "MediaSampleRateHertz": 48000,
        "MediaFormat": "flac",
        "Media": {
            "MediaFileUri": "s3://amzn-s3-demo-bucket/my-input-files/my-media-file.flac"
        },
        "Transcript": {
            "TranscriptFileUri": "https://s3.the-URI-where-your-job-is-located.json"
        },
        "StartTime": "2022-03-07T15:03:44.246000-08:00",
        "CreationTime": "2022-03-07T15:03:44.229000-08:00",
        "CompletionTime": "2022-03-07T15:04:01.158000-08:00",
        "Settings": {
            "ChannelIdentification": false,
            "ShowAlternatives": false
        }
    }
}
```

Wenn Sie Ihren eigenen Amazon S3 Bucket für Ihre Transkriptionsausgabe ausgewählt haben, ist dieser Bucket mit `TranscriptFileUri` aufgeführt. Wenn Sie einen serviceverwalteten Bucket ausgewählt haben, wird ein temporärer URI bereitgestellt. Verwenden Sie diesen URI, um Ihr Transkript herunterzuladen.

**Anmerkung**  
 URIs Temporäre oder vom Service verwaltete Amazon S3 Buckets sind nur für 15 Minuten gültig. Wenn Sie bei der Verwendung der URI eine `AccesDenied` Fehlermeldung erhalten, führen Sie die Anforderung `get-transcription-job` erneut aus, um eine neue temporäre URI zu erhalten.

## Auflistung Ihrer Transkriptionsaufträge
<a name="getting-started-cli-list-jobs"></a>

Verwenden Sie den Befehl, um alle Ihre Transkriptionsaufträge in einer bestimmten AWS-Region Liste aufzulisten. `list-transcription-jobs`

Der einzige erforderliche Parameter für diesen Befehl ist der, AWS-Region in dem sich Ihre Transkriptionsaufträge befinden.

```
aws transcribe list-transcription-jobs \
 --region us-west-2
```

Amazon Transcribe antwortet mit:

```
{
    "NextToken": "A-very-long-string",
    "TranscriptionJobSummaries": [
        {
            "TranscriptionJobName": "my-first-transcription-job",
            "CreationTime": "2022-03-07T15:03:44.229000-08:00",
            "StartTime": "2022-03-07T15:03:44.246000-08:00",
            "CompletionTime": "2022-03-07T15:04:01.158000-08:00",
            "LanguageCode": "en-US",
            "TranscriptionJobStatus": "COMPLETED",
            "OutputLocationType": "SERVICE_BUCKET"
        }        
    ]
}
```

## Löschen Ihres Transkriptionsauftrags
<a name="getting-started-cli-delete-job"></a>

Zum Löschen Ihres Transkriptionsauftrags verwenden Sie den Befehl `delete-transcription-job`.

Die einzigen erforderlichen Parameter für diesen Befehl sind der AWS-Region Ort, an dem sich der Job befindet, und der Name des Jobs.

```
aws transcribe delete-transcription-job \
 --region us-west-2 \
 --transcription-job-name my-first-transcription-job
```

Um zu bestätigen, dass Ihre Löschanfrage erfolgreich war, können Sie den Befehl `list-transcription-jobs` ausführen. Ihr Auftrag sollte nicht mehr in der Liste erscheinen.

# Transkribieren mit dem AWS SDKs
<a name="getting-started-sdk"></a>

Sie können es sowohl SDKs für Batch- als auch für Streaming-Transkriptionen verwenden. Wenn Sie eine Mediendatei transkribieren, die sich in einem Amazon S3 Bucket befindet, führen Sie eine Batch-Transkription durch. Wenn Sie einen Echtzeitstream von Audiodaten transkribieren, führen Sie eine Streaming-Transkription durch.

Eine Liste der Programmiersprachen, die Sie mit Amazon Transcribe verwenden können, finden Sie unter. [Unterstützte Programmiersprachen](supported-languages.md#supported-sdks) Beachten Sie, dass Streaming-Transkriptionen nicht von allen unterstützt werden. AWS SDKs Informationen zu unterstützten Medienformaten und anderen Medienanforderungen und -beschränkungen finden Sie unter [Dateneingabe und -ausgabe](how-input.md).

Weitere Informationen zu allen verfügbaren Tools AWS SDKs und Builder-Tools finden Sie unter Tools, [auf denen Sie aufbauen können](https://aws.amazon.com/developer/tools). AWS

**Tipp**  
Weitere Beispiele für die Verwendung von AWS SDKs, einschließlich funktionsspezifischer, szenarienspezifischer und serviceübergreifender Beispiele, finden Sie im Kapitel. [Codebeispiele für Amazon Transcribe mit AWS SDKs](service_code_examples.md)  
Sie finden SDK-Codebeispiele auch in diesen Repositorys: GitHub   
[AWS Codebeispiele](https://github.com/aws-samples)
[Amazon Transcribe Beispiele](https://github.com/aws-samples/amazon-transcribe-examples)

# Batch-Transkriptionen
<a name="getting-started-sdk-batch"></a>

Sie können Batch-Transkriptionen mit dem URI einer Mediendatei erstellen, die sich in einem Amazon S3 -Bucket befindet. Wenn Sie sich nicht sicher sind, wie Sie einen Amazon S3 Bucket erstellen oder Ihre Datei hochladen, finden Sie weitere Informationen unter [Erstellen Sie Ihren ersten S3-Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) und [Laden Sie ein Objekt in Ihren Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) hoch.

------
#### [ Java ]

```
import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.transcribe.TranscribeClient;
import software.amazon.awssdk.services.transcribe.model.*;
import software.amazon.awssdk.services.transcribestreaming.model.LanguageCode;

public class TranscribeDemoApp {
    private static final Region REGION = Region.US_WEST_2;
    private static TranscribeClient client;

    public static void main(String args[]) {

        client = TranscribeClient.builder()
                .credentialsProvider(getCredentials())
                .region(REGION)
                .build();

        String transcriptionJobName = "my-first-transcription-job";
        String mediaType = "flac"; // can be other types
        Media myMedia = Media.builder()
                .mediaFileUri("s3://amzn-s3-demo-bucket/my-input-files/my-media-file.flac")
                .build();

        String outputS3BucketName = "s3://amzn-s3-demo-bucket";
        // Create the transcription job request
        StartTranscriptionJobRequest request = StartTranscriptionJobRequest.builder()
                .transcriptionJobName(transcriptionJobName)
                .languageCode(LanguageCode.EN_US.toString())
                .mediaSampleRateHertz(16000)
                .mediaFormat(mediaType)
                .media(myMedia)
                .outputBucketName(outputS3BucketName)
                .build();

        // send the request to start the transcription job
        StartTranscriptionJobResponse startJobResponse = client.startTranscriptionJob(request);

        System.out.println("Created the transcription job");
        System.out.println(startJobResponse.transcriptionJob());

        // Create the get job request
        GetTranscriptionJobRequest getJobRequest = GetTranscriptionJobRequest.builder()
                .transcriptionJobName(transcriptionJobName)
                .build();

        // send the request to get the transcription job including the job status
        GetTranscriptionJobResponse getJobResponse = client.getTranscriptionJob(getJobRequest);

        System.out.println("Get the transcription job request");
        System.out.println(getJobResponse.transcriptionJob());
    }

    private static AwsCredentialsProvider getCredentials() {
        return DefaultCredentialsProvider.create();
    }

}
```

------
#### [ JavaScript ]

```
const { TranscribeClient, StartTranscriptionJobCommand } = require("@aws-sdk/client-transcribe"); // CommonJS import

const region = "us-west-2";
const credentials = {
  "accessKeyId": "",
  "secretAccessKey": "",
};

const input = {
  TranscriptionJobName: "my-first-transcription-job",
  LanguageCode: "en-US",
  Media: {
    MediaFileUri: "s3://amzn-s3-demo-bucket/my-input-files/my-media-file.flac"
  },
  OutputBucketName: "amzn-s3-demo-bucket",
};

async function startTranscriptionRequest() {
  const transcribeConfig = {
    region,
    credentials
  };
  const transcribeClient = new TranscribeClient(transcribeConfig);
  const transcribeCommand = new StartTranscriptionJobCommand(input);
  try {
    const transcribeResponse = await transcribeClient.send(transcribeCommand);
    console.log("Transcription job created, the details:");
    console.log(transcribeResponse.TranscriptionJob);
  } catch(err) {
    console.log(err);
  }
}

startTranscriptionRequest();
```

------
#### [ Python ]

```
import time
import boto3

def transcribe_file(job_name, file_uri, transcribe_client):
    transcribe_client.start_transcription_job(
        TranscriptionJobName = job_name,
        Media = {
            'MediaFileUri': file_uri
        },
        MediaFormat = 'flac',
        LanguageCode = 'en-US'
    )

    max_tries = 60
    while max_tries > 0:
        max_tries -= 1
        job = transcribe_client.get_transcription_job(TranscriptionJobName = job_name)
        job_status = job['TranscriptionJob']['TranscriptionJobStatus']
        if job_status in ['COMPLETED', 'FAILED']:
            print(f"Job {job_name} is {job_status}.")
            if job_status == 'COMPLETED':
                print(
                    f"Download the transcript from\n"
                    f"\t{job['TranscriptionJob']['Transcript']['TranscriptFileUri']}.")
            break
        else:
            print(f"Waiting for {job_name}. Current status is {job_status}.")
        time.sleep(10)


def main():
    transcribe_client = boto3.client('transcribe', region_name = 'us-west-2')
    file_uri = 's3://amzn-s3-demo-bucket/my-input-files/my-media-file.flac'
    transcribe_file('Example-job', file_uri, transcribe_client)


if __name__ == '__main__':
    main()
```

------

# Streaming-Transkriptionen
<a name="getting-started-sdk-streaming"></a>

Sie können Streaming-Transkriptionen mit einer gestreamten Mediendatei oder einem Live-Medienstream erstellen.

Beachten Sie, dass der Standard AWS SDK für Python (Boto3) für Amazon Transcribe Streaming nicht unterstützt wird. Verwenden Sie dieses [asynchrone Python-SDK für, um eine Streaming-Transkription mit Python](https://github.com/awslabs/amazon-transcribe-streaming-sdk) zu starten. Amazon Transcribe

------
#### [ Java ]

Das folgende Beispiel ist ein Java-Programm, das gestreamte Audiodaten transkribiert.

Um dieses Beispiel auszuführen, beachten Sie Folgendes:
+  Sie müssen das [AWS -SDK für Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html) verwenden.
+ Clients müssen Java 1.8 verwenden, um mit dem [AWS -SDK für Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html)kompatibel zu sein.
+ Die von Ihnen angegebene Samplerate muss mit der tatsächlichen Samplerate Ihres Audiostreams übereinstimmen.

Siehe auch: [Client für Amazon Transcribe Streaming erneut versuchen (Java](https://github.com/awsdocs/aws-doc-sdk-examples/tree/b320aeae1a3e650bffc23f9584a26a7ca177cbb2/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribestreaming) SDK). Dieser Code verwaltet die Verbindung zu Amazon Transcribe und versucht erneut, Daten zu senden, wenn bei der Verbindung Fehler auftreten. Beispiel: Wenn ein vorübergehender Fehler im Netzwerk vorliegt, sendet dieser Client die fehlgeschlagene Anforderung erneut.

```
public class TranscribeStreamingDemoApp {
    private static final Region REGION = Region.US_WEST_2;
    private static TranscribeStreamingAsyncClient client;

    public static void main(String args[]) throws URISyntaxException, ExecutionException, InterruptedException, LineUnavailableException {

        client = TranscribeStreamingAsyncClient.builder()
                .credentialsProvider(getCredentials())
                .region(REGION)
                .build();

        CompletableFuture<Void> result = client.startStreamTranscription(getRequest(16_000),
                new AudioStreamPublisher(getStreamFromMic()),
                getResponseHandler());

        result.get();
        client.close();
    }

    private static InputStream getStreamFromMic() throws LineUnavailableException {

        // Signed PCM AudioFormat with 16,000 Hz, 16 bit sample size, mono
        int sampleRate = 16000;
        AudioFormat format = new AudioFormat(sampleRate, 16, 1, true, false);
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);

        if (!AudioSystem.isLineSupported(info)) {
            System.out.println("Line not supported");
            System.exit(0);
        }

        TargetDataLine line = (TargetDataLine) AudioSystem.getLine(info);
        line.open(format);
        line.start();

        InputStream audioStream = new AudioInputStream(line);
        return audioStream;
    }

    private static AwsCredentialsProvider getCredentials() {
        return DefaultCredentialsProvider.create();
    }

    private static StartStreamTranscriptionRequest getRequest(Integer mediaSampleRateHertz) {
        return StartStreamTranscriptionRequest.builder()
                .languageCode(LanguageCode.EN_US.toString())
                .mediaEncoding(MediaEncoding.PCM)
                .mediaSampleRateHertz(mediaSampleRateHertz)
                .build();
    }

    private static StartStreamTranscriptionResponseHandler getResponseHandler() {
        return StartStreamTranscriptionResponseHandler.builder()
                .onResponse(r -> {
                    System.out.println("Received Initial response");
                })
                .onError(e -> {
                    System.out.println(e.getMessage());
                    StringWriter sw = new StringWriter();
                    e.printStackTrace(new PrintWriter(sw));
                    System.out.println("Error Occurred: " + sw.toString());
                })
                .onComplete(() -> {
                    System.out.println("=== All records stream successfully ===");
                })
                .subscriber(event -> {
                    List<Result> results = ((TranscriptEvent) event).transcript().results();
                    if (results.size() > 0) {
                        if (!results.get(0).alternatives().get(0).transcript().isEmpty()) {
                            System.out.println(results.get(0).alternatives().get(0).transcript());
                        }
                    }
                })
                .build();
    }

    private InputStream getStreamFromFile(String myMediaFileName) {
        try {
            File inputFile = new File(getClass().getClassLoader().getResource(myMediaFileName).getFile());
            InputStream audioStream = new FileInputStream(inputFile);
            return audioStream;
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    private static class AudioStreamPublisher implements Publisher<AudioStream> {
        private final InputStream inputStream;
        private static Subscription currentSubscription;


        private AudioStreamPublisher(InputStream inputStream) {
            this.inputStream = inputStream;
        }

        @Override
        public void subscribe(Subscriber<? super AudioStream> s) {

            if (this.currentSubscription == null) {
                this.currentSubscription = new SubscriptionImpl(s, inputStream);
            } else {
                this.currentSubscription.cancel();
                this.currentSubscription = new SubscriptionImpl(s, inputStream);
            }
            s.onSubscribe(currentSubscription);
        }
    }

    public static class SubscriptionImpl implements Subscription {
        private static final int CHUNK_SIZE_IN_BYTES = 1024 * 1;
        private final Subscriber<? super AudioStream> subscriber;
        private final InputStream inputStream;
        private ExecutorService executor = Executors.newFixedThreadPool(1);
        private AtomicLong demand = new AtomicLong(0);

        SubscriptionImpl(Subscriber<? super AudioStream> s, InputStream inputStream) {
            this.subscriber = s;
            this.inputStream = inputStream;
        }

        @Override
        public void request(long n) {
            if (n <= 0) {
                subscriber.onError(new IllegalArgumentException("Demand must be positive"));
            }

            demand.getAndAdd(n);

            executor.submit(() -> {
                try {
                    do {
                        ByteBuffer audioBuffer = getNextEvent();
                        if (audioBuffer.remaining() > 0) {
                            AudioEvent audioEvent = audioEventFromBuffer(audioBuffer);
                            subscriber.onNext(audioEvent);
                        } else {
                            subscriber.onComplete();
                            break;
                        }
                    } while (demand.decrementAndGet() > 0);
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            });
        }

        @Override
        public void cancel() {
            executor.shutdown();
        }

        private ByteBuffer getNextEvent() {
            ByteBuffer audioBuffer = null;
            byte[] audioBytes = new byte[CHUNK_SIZE_IN_BYTES];

            int len = 0;
            try {
                len = inputStream.read(audioBytes);

                if (len <= 0) {
                    audioBuffer = ByteBuffer.allocate(0);
                } else {
                    audioBuffer = ByteBuffer.wrap(audioBytes, 0, len);
                }
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }

            return audioBuffer;
        }

        private AudioEvent audioEventFromBuffer(ByteBuffer bb) {
            return AudioEvent.builder()
                    .audioChunk(SdkBytes.fromByteBuffer(bb))
                    .build();
        }
    }
}
```

------
#### [ JavaScript ]

```
const {
  TranscribeStreamingClient,
  StartStreamTranscriptionCommand,
} = require("@aws-sdk/client-transcribe-streaming");
const { createReadStream } = require("fs");
const { join } = require("path");

const audio = createReadStream(join(__dirname, "my-media-file.flac"), { highWaterMark: 1024 * 16});

const LanguageCode = "en-US";
const MediaEncoding = "pcm";
const MediaSampleRateHertz = "16000";
const credentials = {
  "accessKeyId": "",
  "secretAccessKey": "",
};
async function startRequest() {
  const client = new TranscribeStreamingClient({
    region: "us-west-2",
    credentials
  });

  const params = {
    LanguageCode,
    MediaEncoding,
    MediaSampleRateHertz,
    AudioStream: (async function* () {
      for await (const chunk of audio) {
        yield {AudioEvent: {AudioChunk: chunk}};
      }
    })(),
  };
  const command = new StartStreamTranscriptionCommand(params);
  // Send transcription request
  const response = await client.send(command);
  // Start to print response
  try {
    for await (const event of response.TranscriptResultStream) {
      console.log(JSON.stringify(event));
    }
  } catch(err) {
    console.log("error")
    console.log(err)
  }
}
startRequest();
```

------
#### [ Python ]

Das folgende Beispiel ist ein Python-Programm, das Streaming-Audio transkribiert.

Um dieses Beispiel auszuführen, beachten Sie Folgendes:
+ Sie müssen dieses [SDK für Python ](https://github.com/awslabs/amazon-transcribe-streaming-sdk)verwenden.
+ Die von Ihnen angegebene Samplerate muss mit der tatsächlichen Samplerate Ihres Audiostreams übereinstimmen.

```
import asyncio
# This example uses aiofile for asynchronous file reads.
# It's not a dependency of the project but can be installed
# with `pip install aiofile`.
import aiofile

from amazon_transcribe.client import TranscribeStreamingClient
from amazon_transcribe.handlers import TranscriptResultStreamHandler
from amazon_transcribe.model import TranscriptEvent

"""
Here's an example of a custom event handler you can extend to
process the returned transcription results as needed. This
handler will simply print the text out to your interpreter.
"""
class MyEventHandler(TranscriptResultStreamHandler):
    async def handle_transcript_event(self, transcript_event: TranscriptEvent):
        # This handler can be implemented to handle transcriptions as needed.
        # Here's an example to get started.
        results = transcript_event.transcript.results
        for result in results:
            for alt in result.alternatives:
                print(alt.transcript)


async def basic_transcribe():
    # Set up our client with your chosen Region
    client = TranscribeStreamingClient(region = "us-west-2")

    # Start transcription to generate async stream
    stream = await client.start_stream_transcription(
        language_code = "en-US",
        media_sample_rate_hz = 16000,
        media_encoding = "pcm",
    )

    async def write_chunks():
        # NOTE: For pre-recorded files longer than 5 minutes, the sent audio
        # chunks should be rate limited to match the real-time bitrate of the
        # audio stream to avoid signing issues.
        async with aiofile.AIOFile('filepath/my-media-file.flac', 'rb') as afp:
            reader = aiofile.Reader(afp, chunk_size = 1024 * 16)
            async for chunk in reader:
                await stream.input_stream.send_audio_event(audio_chunk = chunk)
        await stream.input_stream.end_stream()

    # Instantiate our handler and start processing events
    handler = MyEventHandler(stream.output_stream)
    await asyncio.gather(write_chunks(), handler.handle_events())

loop = asyncio.get_event_loop()
loop.run_until_complete(basic_transcribe())
loop.close()
```

------
#### [ C\$1\$1 ]

Ein [Streaming C\$1\$1 SDK-Beispiel](https://docs.aws.amazon.com/code-library/latest/ug/cpp_1_transcribe-streaming_code_examples.html) finden Sie im Kapitel Codebeispiele.

------

## Verwenden Sie diesen Dienst mit einem SDK AWS
<a name="sdk-general-information-section"></a>

AWS Software Development Kits (SDKs) sind für viele gängige Programmiersprachen verfügbar. Jedes SDK bietet eine API, Codebeispiele und Dokumentation, die es Entwicklern erleichtern, Anwendungen in ihrer bevorzugten Sprache zu erstellen.


| SDK-Dokumentation | Codebeispiele | 
| --- | --- | 
| [AWS SDK für C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp) | [AWS SDK für C\$1\$1 Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp) | 
| [AWS CLI](https://docs.aws.amazon.com/cli) | [AWS CLI Codebeispiele](https://docs.aws.amazon.com/code-library/latest/ug/cli_2_code_examples.html) | 
| [AWS SDK für Go](https://docs.aws.amazon.com/sdk-for-go) | [AWS SDK für Go Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2) | 
| [AWS SDK für Java](https://docs.aws.amazon.com/sdk-for-java) | [AWS SDK für Java Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) | 
| [AWS SDK für JavaScript](https://docs.aws.amazon.com/sdk-for-javascript) | [AWS SDK für JavaScript Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3) | 
| [AWS SDK für Kotlin](https://docs.aws.amazon.com/sdk-for-kotlin) | [AWS SDK für Kotlin Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin) | 
| [AWS SDK für .NET](https://docs.aws.amazon.com/sdk-for-net) | [AWS SDK für .NET Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3) | 
| [AWS SDK für PHP](https://docs.aws.amazon.com/sdk-for-php) | [AWS SDK für PHP Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php) | 
| [AWS -Tools für PowerShell](https://docs.aws.amazon.com/powershell) | [AWS -Tools für PowerShell Codebeispiele](https://docs.aws.amazon.com/code-library/latest/ug/powershell_5_code_examples.html) | 
| [AWS SDK für Python (Boto3)](https://docs.aws.amazon.com/pythonsdk) | [AWS SDK für Python (Boto3) Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python) | 
| [AWS SDK für Ruby](https://docs.aws.amazon.com/sdk-for-ruby) | [AWS SDK für Ruby Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby) | 
| [AWS SDK für Rust](https://docs.aws.amazon.com/sdk-for-rust) | [AWS SDK für Rust Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1) | 
| [AWS SDK für SAP ABAP](https://docs.aws.amazon.com/sdk-for-sapabap) | [AWS SDK für SAP ABAP Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap) | 
| [AWS SDK für Swift](https://docs.aws.amazon.com/sdk-for-swift) | [AWS SDK für Swift Codebeispiele](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift) | 

Weitere Beispiele speziell für diesen Service finden Sie unter [Codebeispiele für Amazon Transcribe mit AWS SDKs](service_code_examples.md).

**Beispiel für die Verfügbarkeit**  
Sie können nicht finden, was Sie brauchen? Fordern Sie ein Codebeispiel an, indem Sie unten den Link **Provide feedback** (Feedback geben) auswählen.

# Transkribieren mit HTTP oder WebSockets
<a name="getting-started-http-websocket"></a>

Amazon Transcribe unterstützt HTTP sowohl für Batch- (HTTP/1.1) als auch für Streaming-Transkriptionen (HTTP/2). WebSockets werden für Streaming-Transkriptionen unterstützt.

Wenn Sie eine Mediendatei transkribieren, die sich in einem Amazon S3 Bucket befindet, führen Sie eine Batch-Transkription durch. Wenn Sie einen Echtzeitstream von Audiodaten transkribieren, führen Sie eine Streaming-Transkription durch.

Sowohl HTTP als auch WebSockets erfordern, dass Sie Ihre Anfrage mithilfe von AWS Signature Version 4-Headern authentifizieren. Weitere Informationen finden Sie unter [AWS API-Anfragen signieren](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html).

## Batch-Transkriptionen
<a name="getting-started-http-batch"></a>

Sie können eine Batch-HTTP-Anfrage mit den folgenden Headern stellen:
+ Host
+ x-amz-target
+ Inhalts-Typ
+ x-amz-content-sha256
+ x-amz-date
+ Autorisierung

Hier ist ein Beispiel für eine `StartTranscriptionJob` Anfrage:

```
POST /transcribe HTTP/1.1 
host: transcribe.us-west-2.amazonaws.com
x-amz-target: com.amazonaws.transcribe.Transcribe.StartTranscriptionJob 
content-type: application/x-amz-json-1.1
x-amz-content-sha256: string
x-amz-date: YYYYMMDDTHHMMSSZ
authorization: AWS4-HMAC-SHA256 Credential=access-key/YYYYMMSS/us-west-2/transcribe/aws4_request, SignedHeaders=content-type;host;x-amz-content-sha256;x-amz-date;x-amz-target;x-amz-security-token, Signature=string

{
    "TranscriptionJobName": "my-first-transcription-job",
    "LanguageCode": "en-US",
    "Media": {
        "MediaFileUri": "s3://amzn-s3-demo-bucket/my-input-files/my-media-file.flac"
    },
    "OutputBucketName": "amzn-s3-demo-bucket",
    "OutputKey": "my-output-files/" 
}
```

Zusätzliche Operationen und Parameter sind in der [API-Referenz](https://docs.aws.amazon.com/transcribe/latest/APIReference/API_Reference.html) aufgeführt. Parameter, die allen AWS API-Vorgängen gemeinsam sind, sind im Abschnitt [Allgemeine Parameter](https://docs.aws.amazon.com/transcribe/latest/APIReference/CommonParameters.html) aufgeführt. Weitere Signaturelemente werden unter [Elemente einer AWS Signaturversion 4-Anfrage](https://docs.aws.amazon.com/general/latest/gr/sigv4_elements.html) detailliert beschrieben.

## Streaming-Transkriptionen
<a name="getting-started-http-streaming"></a>

Das Streamen von Transkriptionen unter Verwendung von HTTP/2 ist aufwändiger WebSockets als das Verwenden von. SDKs Wir empfehlen Ihnen, den Abschnitt [Einrichten einer Streaming-Transkription](streaming-setting-up.md) durchzulesen, bevor Sie Ihren ersten Stream einrichten.

Weitere Informationen zu diesen Methoden finden Sie unter [Einrichten eines HTTP/2-Streams](streaming-setting-up.md#streaming-http2) oder [Einen WebSocket Stream einrichten](streaming-setting-up.md#streaming-websocket).

**Anmerkung**  
Wir empfehlen dringend die Verwendung eines SDK für Streaming-Transkriptionen. Eine Liste der unterstützten SDKs Programme finden Sie unter. [Unterstützte Programmiersprachen](supported-languages.md#supported-sdks)