Livestreaming in Google Cloud mit Media CDN und der Live Streaming API

1. Einführung

Content Delivery Networks (CDNs) verbessern die Leistung für Nutzer, indem sie häufig aufgerufene Inhalte näher an den Endnutzern im Cache speichern, Verbindungen näher an den Clients beenden, Verbindungen zum Ursprung wiederverwenden und moderne Netzwerkprotokolle und Anpassungen nutzen. Für Nutzer und unsere Kunden bedeutet das eine geringere Latenz, mehr Zuverlässigkeit und geringere Kosten. Das führt zu mehr Umsatz, einer besseren Webleistung und einer insgesamt besseren Nutzerfreundlichkeit. Heutzutage gibt es nur noch sehr wenige moderne Websites und Videostreaming-Plattformen, die ohne CDN auskommen.

Lerninhalte

In diesem Lab werden wir durch die Schritte zum Bereitstellen einer Live-Streaming-Workflow-Umgebung mit Media CDN (CDN) + Cloud Media Live Streaming API (Live-Videotranscodierung) + Cloud Storage (Speicher für die Videos) + Videoplayer (VLC, Google Shaka Player usw. – HLS- und MPEG-DASH-kompatibler Player) geführt.

Wir richten die Livestreaming-API-Komponenten „Input“ und „Channel“ ein und starten mit FFmpeg einen Livefeed zum Input/Channel. FFmpeg kann ein Live-Testsignal generieren. Die Live Streaming API transcodiert den Livefeed. Das transcodierte Videomanifest und die Segmente werden in einem Cloud Storage-Bucket gespeichert. Anschließend richten wir Media CDN mit dem Cloud Storage-Bucket für Live-Videos als Ursprung ein. Schließlich wird der VLC Player verwendet, um Liveinhalte wiederzugeben, die über Media CDN im Cache gespeichert wurden. Außerdem richten wir ein Cloud Monitoring-Dashboard ein, um die Aktivität von Media CDN zu visualisieren.

Umfang

In diesem Lab richten wir die Umgebung basierend auf der folgenden Architektur ein:

Im Rahmen dieses Labs werden die folgenden Komponenten eingerichtet und die folgenden Aufgaben ausgeführt:

• Google Cloud Storage-Bucket (GCS) zum Speichern der live transcodierten Videos erstellen
• Live Streaming API so konfigurieren, dass das Video in mehrere Formate transcodiert wird: HLS + MPEG DASH, SD und HD
• Livestreaming-Komponenten einrichten: Eingabe/Kanal
• Livestreamkanal starten
• Media CDN mit dem GCS-Bucket als Ursprung einrichten
• FFmpeg zum Speisen des Live-Kanals einrichten
• Transcodierten Livestream mit einem Videoplayer streamen
• Cloud Monitoring-Dashboard einrichten, um Media CDN-Aktivitäten zu überwachen (Latenz, Cache-Treffer, Cache-Fehler usw.)

Hinweis: In diesem Lab wird davon ausgegangen, dass Nutzer Zugriff auf die Google Cloud Console haben und bereits ein Projekt eingerichtet haben. Wir gehen außerdem davon aus, dass Nutzer mit einer neuen Umgebung beginnen und für diese Demo nichts eingerichtet haben.

Alle Konfigurationsaktionen werden über die Befehlszeile in Cloud Shell ausgeführt. Wir können die über die Befehlszeile konfigurierten Komponenten jederzeit in der Console prüfen. Im gesamten Lab werden wir auf die Google Cloud Console verweisen.

Hinweis:Der Zugriff auf Media CDN ist eingeschränkt. Wenn Sie Zugriff auf Media CDN erhalten möchten, wenden Sie sich an Ihr Account-Management-Team. Er kann in deinem Namen eine Zugriffsanfrage erstellen. Wenn Sie bei Google arbeiten und Livestreaming mit Media CDN testen möchten, wenden Sie sich an den Produktmanager für Media CDN, um Zugriff auf Media CDN anzufordern.

2. Hinweis

Der Zugriff auf Media CDN ist eingeschränkt. Wenn Sie Zugriff auf Media CDN erhalten möchten, wenden Sie sich an Ihr Account-Management-Team. Er kann in deinem Namen eine Zugriffsanfrage erstellen. Wenn Sie zu Google gehören und Livestreaming mit Media CDN testen möchten, wenden Sie sich an den Produktmanager für Media CDN, um Zugriff auf Media CDN anzufordern.

Achtung:Ihr Projekt muss auf der Zulassungsliste für Media CDN stehen. Wenn Ihr Projekt nicht auf der Zulassungsliste steht, können Sie dieses Lab nicht abschließen. Möglicherweise wird der Media CDN-Dienst in Ihrer GCP Console angezeigt, Sie können den Ursprung oder den Dienst jedoch nicht erstellen.

3. Einrichtung und Anforderungen

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Google Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Klicken Sie in der Google Cloud Console rechts oben in der Symbolleiste auf das Cloud Shell-Symbol:

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Anschließend sehen Sie in etwa Folgendes:

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser ausgeführt werden. Sie müssen nichts installieren.

4. Google Cloud SDK-Version

Zum Zeitpunkt der Erstellung dieses Dokuments ist 408.0.0 die aktuelle Google Cloud SDK-Version. Alle Befehle in diesem Lab wurden mit der neuesten Version des Google Cloud SDK getestet. Prüfen Sie, ob in Cloud Shell die neueste Version des SDK verwendet wird, bevor Sie fortfahren.

SDK-Version prüfen

Wir verwenden den Befehl gcloud version, um die SDK-Version zu prüfen.

Befehl

gcloud version | grep "Google Cloud SDK"

Beispielausgabe

Google Cloud SDK 408.0.0

Nächste Schritte

Achtung:Wählen Sie Option 1 oder 2 basierend auf der Ausgabe des Befehls gcloud version aus.

1. Wenn die SDK-Version 408.0.0 oder höher ist, fahren Sie mit dem nächsten Abschnitt fort.
2. Wenn die SDK-Version niedriger als 408.0.0 ist, führen Sie den unten aufgeführten Befehl aus, um das SDK zu aktualisieren.

sudo apt-get update && sudo apt-get install google-cloud-sdk

5. Vorbereitung

Bevor wir mit der Konfiguration der GCP-Ressourcen beginnen, müssen wir Folgendes tun:

1. Umgebungsvariablen einrichten
2. Erforderliche Service-APIs aktivieren

1. Umgebungsvariablen einrichten

In diesem Lab führen wir gcloud- und curl-Befehle mit einigen Variablen aus. Wir müssen die folgenden Umgebungsvariablen konfigurieren.

• Projekt-ID
• Projektnummer
• Nutzername
• Region
• Eingabe-ID
• Kanal-ID

Projekt-ID und Nutzername

Diese Umgebungsvariablen sind in Cloud Shell in der Regel vorkonfiguriert. Wir verwenden den Befehl env zur Bestätigung.

Befehl

env | grep -E 'DEVSHELL_PROJECT_ID=|LOGNAME'

Beispielausgabe

DEVSHELL_PROJECT_ID=<YOUR_PROJECT_ID>
LOGNAME=<YOUR_USERNAME>

env_variables-Datei erstellen

Verwenden Sie den Befehl cat, um die Datei env_variables.txt zu erstellen. Mit dem folgenden Befehl wird die Datei env_variables.txt im Basisverzeichnis des Nutzers erstellt.

Hinweis:Wenn Sie dazu aufgefordert werden, autorisieren Sie die Anfrage.

Befehle

cat > ~/env_variables.txt << EOF
export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export LOCATION=us-west2
export INPUT_ID=lab-live-input
export CHANNEL_ID=lab-live-channel
EOF

Umgebungsvariablen einrichten

Wir verwenden den Befehl source, um die Umgebungsvariablen festzulegen.

Befehl

source ~/env_variables.txt

Hinweis:Mit dem oben genannten Befehl werden die Umgebungsvariablen nur für den Lebenszyklus der Cloud Shell-Instanz festgelegt. Wenn der Nutzer die Cloud Shell-Instanz beendet oder eine neue Cloud Shell öffnet, muss er den Befehl source noch einmal ausführen.

Prüfen, ob die Variablen festgelegt sind

Prüfen wir, ob alle erforderlichen Umgebungsvariablen festgelegt sind. In der Ausgabe sollten insgesamt sechs Umgebungsvariablen angezeigt werden.

Befehl

env | grep -E 'DEVSHELL_PROJECT_ID=|LOGNAME|PROJECT_NUMBER|LOCATION|INPUT_ID|CHANNEL_ID'

Beispielausgabe

LOCATION=us-west2
DEVSHELL_PROJECT_ID=<YOUR_PROJECT_ID>
LOGNAME=<YOUR_USERNAME>
PROJECT_NUMBER=<YOUR_PROJECT_NUMBER>
INPUT_ID=lab-live-input
CHANNEL_ID=lab-live-channel

2. Erforderliche Dienst-APIs aktivieren

Wir müssen dafür sorgen, dass die folgenden APIs in unserem Projekt aktiviert sind.

• Network Services API
• Certificate Manager API
• Livestream API
• Media CDN Edge Cache API

Network Services API aktivieren

Führen Sie den folgenden Befehl aus, um die Network Services API zu aktivieren:

Befehl

gcloud services enable networkservices.googleapis.com

Certificate Manager API aktivieren

Führen Sie den folgenden Befehl aus, um die Certificate Manager API zu aktivieren:

Befehl

gcloud services enable certificatemanager.googleapis.com

Live Stream API aktivieren

Führen Sie den folgenden Befehl aus, um die Live Stream API zu aktivieren:

Befehl

gcloud services enable livestream.googleapis.com

Media CDN Edge Cache API aktivieren

Führen Sie den folgenden Befehl aus, um die Media CDN Edge Cache API zu aktivieren:

Befehl

gcloud services enable edgecache.googleapis.com

Prüfen, ob die APIs aktiviert sind

Führen Sie den Befehl gcloud services list aus, um alle aktivierten APIs aufzulisten. In der Ausgabe sollten 4 APIs angezeigt werden.

Befehl

gcloud services list | grep -E 'networkservices|certificatemanager|livestream|edgecache'

Beispielausgabe

NAME: certificatemanager.googleapis.com
NAME: livestream.googleapis.com
NAME: networkservices.googleapis.com
NAME: edgecache.googleapis.com

6. Cloud Storage-Bucket erstellen

Hinweis:Cloud Storage-Bucket-Namen müssen global eindeutig sein. Um Konflikte zu vermeiden, verwenden wir die Umgebungsvariable $LOGNAME als Teil des Bucket-Namens. Diese Variable wird standardmäßig in Cloud Shell erstellt.

In diesem Abschnitt gehen wir so vor:

1. Cloud Storage-Bucket erstellen
2. Bucket öffentlich zugänglich machen

Später im Lab verwenden wir diesen Bucket zum Speichern der transcodierten Videodateien. Dieser Bucket dient auch als Ursprungsspeicher für den Media CDN-Dienst.

1. Bucket erstellen

Wir verwenden den Befehl gsutil mb, um den Bucket zu erstellen:

Befehl

gsutil mb gs://live-streaming-storage-$LOGNAME

2. Bucket öffentlich zugänglich machen

Hinweis:Damit dieses Lab einfach gehalten wird, machen wir den Quell-Bucket öffentlich lesbar. Media CDN unterstützt auch private Buckets als Ursprung. Weitere Informationen zur Verwendung privater Cloud Storage-Buckets mit Media CDN finden Sie in der öffentlichen Dokumentation.

Wir verwenden den Befehl gsutil iam, um die Dateien öffentlich verfügbar zu machen:

Befehl

gsutil iam ch allUsers:objectViewer gs://live-streaming-storage-$LOGNAME

7. Livestreaming API-Umgebung einrichten

Die Komponenten der Live Streaming API-Kette sind so aufgebaut:

Wir haben den Cloud Storage-Bucket live-streaming-storage-$LOGNAME im vorherigen Abschnitt erstellt. In den nächsten beiden Abschnitten erstellen wir die folgenden Ressourcen:

• Livestreaming-Eingabe:Ein Eingabeendpunkt ist ein Endpunkt, an den Ihr Encoder Ihren Eingabestream sendet. Mit dem Eingabeendpunkt können Sie Konfigurationen für Ihren Stream angeben, z. B. Eingabeauflösung, Eingabetyp und Videobeschneidung.
• Live-Streaming-Kanal:Ein Kanal ist eine Ressource, die den Eingabestream über einen Eingabeendpunkt aufnimmt, den Eingabestream in mehrere Versionen transcodiert und Live-Ausgabestreams in bestimmten Formaten am angegebenen Ort veröffentlicht. Du kannst einen primären und einen Backup-Eingabestream in denselben Kanal einfügen.

Wir erstellen die folgenden Ressourcen später im Lab:

• Encoder:Ein Encoder ist ein Programm, mit dem Eingabestreams gesendet werden. In diesem Lab verwenden wir FFmpeg.

8. Eingabeendpunkt erstellen und konfigurieren

Datei „input.json“ erstellen

Wir erstellen eine input.json-Datei, um den Livestream-Signaltyp anzugeben. In diesem Lab verwenden wir das RTMP-Livesignal.

Befehl

cat > input.json << EOF
{
  "type": "RTMP_PUSH"
}
EOF

Eingabeendpunkt erstellen

Zum Zeitpunkt der Erstellung dieses Labs wird die Live Stream API nicht von gcloud unterstützt. Wir verwenden den curl-Befehl, um die API-Aufrufe auszuführen.

Hinweis:Mit dem folgenden Befehl werden die PROJECT_NUMBER, LOCATION und INPUT_ID aus den Umgebungsvariablen ausgewählt, die wir zuvor konfiguriert haben.

Befehl

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @input.json \
"https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/inputs?inputId=$INPUT_ID"

Beispielausgabe

{
  "name": "projects/PROJECT_NUMBER/locations/us-west2/operations/operation-1661405972853-5e70a38d6f27f-79100d00-310671b4",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
    "createTime": "2022-08-25T05:39:32.884030164Z",
    "target": "projects/PROJECT_NUMBER/locations/us-west2/inputs/lab-live-input",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Die Ausgabe enthält viele nützliche Informationen, aber derzeit müssen wir uns auf zwei Felder konzentrieren:

• Vorgangs-ID:Kopieren Sie die Vorgangs-ID aus der Ausgabe und notieren Sie sie. Unten sehen Sie die Vorgangs-ID aus dem Beispiel für die Ausgabe. Sie finden sie in der Ausgaberzeile, die mit "name" beginnt. "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4"
• Status:Wir müssen warten, bis sich der Status von "done": false zu "done": true ändert.

Status prüfen

Bevor wir fortfahren, müssen wir prüfen, ob der Eingabeendpunkt erfolgreich erstellt wurde und bereit ist.

Achtung:Wenn die Antwort "done: false" enthält, wiederholen Sie den Befehl, bis die Antwort "done: true" enthält. Das Erstellen des ersten Eingabeendpunkts in einer Region kann bis zu 10 Minuten dauern.

Ersetzen Sie im folgenden Befehl <OPERATION> durch die ID des Vorgangs, die wir oben erhalten haben. In diesem Beispiel ist das "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4".

Hinweis:Mit dem folgenden Befehl werden die Umgebungsvariablen nur für den Lebenszyklus der Cloud Shell-Instanz festgelegt. Wenn der Nutzer die Cloud Shell-Instanz beendet oder eine neue Cloud Shell öffnet, muss er die Umgebungsvariable noch einmal festlegen.

Befehl

export OPERATION_ID_1=<OPERATION>

Hinweis:Möglicherweise müssen Sie den Befehl mehrmals ausführen, bis in der Ausgabe „done:true“ angezeigt wird. Das bedeutet, dass der Eingabeendpunkt erstellt wurde und bereit ist.

Befehl

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
"https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/operations/$OPERATION_ID_1"

Beispielausgabe

{
  "name": "projects/PROJECT_NUMBER/locations/us-west2/operations/operation-1661408816982-5e70ae25cea49-617844f0-8fdcb4a1",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
    "createTime": "2022-08-25T06:26:57.001530499Z",
    "endTime": "2022-08-25T06:26:57.043623522Z",
    "target": "projects/PROJECT_NUMBER/locations/us-west2/inputs/lab-live-input",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.video.livestream.v1.Input",
    "name": "projects/PROJECT_ID/locations/us-west2/inputs/lab-live-input",
    "createTime": "2022-08-25T06:26:56.997623672Z",
    "updateTime": "2022-08-25T06:26:56.997623672Z",
    "type": "RTMP_PUSH",
    "uri": "rtmp://34.94.97.220/live/4b7846a1-4a67-44ed-bfd0-d98281b6464a",
    "tier": "HD"
  }
}

Führen Sie den Befehl so lange aus, bis "done:true" angezeigt wird. Das bedeutet, dass der Eingabeendpunkt erstellt wurde und bereit ist.

Hinweis:Kopieren Sie den URI (hier rtmp://34.94.97.220/live/4b7846a1-4a67-44ed-bfd0-d98281b6464a) und notieren Sie ihn sich, da wir ihn später im Lab verwenden werden, um ein Live-Signal an den Input/Kanal zu senden.

URI speichern

Wir verwenden die URI aus der vorherigen Ausgabe später im Lab. Legen wir jetzt eine Umgebungsvariable für URI fest.

Hinweis:Mit dem folgenden Befehl werden die Umgebungsvariablen nur für den Lebenszyklus der Cloud Shell-Instanz festgelegt. Wenn der Nutzer die Cloud Shell-Instanz beendet oder eine neue Cloud Shell öffnet, muss er die Umgebungsvariable noch einmal festlegen.

Befehl

export URI=<uri>

Ersetzen Sie <uri> durch den URI, den Sie gerade oben notiert haben. Optional können Sie auch die GET-Methode verwenden, um den URI abzurufen.

Befehl

curl -s -X GET -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) "https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/inputs/$INPUT_ID" | jq .uri

9. Livestreaming-Kanal erstellen und konfigurieren

Erstellen wir den Livestreaming-Kanal, der mit dem Eingabeendpunkt verknüpft ist, den wir gerade im vorherigen Abschnitt erstellt haben. Im folgenden Beispiel wird ein Kanal erstellt, der einen HLS-Livestream mit einer einzelnen HD-Wiedergabe (1280 × 720) generiert. Der Kanal wird mit dem Eingabeendpunkt und dem zuvor erstellten Storage-Bucket verknüpft.

Datei „channel.json“ erstellen

Geben Sie im Cloud Shell-Terminal den folgenden Befehl ein, um eine "channel.json"-Datei zu erstellen:

Befehl

cat > channel.json << EOF
{
  "inputAttachments": [
    {
      "key": "my-input",
      "input": "projects/$PROJECT_NUMBER/locations/$LOCATION/inputs/$INPUT_ID"
    }
  ],
  "output": {
    "uri": "gs://live-streaming-storage-$LOGNAME"
  },
  "elementaryStreams": [
    {
      "key": "es_video",
      "videoStream": {
        "h264": {
          "profile": "high",
          "widthPixels": 1280,
          "heightPixels": 720,
          "bitrateBps": 3000000,
          "frameRate": 30
        }
      }
    },
    {
      "key": "es_audio",
      "audioStream": {
        "codec": "aac",
        "channelCount": 2,
        "bitrateBps": 160000
      }
    }
  ],
  "muxStreams": [
    {
      "key": "mux_video_ts",
      "container": "ts",
      "elementaryStreams": ["es_video", "es_audio"],
      "segmentSettings": { "segmentDuration": "2s" }
    }
  ],
  "manifests": [
    {
      "fileName": "main.m3u8",
      "type": "HLS",
      "muxStreams": [
        "mux_video_ts"
      ],
      "maxSegmentCount": 5
    }
  ]
}
EOF

Kanal erstellen

Führen Sie den folgenden curl-Befehl aus, um den Channel zu erstellen:

Befehl

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @channel.json \
"https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/channels?channelId=$CHANNEL_ID"

Beispielausgabe

{
  "name": "projects/PROJECT_NUMBER/locations/us-west2/operations/operation-1661405972853-5e70a38d6f27f-79100d00-310671b4",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
    "createTime": "2022-08-25T05:39:32.884030164Z",
    "target": "projects/PROJECT_NUMBER/locations/us-west2/channels/lab-live-channel",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Notieren und kopieren Sie die Vorgangs-ID. Wir benötigen sie in einem der nächsten Schritte. Sie finden sie in der Ausgaberzeile, die mit "name" beginnt.

Status prüfen

Bevor wir fortfahren, müssen wir prüfen, ob der Kanal erstellt wurde und bereit ist.

Achtung:Wenn die Antwort "done: false" enthält, wiederholen Sie den Befehl, bis die Antwort "done: true" enthält. Das Erstellen des ersten Channels in einer Region kann bis zu 10 Minuten dauern.

Ersetzen Sie im folgenden Befehl <OPERATION> durch die ID des Vorgangs, die wir oben erhalten haben. In diesem Beispiel ist das operation-1661405972853-5e70a38d6f27f-79100d00-310671b4.

Befehl

export OPERATION_ID_2=<OPERATION>

Hinweis:Möglicherweise müssen Sie den Befehl mehrmals ausführen, bis in der Ausgabe „done:true“ angezeigt wird. Das bedeutet, dass der Eingabeendpunkt erstellt wurde und bereit ist.

Befehl

curl -s -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
"https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/operations/$OPERATION_ID_2"

Beispielausgabe

  "name": "projects/PROJECT_NUMBER/locations/us-west2/operations/operation-1668666801461-5eda4c3f31852-a4d2229f-0efeef9e",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
    "createTime": "2022-11-17T06:33:21.500841488Z",
    "endTime": "2022-11-17T06:33:21.529311112Z",
    "target": "projects/PROJECT_NUMBER/locations/us-west2/channels/lab-live-channel",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.video.livestream.v1.Channel",
    "name": "projects/PROJECT_NAME/locations/us-west2/channels/lab-live-channel",
    "createTime": "2022-11-17T06:33:21.497818033Z",
    "updateTime": "2022-11-17T06:33:21.497818033Z",
    "activeInput": "my-input",
    "output": {
      "uri": "gs://live-streaming-storage-LOGNAME"
    },
    "elementaryStreams": [
      {
        "videoStream": {
          "h264": {
            "widthPixels": 1280,
            "heightPixels": 720,
            "frameRate": 30,
            "bitrateBps": 3000000,
            "gopDuration": "2s",
            "vbvSizeBits": 3000000,
            "vbvFullnessBits": 2700000,
            "entropyCoder": "cabac",
            "profile": "high"
          }
        },
        "key": "es_video"
      },
      {
        "audioStream": {
          "codec": "aac",
          "bitrateBps": 160000,
          "channelCount": 2,
          "sampleRateHertz": 48000
        },
        "key": "es_audio"
      }
    ],
    "muxStreams": [
      {
        "key": "mux_video_ts",
        "container": "ts",
        "elementaryStreams": [
          "es_video",
          "es_audio"
        ],
        "segmentSettings": {
          "segmentDuration": "2s"
        }
      }
    ],
    "manifests": [
      {
        "fileName": "main.m3u8",
        "type": "HLS",
        "muxStreams": [
          "mux_video_ts"
        ],
        "maxSegmentCount": 5,
        "segmentKeepDuration": "60s"
      }
    ],
    "streamingState": "STOPPED",
    "inputAttachments": [
      {
        "key": "my-input",
        "input": "projects/PROJECT_NUMBER/locations/us-west2/inputs/lab-live-input"
      }
    ],
    "logConfig": {
      "logSeverity": "OFF"
    }
  }
}

Führen Sie den Befehl so lange aus, bis "done:true" angezeigt wird. Das bedeutet, dass der Eingabeendpunkt erstellt wurde und bereit ist.

Der "streamingState" ist derzeit "STOPPED". Wir starten den Channel im nächsten Abschnitt.

10. Livestreaming-Kanal starten

Nachdem wir unseren Livestream-Kanal erstellt haben, starten wir ihn. In diesem Abschnitt gehen wir so vor:

1. Livestreaming-Kanal starten
2. Prüfe den Status des Kanals. Er muss "AWAITING INPUT" sein.streamingState

1. Kanal starten

Führen Sie in Cloud Shell den folgenden curl-Befehl aus, um den Kanal zu starten:

Befehl

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d "" \
"https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/channels/$CHANNEL_ID:start"

Beispielausgabe

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/operation-1661405972853-5e70a38d6f27f-79100d00-310671b4",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
    "createTime": "2022-08-25T05:39:32.884030164Z",
    "target": "projects/PROJECT_NUMBER/locations/us-west2/channels/lab-live-channel",
    "verb": "start",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Achtung:Das Starten des ersten Kanals in einer Region dauert etwa 10 Minuten. Fahren Sie mit dem Lab fort und folgen Sie der Anleitung im nächsten Abschnitt, um den Status des Kanals zu überprüfen. Klicken Sie erst auf „Weiter“, wenn Sie "streamingState": "AWAITING INPUT" sehen. Das bedeutet, dass der Kanal gestartet wurde und bereit ist, ein Live-Signal für die Transcodierung zu empfangen.

2. Status des Kanals prüfen

Führen Sie den folgenden curl-Befehl aus, um den Status des Channels abzurufen:

Hinweis:Warten Sie an dieser Stelle noch einmal und führen Sie den GET-Befehl dann noch einmal aus, bis "streamingState": "AWAITING_INPUT" angezeigt wird. Das bedeutet, dass der Channel gestartet und bereit ist, ein Eingangssignal zu empfangen.

Befehl

curl -s -X GET -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) "https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/channels/$CHANNEL_ID" | grep "streamingState"

Beispielausgabe

"streamingState": "AWAITING_INPUT",

Führen Sie den Befehl so lange aus, bis „AWAITING_INPUT“ angezeigt wird. Das bedeutet, dass der Channel ausgeführt wird und bereit ist, ein Signal zu empfangen.

11. Media CDN konfigurieren

In diesem Abschnitt stellen wir Media CDN bereit – die CDN-Infrastruktur. Wir erstellen die folgenden Ressourcen:

1. Edge-Cache-Ursprung
2. Edge-Cache-Dienst

1. Edge-Cache-Ursprung erstellen

Ein Edge Cache-Ursprung stellt einen Inhaltsspeicherort dar, z. B. einen Cloud Storage-Bucket, einen Speicherort eines Drittanbieters oder einen Load Balancer. Im CDN-Kontext ist der Ursprung (oder Ursprungsserver) der Ort, an dem sich die Quelle der Inhalte befindet, die wir verteilen möchten, z.B. alle CSS-, JavaScript-, HTML- und Bilddateien. In diesem Lab erstellen wir einen Ursprung, der dem Cloud Storage-Bucket entspricht, den wir am Anfang des Labs erstellt haben. Wir nennen den Edge-Cache-Ursprung cme-origin. Der Ursprung eines CDN ist der Ort, an dem alle Quellinhalte gespeichert werden, bevor sie an die Edge-Cache-Server verteilt werden.

Wir verwenden den Befehl gcloud edge-cache origins create, um den Ursprung zu erstellen. Die Ausführung des Befehls kann einige Minuten dauern.

Hinweis:Es kann bis zu 10 Minuten dauern, bis Media CDN den Ursprung erstellt hat.

Befehl

gcloud edge-cache origins create cme-origin \
--origin-address="gs://live-streaming-storage-$LOGNAME"

Beispielausgabe

Create request issued for: cme-origin
Waiting for operation [projects/my-project/locations/global/operations/operation-1612121774168-5ba3759af1919-
3fdcd7b1-99f59223] to complete...done
Created origin cme-origin

2. Edge-Cache-Dienst erstellen

Nachdem wir einen Edge-Cache-Ursprung eingerichtet haben, können wir den Edge-Cache-Dienst selbst erstellen.

Erstellen der cme-demo.yaml-Datei

Die Konfiguration des Edge-Cache-Dienstes erfolgt über eine YAML-Datei. Erstellen Sie in Cloud Shell eine lokale Datei mit dem Namen cme-demo.yaml. Verwenden Sie vi, nano oder einen anderen Editor und fügen Sie die folgenden Zeilen in die YAML-Datei ein:

name: cme-demo
routing:
  hostRules:
    - hosts:
        - demo.cme.com
      pathMatcher: routes
  pathMatchers:
    - name: routes
      routeRules:
        - headerAction:
            responseHeadersToAdd:
              - headerName: x-cache-status
                headerValue: "{cdn_cache_status}"
          matchRules:
            - prefixMatch: /
          origin: cme-origin
          priority: 100
          routeAction:
            cdnPolicy:
              cacheKeyPolicy: {}
              cacheMode: FORCE_CACHE_ALL
              defaultTtl: 3600s
              signedRequestMode: DISABLED
        - headerAction:
            responseHeadersToAdd:
              - headerName: x-cache-status
                headerValue: "{cdn_cache_status}"
          matchRules:
            - pathTemplateMatch: /**.m3u8
          origin: cme-origin
          priority: 25
          routeAction:
            cdnPolicy:
              cacheKeyPolicy: {}
              cacheMode: FORCE_CACHE_ALL
              defaultTtl: 1s
              signedRequestMode: DISABLED
        - headerAction: {}
          matchRules:
            - pathTemplateMatch: /**.ts
          origin: cme-origin
          priority: 50
          routeAction:
            cdnPolicy:
              cacheKeyPolicy: {}
              cacheMode: FORCE_CACHE_ALL
              defaultTtl: 2s
              signedRequestMode: DISABLED

Wir behalten alle Standardeinstellungen für die Konfiguration des Edge-Cache-Dienstes bei. In der Datei oben gibt es drei Feldwerte, die Nutzer möglicherweise aktualisieren möchten:

• name: Der Name der Media CDN-Instanz, hier: cme-demo
• hosts: die Liste der Domainnamen, die von diesem Media CDN-Dienst aufgelöst werden – hier: demo.cme.com. Wir werden sie in dieser Demo verwenden. Wir verwenden die IP-Adresse der Media CDN-Instanz.
• Origin: – Dies ist der Edge-Cache-Ursprung, den wir gerade im vorherigen Schritt erstellt haben. Legen Sie den Wert auf cme-origin fest – Name des Media CDN-Ursprungs.

Hinweis:Zu Beginn einer Streaming-Sitzung lädt der Client zuerst die m3u8-Datei herunter. Die m3u8-Datei enthält Informationen zu den Videosegmentdateien (.ts-Dateien). Die m3u8-Datei wird für den Livestreaming-Anwendungsfall häufig aktualisiert, da transkodierte Dateien kontinuierlich in den Speicher-Bucket hochgeladen werden. Damit der Livestream richtig funktioniert, soll Media CDN die m3u8-Datei nur für kurze Zeit im Cache speichern.

In der obigen Konfigurationsdatei haben wir eine separate Routenregel für die .m3u8-Datei erstellt und die TTL auf 1 Sekunde festgelegt.

Weitere Informationen zu den verschiedenen Variablen, die Sie in der YAML-Datei verwenden können, finden Sie im Konfigurationsleitfaden für den Edge Cache Service.

Edge-Cache-Dienst erstellen

Wir erstellen einen Edge-Cache-Dienst mit dem Namen cme-demo für den Edge-Cache-Ursprung cme-origin mit dem Host demo.cme.com. Führen Sie den folgenden Befehl in Cloud Shell aus, um den Dienst zu erstellen:

Hinweis:Es kann bis zu 10 Minuten dauern, bis Media CDN den Dienst erstellt hat.

Befehl

gcloud edge-cache services import cme-demo \
    --source=cme-demo.yaml

Es kann einige Minuten dauern, bis der Edge Cache Service erstellt ist.

Beispielausgabe

Request issued for: [cme-demo]
Waiting for operation [projects/PROJECT_ID/locations/global/operations/operation-1670476252264-5ef4a0f9f36ce-dd380af5-321be9a0] to complete...done.     
createTime: '2022-12-07T18:08:54.403446942Z'
ipv4Addresses:
- 34.104.35.152
ipv6Addresses:
- '2600:1900:4110:d18::'
name: projects/PROJECT_ID/locations/global/edgeCacheServices/cme-demo
routing:
  hostRules:
  - hosts:
    - demo.cme.com
    - 34.104.35.152
    pathMatcher: routes
  pathMatchers:
  - name: routes
    routeRules:
    - headerAction:
        responseHeadersToAdd:
        - headerName: x-cache-status
          headerValue: '{cdn_cache_status}'
      matchRules:
      - prefixMatch: /
      origin: projects/123456789/locations/global/edgeCacheOrigins/cme-origin
      priority: '100'
      routeAction:
        cdnPolicy:
          cacheKeyPolicy: {}
          cacheMode: FORCE_CACHE_ALL
          defaultTtl: 3600s
          signedRequestMode: DISABLED
    - headerAction:
        responseHeadersToAdd:
        - headerName: x-cache-status
          headerValue: '{cdn_cache_status}'
      matchRules:
      - pathTemplateMatch: /**.m3u8
      origin: projects/123456789/locations/global/edgeCacheOrigins/cme-origin
      priority: '25'
      routeAction:
        cdnPolicy:
          cacheKeyPolicy: {}
          cacheMode: FORCE_CACHE_ALL
          defaultTtl: 1s
          signedRequestMode: DISABLED
    - headerAction: {}
      matchRules:
      - pathTemplateMatch: /**.ts
      origin: projects/123456789/locations/global/edgeCacheOrigins/cme-origin
      priority: '50'
      routeAction:
        cdnPolicy:
          cacheKeyPolicy: {}
          cacheMode: FORCE_CACHE_ALL
          defaultTtl: 2s
          signedRequestMode: DISABLED
updateTime: '2022-12-08T05:11:31.598744308Z'

Notieren und kopieren Sie die ipv4Addresses der Edge-Cache-Dienstinstanz – hier 34.104.36.157. Wir verwenden sie, um die Datei cme-demo.yaml zu aktualisieren und später das transcodierte Video zu streamen.

Edge-Cache-Dienst aktualisieren

An dieser Stelle ist es sinnvoll, die Edge-Cache-Dienstkonfiguration zu aktualisieren, damit Sie die IP-Adresse des Dienstes später zum Streamen des Videos verwenden können. In der YAML-Datei für den Edge-Cache-Dienst können wir alle Hostnamen/IPs auflisten, von denen der Edge-Cache-Dienst Anfragen akzeptiert. Bisher haben wir nur demo.cme.com als Host angegeben. Um die Namensauflösung für diese Domain zu ermöglichen, können Sie eine DNS-Zone konfigurieren. Eine einfachere Lösung wäre jedoch, die IP-Adresse der Hostliste in der yaml-Datei hinzuzufügen. Bearbeiten Sie die YAML-Datei noch einmal, sodass sie wie unten aussieht:

Hinweis:Ersetzen Sie unter hosts IPADDRESS durch ipv4Addresses aus der vorherigen Ausgabe.

name: cme-demo
routing:
  hostRules:
    - hosts:
        - demo.cme.com
        - IPADDRESS
      pathMatcher: routes
  pathMatchers:
    - name: routes
      routeRules:
        - headerAction:
            responseHeadersToAdd:
              - headerName: x-cache-status
                headerValue: "{cdn_cache_status}"
          matchRules:
            - prefixMatch: /
          origin: cme-origin
          priority: 100
          routeAction:
            cdnPolicy:
              cacheKeyPolicy: {}
              cacheMode: FORCE_CACHE_ALL
              defaultTtl: 3600s
              signedRequestMode: DISABLED
        - headerAction:
            responseHeadersToAdd:
              - headerName: x-cache-status
                headerValue: "{cdn_cache_status}"
          matchRules:
            - pathTemplateMatch: /**.m3u8
          origin: cme-origin
          priority: 25
          routeAction:
            cdnPolicy:
              cacheKeyPolicy: {}
              cacheMode: FORCE_CACHE_ALL
              defaultTtl: 1s
              signedRequestMode: DISABLED
        - headerAction: {}
          matchRules:
            - pathTemplateMatch: /**.ts
          origin: cme-origin
          priority: 50
          routeAction:
            cdnPolicy:
              cacheKeyPolicy: {}
              cacheMode: FORCE_CACHE_ALL
              defaultTtl: 2s
              signedRequestMode: DISABLED

Damit die Änderungen übernommen werden, müssen wir die YAML-Datei noch einmal importieren. Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus:

Befehl

gcloud edge-cache services import cme-demo \
    --source=cme-demo.yaml

Prüfen Sie die Ausgabe des Befehls und vergewissern Sie sich, dass die IP-Adresse in der Liste der Hosts angezeigt wird.

An diesem Punkt akzeptiert die Edge-Cache-Dienstinstanz Anfragen mit "demo.cme.com" oder der IP-Adresse als Host.

12. Eingabesignal generieren

Nachdem wir alle erforderlichen Dienste konfiguriert haben, können wir das Livestream-Eingabesignal generieren. In diesem Abschnitt gehen wir so vor:

1. FFmpeg installieren, eine kostenlose Open-Source-Software
2. Test-Livesignal an den Eingang/Kanal senden

1. FFmpeg installieren

FFmpeg ist ein kostenloses Open-Source-Softwareprojekt, das aus einer Reihe von Bibliotheken und Programmen für die Verarbeitung von Video-, Audio- und anderen Multimedia-Dateien und ‑Streams besteht. Verwenden Sie im Cloud Shell-Terminal den folgenden Befehl, um FFmpeg zu installieren:

Befehl

sudo apt install ffmpeg -y

Prüfen Sie nach der Installation, ob FFmpeg richtig installiert wurde, indem Sie die Version prüfen:

Hinweis:Mit dem oben genannten Befehl wird FFmpeg nur für den Lebenszyklus der Cloud Shell-Instanz installiert. Wenn der Nutzer die Cloud Shell-Instanz beendet oder eine neue Cloud Shell öffnet, muss er FFmpeg. neu installieren.

Befehl

ffmpeg -version

Beispielausgabe

ffmpeg version 4.3.4-0+deb11u1 Copyright (c) 2000-2021 the FFmpeg developers
built with gcc 10 (Debian 10.2.1-6)
...

FFmpeg wurde richtig installiert.

2. Livestream-Signal an den Eingang/Kanal senden

Nachdem FFmpeg installiert wurde, senden wir einen Testeingabestream an den Eingabeendpunkt, um den Livestream zu generieren.

Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus. Verwenden Sie dabei die URI-Umgebungsvariable, die wir im Abschnitt „Eingabeendpunkt erstellen und konfigurieren“ erstellt haben.

Befehl

ffmpeg -re -f lavfi -i "testsrc=size=1280x720 [out0]; sine=frequency=500 [out1]" \
  -acodec aac -vcodec h264 -f flv $URI

Sie sollten sehen, dass FFmpeg das Live-Testsignal sendet. Der Befehl gibt den Prompt nicht zurück. Das Signal wird so lange generiert, bis Sie es beenden. Für den Rest des Labs müssen Sie ein neues Cloud Shell-Fenster öffnen.

13. Neue Cloud Shell öffnen

Importieren:Überspringen Sie diesen Schritt nicht. Wir benötigen eine neue Cloud Shell, um das Lab abzuschließen

An diesem Punkt müssen Sie ein neues Cloud Shell-Fenster öffnen, um das Lab fortzusetzen, da FFmpeg dauerhaft ausgeführt wird, bis Sie den Befehl mit <STRG+C> beenden und so die Generierung des Live-Signals stoppen.

Klicken Sie neben dem Namen des aktuellen Cloud Shell-Terminals auf das Pluszeichen (+). Dadurch wird ein zusätzliches Cloud Shell-Fenster geöffnet.

Führen Sie den Rest des Labs im neu geöffneten Cloud Shell-Fenster aus.

Umgebungsvariablen einrichten

Da es sich um eine neue Cloud Shell-Sitzung handelt, müssen wir die Umgebungsvariablen noch einmal festlegen. Wir verwenden den Befehl source, um die Umgebungsvariablen festzulegen.

Befehl

source ~/env_variables.txt

Hinweis:Mit dem oben genannten Befehl werden die Umgebungsvariablen nur für den Lebenszyklus der Cloud Shell-Instanz festgelegt. Wenn der Nutzer die Cloud Shell-Instanz beendet oder eine neue Cloud Shell öffnet, muss er den Befehl source noch einmal ausführen.

Prüfen, ob die Variablen festgelegt sind

Prüfen wir, ob alle erforderlichen Umgebungsvariablen festgelegt sind. In der Ausgabe sollten insgesamt sechs Umgebungsvariablen angezeigt werden.

Befehl

env | grep -E 'DEVSHELL_PROJECT_ID=|LOGNAME|PROJECT_NUMBER|LOCATION|INPUT_ID|CHANNEL_ID'

Beispielausgabe

LOCATION=us-west2
DEVSHELL_PROJECT_ID=<YOUR_PROJECT_ID>
LOGNAME=<YOUR_USERNAME>
PROJECT_NUMBER=<YOUR_PROJECT_NUMBER>
INPUT_ID=lab-live-input
CHANNEL_ID=lab-live-channel

14. Prüfen, ob das Livesignal transcodiert wird

Wir führen einen curl aus, um den Kanal zu beschreiben. In der Ausgabe sollte zu sehen sein, dass sich der streamingState von "AWAITING_INPUT" in "STREAMING" geändert hat.

Befehl

curl -s -X GET -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) "https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/channels/$CHANNEL_ID" | grep "streamingState"

In der JSON-Datei für die Ausgabe sollte "streamingState": "STREAMING" angezeigt werden. Das bedeutet, dass der Kanal streamt und das Live-Signal transcodiert wird.

Sehen wir uns auch den Inhalt des Buckets an. Dort sollten wir eine Manifestdatei und mehrere TS-Videosegmente sehen. Führen Sie den folgenden Befehl in Cloud Shell aus, um den Inhalt des Buckets aufzulisten, den wir am Anfang des Labs erstellt haben und der von der Live Streaming API verwendet wird, um das Manifest des transcodierten Live-Signals und die TS-Videosegmente auszugeben:

Befehl

gcloud storage ls --recursive gs://live-streaming-storage-$LOGNAME/**

Beispielausgabe

gs://live-streaming-storage-$LOGNAME/
gs://live-streaming-storage-$LOGNAME/main.m3u8
gs://live-streaming-storage-$LOGNAME/mux_video_ts/index-1.m3u8
gs://live-streaming-storage-$LOGNAME/mux_video_ts/segment-0000000016.ts
gs://live-streaming-storage-$LOGNAME/mux_video_ts/segment-0000000017.ts
gs://live-streaming-storage-$LOGNAME/mux_video_ts/segment-0000000018.ts
gs://live-streaming-storage-$LOGNAME/mux_video_ts/segment-0000000019.ts
gs://live-streaming-storage-$LOGNAME/mux_video_ts/segment-0000000020.ts
gs://live-streaming-storage-$LOGNAME/mux_video_ts/segment-0000000021.ts
gs://live-streaming-storage-$LOGNAME/mux_video_ts/segment-0000000022.ts
...

Hier sollten Sie dies sehen:

• die HLS-Manifestdatei: main.m3u8
• Die entsprechenden TS-Videosegmente: eine Reihe nummerierter Dateien segment-000000000X.ts

An dieser Stelle haben wir Folgendes erledigt:

• Live Streaming API: Das Live-Signal wird über die Live Streaming API generiert und in einen Bucket transcodiert.
• Media CDN: Media CDN wurde mit dem Live-Streaming-Speicher-Bucket als Ursprung von Media CDN konfiguriert.

In den nächsten Abschnitten validieren wir den Edge Cache Service und streamen dann das transkodierte Video über die Anycast-IP-Adresse von Media CDN.

15. Prüfen, ob die Edge-Cache-Dienstinstanz funktioniert

In diesem Abschnitt prüfen wir, ob die Edge Cache Service-Instanz wie erwartet funktioniert. Dazu versuchen wir, über die IP-Adresse des Edge-Cache-Dienstes auf eine Datei in der Edge-Cache-Dienst-Instanz zuzugreifen. Wenn zum ersten Mal auf ein Objekt zugegriffen wird, ist es noch nicht im Cache. Wir sollten einen Cache MISS beobachten. Bei der ersten Anfrage wird das Objekt vom Ursprung gelesen und am Edge-Standort im Cache gespeichert. Alle nachfolgenden Versuche, auf dieselbe Datei zuzugreifen, geben einen Cache-HIT zurück, da das Objekt jetzt am Edge im Cache gespeichert ist. So können Sie dieses Verhalten überprüfen:

Führen Sie den folgenden curl-Befehl in Cloud Shell aus, um auf die Manifestdatei des transcodierten Videos zuzugreifen, die im Edge Cache-Ursprung gespeichert ist:

Befehl

curl -svo /dev/null --resolve demo.cme.com:80:<Replace_With_Edge_Cache_IP> \
"http://demo.cme.com/main.m3u8"

Beachten Sie die Auflösung, bei der wir die IP-Adresse der Edge Cache Service-Instanz verwenden, um ihren Namen aufzulösen. Verwenden Sie demo.cme.com:<IP>, wobei „IP“ die IP-Adresse der Edge-Cache-Dienstinstanz ist, die wir gerade erstellt haben.

Suchen Sie in der Ausgabe nach der Überschrift x-cache-status.

Beispielausgabe

Added demo.cme.com:80:34.104.35.152 to DNS cache
* Hostname demo.cme.com was found in DNS cache
*   Trying 34.104.35.152:80...
* Connected to demo.cme.com (34.104.35.152) port 80 (#0)
> GET /main.m3u8 HTTP/1.1
> Host: demo.cme.com
> User-Agent: curl/7.74.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< x-guploader-uploadid: ADPycdtKtflWt4Kha5YxXNNRwO-Eu6fGSPs-T-XY4HJmNMo46VJyWlD4EAk-8a6SegxjWq3o1gTPqZbpkU_sjW__HPAdDw
< date: Wed, 07 Dec 2022 18:23:46 GMT
< last-modified: Wed, 07 Dec 2022 18:23:45 GMT
< etag: "6bff620ccca4a9849ba4e17fa7c521fb"
< x-goog-generation: 1670437425805400
< x-goog-metageneration: 1
< x-goog-stored-content-encoding: identity
< x-goog-stored-content-length: 193
< content-type: application/x-mpegURL
< x-goog-hash: crc32c=sPO3zw==
< x-goog-hash: md5=a/9iDMykqYSbpOF/p8Uh+w==
< x-goog-storage-class: STANDARD
< accept-ranges: bytes
< content-length: 193
< server: Google-Edge-Cache
< x-request-id: fd25285b-fc1a-4fd4-981a-c50ead2c85ed
< x-xss-protection: 0
< x-frame-options: SAMEORIGIN
< x-cache-status: den;miss
< cache-control: public,max-age=3600
<
{ [193 bytes data]
* Connection #0 to host demo.cme.com left intact

Beachten Sie den Cache-Fehler, da das Objekt noch nicht im Cache gespeichert ist und vom Ursprung gelesen wird.

Wir senden jetzt mehrere Anfragen für die Datei m3u8. Wenn alles richtig konfiguriert ist, sollte Media CDN die Inhalte aus dem Cache bereitstellen. Mit dem folgenden Befehl werden 10 curl-Anfragen gestellt und nur der x-cache-status-Header wird ausgegeben.

Befehl

for i in {1..10};do curl -Is --resolve demo.cme.com:80:<Replace_With_Edge_Cache_IP> "http://demo.cme.com/main.m3u8" | grep x-cache-status;done

Die Ausgabe sollte eine Mischung aus Cache hit und miss sein. Wenn in der Ausgabe Cache-Treffer angezeigt werden, funktioniert Media CDN wie erwartet.

Beispielausgabe

x-cache-status: den;miss
x-cache-status: den;hit
x-cache-status: den;hit
x-cache-status: den;hit
x-cache-status: den;hit
x-cache-status: den;hit
x-cache-status: den;hit
x-cache-status: den;hit
x-cache-status: den;hit
x-cache-status: den;hit

Beachten Sie den Cache-Treffer, da das Objekt jetzt am Edge-Standort zwischengespeichert wird. Der Cloud Media Edge Service funktioniert wie erwartet.

16. Transcodiertes Live-Videosignal mit VLC streamen

In diesem Abschnitt werden die einzelnen Schritte, an denen wir bisher gearbeitet haben, miteinander verknüpft:

• Wir haben einen Bucket namens live-streaming-storage-$LOGNAME erstellt, in dem das Ergebnis des Live-Signals empfangen wird, das von der Live Streaming API in HLS-Inhalte transcodiert wurde.
• Wir haben die Live Streaming API eingerichtet.
• Wir haben ein RTMP-Livesignal mit FFmpeg gestartet, das den Eingabe-/Kanal der Live Streaming API speist.
• Wir haben überprüft, ob das Live-Signal an den Kanal gesendet wurde und ob sich der Kanal im streaming-Modus befand.
• Wir haben überprüft, ob die resultierenden transcodierten Dateien (Manifest + TS-Segmente) generiert und im Bucket live-streaming-storage-$LOGNAME gespeichert wurden.
• Ein Edge-Cache-Ursprung namens cme-origin wurde mit dem GCS-Bucket live-streaming-storage-$LOGNAME als Ursprung eingerichtet.
• Eine Edge-Cache-Instanz mit dem Namen cme-demo wurde mit cme-origin als Ursprung eingerichtet.
• Wir haben das Verhalten (Cache-Fehler, Cache-Treffer) der Edge-Cache-Dienstinstanz überprüft.

Wir sind jetzt an einem Punkt, an dem wir einen Videoplayer verwenden können, um das transcodierte Live-Signal über den Media CDN-Cache zu streamen. Dazu verwenden wir den VLC Player. Der VLC Player ist ein kostenloser, plattformübergreifender Open-Source-Multimediaplayer und ein Framework, das die meisten Multimediadateien abspielen kann. Es werden adaptive Medienformate wie DASH und HLS unterstützt. Dabei wird das Prinzip des adaptiven Streamings verwendet: Je nach Qualität Ihrer Netzwerkverbindung und verfügbarer Bandbreite passt der Player die Qualität des wiedergegebenen Videos an. Beim Transcodierungsjob haben wir die Standardvoreinstellungen verwendet und „nur“ zwei Qualitäten generiert: SD und HD. Wenn wir das Video im Player abspielen, sollte es zuerst im SD-Format wiedergegeben werden und dann schnell zum HD-Format wechseln, sofern deine Netzwerkverbindung gut genug ist.

Wir streamen das transcodierte Live-Signal im HLS-Format (weit verbreitetes Apple-Videoformat). Die entsprechende Datei heißt main.m3u8. Das ist das HLS-Manifest. Das Manifest verweist auf die TS-Videosegmente.

Wenn Sie den VLC Player verwenden möchten, rufen Sie https://www.videolan.org/vlc/ auf und laden Sie eine Version des Players für das Betriebssystem Ihres Laptops herunter. VLC ist für Windows, MacOSX, Linux, Android und iOS verfügbar.

Installieren Sie den Player auf Ihrem Laptop und starten Sie ihn. In den nächsten Schritten verwenden wir die MacOSX-Version des Players.

Um ein Video abzuspielen, gehen Sie zu „Datei“ / „Netzwerk öffnen“:

Einrichten mit:

• URL: http://<Replace_With_Edge_Cache_IP>/main.m3u8. Das ist die URL des Videos, das wir streamen möchten. Hinweis:
• Die IP-Adresse der Media CDN-Instanz: 34.105.35.246. Ersetzen Sie diese durch die IP-Adresse des bereitgestellten Cloud Media Service.
• Der Pfad zur Manifest-Videodatei: „/“. Dies ist der Pfad, den wir im Bucket live-streaming-storage-$LOGNAME zum Speichern der transcodierten Live-Signaldaten verwendet haben. Der Pfad ist hier der Root-Pfad: „/“.
• Der Name der Manifest-Videodatei: die HLS-Manifestdatei main.m3u8.

Klicken Sie auf „Öffnen“. Das transkodierte Livevideo sollte jetzt wiedergegeben werden. Das Video sollte so aussehen wie im Screenshot unten. Der Zähler auf dem Bildschirm wird in Schritten von 1 hochgezählt und Sie sollten einen kontinuierlichen Piepton hören.

Es handelt sich um ein einfaches RTMP-Test-Livesignal, das von FFmpeg generiert, von der Live Streaming API in HLS transcodiert und über den Media CDN-Cache bereitgestellt wird:

Sie können auch einen anderen HLS- und MPEG-DASH-Player verwenden. Hier sind einige Beispiele:

• QuickTime Player – standardmäßig auf Macs installiert. Öffnen Sie auch hier eine Netzwerkverbindung zu http://34.104.36.157/main.m3u8. Ersetzen Sie die IP-Adresse durch die Ihrer Edge Cache Service-Instanz.

17. Media CDN überwachen

Das SME-Team hat eine Media CDN-Dashboardvorlage erstellt: https://gist.github.com/elithrar/1c511d00f5cd3736fb2a3897867209c1.

Führen Sie die folgenden Befehle im Cloud Shell-Fenster aus, um es zu installieren:

Laden Sie die YAML-Datei herunter:

curl https://gist.githubusercontent.com/elithrar/1c511d00f5cd3736fb2a3897867209c1/raw/3cb70855304f29e5c06b8d63063196354db0dec3/media-edge-20210208-dashboard --output media-edge-20210208-dashboard.yaml

Dashboard für Cloud Monitoring erstellen:

gcloud monitoring dashboards create --config-from-file media-edge-20210208-dashboard.yaml

Die Einrichtung kann einige Minuten dauern. Rufen Sie die Google Cloud Console auf und klicken Sie auf die drei Balken > „Operations“ > „Monitoring“ > „Dashboards“. Sie sollten ein Dashboard mit dem Namen „Media Edge Metrics“ sehen. Klicken Sie darauf, um die Messwerte aufzurufen:

18. Lab-Umgebung bereinigen

Sie haben das Lab erfolgreich abgeschlossen. In diesem Abschnitt löschen wir alle Ressourcen, die wir im Laufe des Labs erstellt haben.

FFmpeg-Signal beenden:

Drücken Sie im Cloud Shell-Terminal, in dem FFmpeg ausgeführt wird, die Tastenkombination <CTRL+C>.

So beenden Sie den Livestreaming-Kanal:

Befehl

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d "" \
"https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/channels/$CHANNEL_ID:stop"

So löschen Sie den Livestreaming-Kanal:

Befehl

curl -X DELETE -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) "https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/channels/$CHANNEL_ID"

Löschen Sie den Livestreaming-Eingabeendpunkt:

Befehl

curl -X DELETE \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
"https://livestream.googleapis.com/v1/projects/$PROJECT_NUMBER/locations/$LOCATION/inputs/$INPUT_ID"

GCS-Bucket löschen:

Befehl

gsutil rm -r gs://live-streaming-storage-$LOGNAME

Edge-Cache-Dienstinstanz löschen:

Befehl

gcloud edge-cache services delete cme-demo

Bestätigen Sie das Löschen, indem Sie „Y“ eingeben, wenn Sie dazu aufgefordert werden.

Edge-Cache-Ursprung löschen:

Befehl

gcloud edge-cache origins delete cme-origin

Bestätigen Sie das Löschen, indem Sie „Y“ eingeben, wenn Sie dazu aufgefordert werden.

Benutzerdefiniertes Dashboard löschen

Befehl

gcloud monitoring dashboards delete $(gcloud monitoring dashboards list --filter="displayName:Media Edge Metrics" --format="value(name)")