Diese Seite wurde von der Cloud Translation API übersetzt.

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

1. Einführung

Content Delivery Networks (CDNs) verbessern die Nutzerleistung, indem häufig aufgerufene Inhalte näher an den Endnutzern im Cache gespeichert werden, Verbindungen näher an den Clients beendet werden, Verbindungen zum Ursprung wiederverwendet und moderne Netzwerkprotokolle und -anpassungen verwendet werden. Für Nutzer (und unsere Kunden) bedeutet dies geringere Latenz, mehr Zuverlässigkeit und geringere Kosten – was zu besseren Umsätzen, einer besseren Nutzererfahrung auf der Website und einer Nettozunahme der Nutzererfahrung führt. Nur sehr wenige moderne Websites und Videostreaming-Plattformen arbeiten heute ohne CDN.

Lerninhalte

In diesem Lab erfahren Sie, wie Sie eine Livestreaming-Workflowumgebung mit Media CDN (CDN) + Cloud Media Live Streaming API (Livevideotranscodierung) + Cloud Storage (Speicher für die Videos) + Video Player (VLC, Google Shaka Player usw. – HLS- und MPEG-DASH-fähiger Player) bereitstellen.

Wir richten die Komponenten der Live Streaming API (Eingabe und Kanal) ein und starten mit FFmpeg einen Live-Feed für den Eingabe-/Kanal (mit FFmpeg kann ein Live-Testsignal generiert werden). 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 für die Wiedergabe von Live-Inhalten eingesetzt, die über Media CDN im Cache gespeichert wurden. Außerdem richten wir ein Cloud Monitoring-Dashboard ein, um die Aktivitäten von Media CDN zu visualisieren.

Inhalt

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

Im Rahmen dieses Labs richten Sie die folgenden Komponenten ein und führen die folgenden Aufgaben aus:

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

Hinweis: Für dieses Lab gehen wir davon aus, dass Nutzer Zugriff auf die Google Cloud Console haben und bereits ein Projekt eingerichtet haben. Außerdem gehen wir davon aus, dass Nutzer mit einer neuen Umgebung beginnen und nichts für diese Demo eingerichtet haben.

Alle Konfigurationsaktionen werden über die Befehlszeile in Cloud Shell ausgeführt. Wir können die über die Befehlszeile in der Konsole konfigurierten Komponenten jederzeit überprüfen. In diesem Lab sehen Sie immer wieder Hinweise, die auf die Google Cloud Console verweisen.

2. Hinweis

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

3. Einrichtung und Anforderungen

Cloud Shell starten

Sie können Google Cloud zwar von Ihrem Laptop aus der Ferne bedienen, in diesem Codelab verwenden Sie jedoch Google Cloud Shell, 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 dauert nur einen Moment. Wenn er abgeschlossen ist, sollten Sie in etwa Folgendes sehen:

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

4. Google Cloud SDK-Version

Beim Verfassen dieses Artikels ist 408.0.0 die neueste Version des Google Cloud SDK. Alle Befehle in diesem Lab wurden mit der neuesten Version des Google Cloud SDK getestet. Achten Sie darauf, dass Cloud Shell die neueste SDK-Version verwendet, 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"

Ausgabebeispiel

Google Cloud SDK 408.0.0

Nächste Schritte

Wenn die SDK-Version 408.0.0 oder höher ist, fahren Sie mit dem nächsten Abschnitt fort.
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 Sie mit der Konfiguration der GCP-Ressourcen beginnen, müssen Sie Folgendes tun:

Umgebungsvariablen einrichten
Erforderliche Dienst-APIs aktivieren

1. Umgebungsvariablen einrichten

In diesem Lab führen wir die Befehle gcloud und curl 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 der Regel in Cloud Shell vorkonfiguriert. Zur Bestätigung verwenden wir den Befehl env.

Befehl

env | grep -E 'DEVSHELL_PROJECT_ID=|LOGNAME'

Ausgabebeispiel

DEVSHELL_PROJECT_ID=<YOUR_PROJECT_ID>
LOGNAME=<YOUR_USERNAME>

Datei `env_variables` 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.

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

Befehl

source ~/env_variables.txt

Überprüfen, ob die Variablen festgelegt sind

Nun prüfen wir, ob alle erforderlichen Umgebungsvariablen festgelegt sind. Die Ausgabe sollte insgesamt sechs Umgebungsvariablen enthalten.

Befehl

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

Ausgabebeispiel

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 sicherstellen, 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ühre 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. Die Ausgabe sollte 4 APIs enthalten.

Befehl

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

Ausgabebeispiel

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

6. Cloud Storage-Bucket erstellen

In diesem Abschnitt werden wir Folgendes tun:

Cloud Storage-Bucket erstellen
Bucket öffentlich zugänglich machen

Später im Lab werden wir diesen Bucket zum Speichern der transcodierten Videodateien verwenden. 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

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. Live Streaming API-Umgebung einrichten

Die Komponenten der Live Streaming API-Kette sind wie folgt aufgebaut:

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

Live Streaming Input: Der Eingabeendpunkt ist ein Endpunkt, an den dein Encoder deinen Eingabestream sendet. Mit dem Eingabeendpunkt kannst du Konfigurationen für deinen Stream festlegen, z. B. die Eingabeauflösung, den Eingabetyp und das Zuschneiden des Videos.
Livestreaming-Kanal:Ein Kanal ist eine Ressource, die den Eingabestream über einen Eingabeendpunkt aufnimmt, ihn in mehrere Wiedergaben transcodiert und Ausgabe-Livestreams in bestimmten Formaten am angegebenen Ort veröffentlicht. Du kannst einen primären und einen Backup-Eingabestream in denselben Kanal aufnehmen.

Die folgenden Ressourcen werden später im Lab erstellt:

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 Signaltyp des Livestreams anzugeben. In diesem Lab verwenden wir das RTMP-Live-Signal.

Befehl

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

Eingabeendpunkt erstellen

Zum Zeitpunkt der Erstellung dieses Labs gibt es keine gcloud-Unterstützung für die Live Stream API. Wir verwenden den Befehl curl für die API-Aufrufe.

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"

Ausgabebeispiel

{
  "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 aus der Ausgabe die Vorgangs-ID und notieren Sie sie. Unten sehen Sie die Vorgangs-ID aus dem Ausgabebeispiel. Sie finden sie in der Ausgabezeile, 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.

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

Befehl

export OPERATION_ID_1=<OPERATION>

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"

Ausgabebeispiel

{
  "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. Dies bedeutet, dass der Eingabeendpunkt erstellt wurde und bereit ist.

URI speichern

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

Befehl

export URI=<uri>

Ersetzen Sie <uri> durch den oben genannten URI. 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. Erstellen und Livestream-Kanal konfigurieren

Erstellen wir nun den Live-Streaming-Kanal, der mit dem Eingabeendpunkt verknüpft ist, den wir im vorherigen Abschnitt erstellt haben. Im folgenden Beispiel wird ein Kanal erstellt, der einen HLS-Livestream generiert, der aus einer einzelnen HD-Wiedergabe (1280 x 720) besteht. 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 Kanal 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"

Ausgabebeispiel

{
  "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 Ausgabezeile, die mit "name" beginnt.

Status prüfen

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

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

Befehl

export OPERATION_ID_2=<OPERATION>

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"

Ausgabebeispiel

  "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. Dies bedeutet, dass der Eingabeendpunkt erstellt wurde und bereit ist.

Beachten Sie, dass "streamingState" derzeit "STOPPED" ist. Wir starten den Kanal im nächsten Abschnitt.

10. Den Livestream-Kanal starten

Nachdem wir nun den Livestream-Kanal erstellt haben, kann er gestartet werden. In diesem Abschnitt werden wir Folgendes tun:

Den Livestream-Kanal starten
Überprüfe den Status des Kanals. Wir müssen sicherstellen, dass streamingState "AWAITING INPUT" lautet.

1. Den 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"

Ausgabebeispiel

{
  "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
}

2. Status des Kanals prüfen

Führen Sie den folgenden curl-Befehl aus, um den Status des Kanals 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/channels/$CHANNEL_ID" | grep "streamingState"

Ausgabebeispiel

"streamingState": "AWAITING_INPUT",

Führen Sie den Befehl so lange aus, bis Sie „AWAITING_INPUT“ sehen gibt an, dass der Kanal 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:

Edge-Cache-Ursprung
Edge-Cache-Dienst

1. Edge-Cache-Ursprung erstellen

Ein Edge-Cache-Ursprung steht für einen Inhaltsspeicherort, z. B. einen Cloud Storage-Bucket, den Speicherort eines Drittanbieters oder einen Load-Balancer. In Bezug auf CDN ist der Ursprung (oder Ursprungsserver) der Ort, an dem sich die Quelle des Contents befindet, den wir verteilen möchten, z.B. Alle CSS-, JavaScript-, HTML- und Bildelemente usw. In diesem Lab erstellen wir einen Ursprung, der dem Cloud Storage-Bucket zugeordnet ist, den wir zu Beginn des Labs erstellt haben. Wir nennen den Edge-Cache-Ursprung cme-origin. Der Ursprung eines CDN ist der Ort, an dem der gesamte Quellinhalt gespeichert wird, bevor er an die Edge-Cache-Server verteilt wird.

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

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 Sie den Edge-Cache-Ursprung eingerichtet haben, können Sie den Edge-Cache-Dienst selbst erstellen.

Datei `cme-demo.yaml` erstellen

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

Alle Konfigurationsstandards für den Edge-Cache-Dienst werden beibehalten. 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: ist die Liste der Domainnamen, die von diesem Media CDN-Dienst aufgelöst werden. Hier finden Sie die Liste 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 dafür cme-origin fest: Name des Media CDN-Ursprungs.

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

Edge-Cache-Dienst erstellen

Wir erstellen einen Edge-Cache-Dienst namens cme-demo am 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:

Befehl

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

Das Erstellen des Edge-Cache-Dienstes kann einige Minuten dauern.

Ausgabebeispiel

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 Sie sich den ipv4Addresses der Edge Cache-Dienst-Instanz – hier 34.104.36.157. Wir verwenden ihn, um die Datei cme-demo.yaml zu aktualisieren und später das transcodierte Video zu streamen.

Edge-Cache-Dienst aktualisieren

An dieser Stelle empfiehlt es sich, die Konfiguration des Edge-Cache-Dienstes zu aktualisieren, damit Sie die IP-Adresse des Dienstes verwenden können, um das Video später zu streamen. Mit der YAML-Datei des Edge-Cache-Dienstes können Sie alle Hostsnamen/IP-Adressen auflisten, von denen der Edge-Cache-Dienst Anfragen akzeptiert. An dieser Stelle haben wir nur demo.cme.com als Host angegeben. Um eine Namensauflösung für diese Domain bereitzustellen, konfigurieren Sie in der Cloud eine DNS-Zone. Eine einfachere Lösung wäre jedoch, die IP-Adresse der Hostliste in der Datei yaml hinzuzufügen. Bearbeiten Sie die YAML-Datei noch einmal und bearbeiten Sie sie wie folgt:

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 nur 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

Sehen Sie in der Ausgabe des Befehls nach, ob die IP-Adresse in der Liste der Hosts angezeigt wird.

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

12. Eingabesignal generieren

Nachdem Sie alle erforderlichen Dienste konfiguriert haben, können Sie jetzt das Eingabesignal für den Livestream generieren. In diesem Abschnitt werden wir Folgendes tun:

Installation von FFmpeg, einer kostenlosen Open-Source-Software
Senden Sie ein Test-Live-Signal an den Eingang/Kanal

1. FFmpeg installieren

FFmpeg ist ein kostenloses Open-Source-Softwareprojekt, das aus einer Reihe von Bibliotheken und Programmen zur Verarbeitung von Video-, Audio- und anderen Multimediadateien und -streams besteht. Verwenden Sie den folgenden Befehl, um FFmpeg im Cloud Shell-Terminal zu installieren:

Befehl

sudo apt install ffmpeg -y

Wenn die Installation abgeschlossen ist, können Sie überprüfen, ob FFmpeg korrekt installiert wurde. Überprüfen Sie dazu die Version:

Befehl

ffmpeg -version

Ausgabebeispiel

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 ordnungsgemäß installiert.

2. Livestream-Signal zum Eingang/Kanal starten

Nachdem FFmpeg nun installiert ist, 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 Sie im Schritt „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

Du solltest sehen, dass FFmpeg das Test-Live-Signal sendet. Der Befehl gibt die Eingabeaufforderung nicht zurück. Das Signal wird 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

An dieser Stelle müssen Sie ein neues Cloud Shell-Fenster öffnen, um das Lab fortzusetzen, da FFmpeg dauerhaft ausgeführt wird, bis Sie <Strg+C> drücken. den Befehl, um ihn zu stoppen und somit die Generierung des Live-Signals zu stoppen.

Klicken Sie auf das „+“, neben dem Namen des aktuellen Cloud Shell-Terminals. Ein weiteres Cloud Shell-Fenster wird geöffnet.

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

Umgebungsvariablen einrichten

Da dies eine neue Cloud Shell ist, müssen wir die Umgebungsvariablen noch einmal festlegen. Wir verwenden den Befehl source, um die Umgebungsvariablen festzulegen.

Befehl

source ~/env_variables.txt

Überprüfen, ob die Variablen festgelegt sind

Nun prüfen wir, ob alle erforderlichen Umgebungsvariablen festgelegt sind. Die Ausgabe sollte insgesamt sechs Umgebungsvariablen enthalten.

Befehl

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

Ausgabebeispiel

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 Live-Signal transcodiert wird

Wir führen einen curl aus, um den Kanal zu beschreiben. In der Ausgabe sollte angezeigt werden, dass StreamingState von "AWAITING_INPUT" in "STREAMING" geändert wurde.

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 Antwort der JSON-Ausgabedatei sollte "streamingState": "STREAMING" zu sehen sein. Dies bedeutet, dass der Kanal streamt und das Live-Signal transcodiert wird.

Überprüfen wir auch den Inhalt des Buckets, in dem eine Manifestdatei und mehrere TS-Videosegmente angezeigt werden sollten. Führen Sie in Cloud Shell den folgenden Befehl aus, um den Inhalt des Buckets aufzulisten, den wir zu Beginn des Labs erstellt und von der Live Streaming API zur Ausgabe des transcodierten Live-Signal-Manifests und der TS-Videosegmente verwendet haben:

Befehl

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

Ausgabebeispiel

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

Jetzt haben wir Folgendes erledigt:

Live Streaming API: Das Live-Signal wird generiert und über die Live Streaming API in einen Bucket transcodiert.
Media CDN: Media CDN mit dem Storage-Bucket für Livestreaming als Media CDN-Ursprung konfiguriert.

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

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

In diesem Abschnitt prüfen wir, ob die Edge-Cache-Dienstinstanz wie erwartet funktioniert. Dazu versuchen wir, über die IP-Adresse des Edge-Cache-Diensts auf eine Datei aus der Edge-Cache-Dienst-Instanz zuzugreifen. Wenn ein Objekt zum ersten Mal aufgerufen wird, wird es noch nicht im Cache gespeichert. Wir sollten einen Cache MISS beobachten. Bei der ersten Anfrage wird das Objekt aus dem Ursprung gelesen und am Netzwerkrand im Cache gespeichert. Bei allen folgenden Versuchen, auf dieselbe Datei zuzugreifen, wird ein Cache-HIT zurückgegeben, da das Objekt jetzt am Netzwerkrand im Cache gespeichert wird. Überprüfen wir dieses Verhalten:

Führen Sie in Cloud Shell den folgenden curl-Befehl aus, um auf die transcodierte Videomanifestdatei 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-Dienstinstanz verwenden, um ihren Namen aufzulösen. Verwenden Sie demo.cme.com:<IP>, wobei die IP die IP-Adresse der soeben erstellten Edge-Cache-Dienstinstanz ist.

Suchen Sie in der Ausgabe nach dem Header x-cache-status.

Ausgabebeispiel

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 wurde und aus dem Ursprung gelesen wird.

Jetzt senden wir mehrere Anfragen für die Datei m3u8. Wenn alles richtig konfiguriert ist, sollte Media CDN mit der Bereitstellung des Contents aus dem Cache beginnen. 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.

Ausgabebeispiel

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-hit, da das Objekt jetzt am Rand zwischengespeichert wird. Der Cloud Medie Edge-Dienst funktioniert wie erwartet.

16. Transcodiertes Live-Signal-Video mit VLC streamen

In diesem Teil verbinden wir die Punkte und verknüpfen alle Schritte, an denen wir bisher gearbeitet haben:

Wir haben einen Bucket mit dem Namen live-streaming-storage-$LOGNAME erstellt, der das Ergebnis des Live-Signals empfängt, das von der Live Streaming API in HLS-Content transcodiert wurde.
Wir richten die Live Streaming API ein.
Wir haben ein RTMP-Live-Signal mit FFmpeg gestartet, das den Eingabe-/Kanal der Live Streaming API füttert.
Wir haben überprüft, dass das Live-Signal in den Kanal gespeist wurde, und festgestellt, dass sich der Kanal im streaming-Modus befindet.
Wir haben überprüft, ob die resultierenden transcodierten Dateien (Manifest und 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 namens cme-demo wurde mit cme-origin als Ursprung eingerichtet.
Wir haben das Verhalten (Cache-Fehler, Cache-Treffer) der Edge-Cache-Dienstinstanz überprüft.

Wir können jetzt mit einem Videoplayer das transcodierte Live-Signal über den Media CDN-Cache streamen. Dazu verwenden wir den VLC-Player. Der VLC Player ist ein kostenloser plattformübergreifender Open-Source-Multimediaplayer und -Framework, mit dem die meisten Multimediadateien wiedergegeben werden können. Es werden adaptive Medienformate wie DASH und HLS wiedergegeben. Dabei kommt das Prinzip des Adaptiven Streamings zum Einsatz: Je nach Qualität der Netzwerkverbindung und verfügbarer Bandbreite passt der Player die Qualität des Videos an. Mit dem Transcodierungsjob, den wir gerade ausgeführt haben, haben wir die Standardvoreinstellungen verwendet und „nur“ zwei Qualitäten generiert: SD und HD. Während wir mit der Wiedergabe des Videos im Player beginnen, sollte das Video im SD-Format abgespielt werden. Wenn deine Netzwerkverbindung ausreichend ist, wechselt es schnell zum HD-Format.

Wir streamen das im HLS-Format (weit von Apple unterstützte Videoformat) transcodierte Livesignal. Die entsprechende Datei heißt main.m3u8 – 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 Ihr Laptop-Betriebssystem herunter. VLC ist für Windows, MacOSX, Linux, Android und iOS verfügbar.

Installieren Sie den Player auf Ihrem Laptop und starten Sie ihn. Für die nächsten Schritte verwenden wir die MacOSX-Version des Players.

Wenn du ein Video abspielen möchtest, rufe „Datei“ auf / „Offenes Netzwerk“:

So kannst du die Funktion einrichten:

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

Klicken Sie auf „Öffnen“. Die Wiedergabe des transcodierten Live-Videos sollte beginnen. Das Video sieht aus wie im Screenshot unten. Der Zähler auf dem Bildschirm wird in Schritten von 1 ausgeführt und Sie sollten einen fortlaufenden Signalton hören.

Es handelt sich um ein grundlegendes 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, die Sie eventuell in Betracht ziehen:

Quicktime-Player – standardmäßig auf Macs installiert Dasselbe gilt: Stellen Sie eine Netzwerkverbindung zu http://34.104.36.157/main.m3u8 her. Ersetzen Sie die IP-Adresse durch die mit der Instanz des Edge-Cache-Dienstes.

17. Media CDN überwachen

Eine Media CDN-Dashboard-Vorlage wurde vom SME-Team erstellt: https://gist.github.com/elithrar/1c511d00f5cd3736fb2a3897867209c1.

Führen Sie im Cloud Shell-Fenster die folgenden Befehle 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

Erstellen Sie das Dashboard für Cloud Monitoring:

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 3 Balken > Operations-Suite > Monitoring > Dashboards Es sollte ein Dashboard namens „Media Edge Metrics“ angezeigt werden. Wenn Sie darauf klicken, werden die Messwerte angezeigt:

18. Lab-Umgebung bereinigen

Sie haben das Lab erfolgreich abgeschlossen. In diesem Abschnitt löschen wir alle Ressourcen, die wir in diesem Lab erstellt haben.

Halten Sie das FFmpeg-Signal an:

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

So beendest du 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öschst du den Live-Streaming-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 Eingabeendpunkt für das Livestreaming:

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"

Löschen Sie den GCS-Bucket:

Befehl

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

Löschen Sie die Edge-Cache-Dienstinstanz:

Befehl

gcloud edge-cache services delete cme-demo

Bestätigen Sie das Löschen durch Eingabe von „Y“ wenn Sie dazu aufgefordert werden

Löschen Sie den Edge-Cache-Ursprung:

Befehl

gcloud edge-cache origins delete cme-origin

Bestätigen Sie das Löschen durch Eingabe von „Y“ 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)")

Livestreaming in Google Cloud mit Media CDN und der Live Streaming API Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

1. Einführung

Lerninhalte

Inhalt

2. Hinweis

3. Einrichtung und Anforderungen

Cloud Shell starten

4. Google Cloud SDK-Version

SDK-Version prüfen

Nächste Schritte

5. Vorbereitung

1. Umgebungsvariablen einrichten

Projekt-ID und Nutzername

Datei env_variables erstellen

Umgebungsvariablen einrichten

Überprüfen, ob die Variablen festgelegt sind

2. Erforderliche Dienst-APIs aktivieren

Network Services API aktivieren

Certificate Manager API aktivieren

Live Stream API aktivieren

Media CDN Edge Cache API aktivieren

Prüfen, ob die APIs aktiviert sind

6. Cloud Storage-Bucket erstellen

1. Bucket erstellen

2. Bucket öffentlich zugänglich machen

7. Live Streaming API-Umgebung einrichten

8. Eingabeendpunkt erstellen und konfigurieren

Datei „input.json“ erstellen

Eingabeendpunkt erstellen

Status prüfen

URI speichern

9. Erstellen und Livestream-Kanal konfigurieren

Datei „channel.json“ erstellen

Kanal erstellen

Status prüfen

10. Den Livestream-Kanal starten

1. Den Kanal starten

2. Status des Kanals prüfen

11. Media CDN konfigurieren

1. Edge-Cache-Ursprung erstellen

2. Edge-Cache-Dienst erstellen

Datei cme-demo.yaml erstellen

Edge-Cache-Dienst erstellen

Edge-Cache-Dienst aktualisieren

12. Eingabesignal generieren

1. FFmpeg installieren

2. Livestream-Signal zum Eingang/Kanal starten

13. Neue Cloud Shell öffnen

Umgebungsvariablen einrichten

Überprüfen, ob die Variablen festgelegt sind

14. Prüfen, ob das Live-Signal transcodiert wird

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

16. Transcodiertes Live-Signal-Video mit VLC streamen

17. Media CDN überwachen

18. Lab-Umgebung bereinigen

Halten Sie das FFmpeg-Signal an:

So beendest du den Livestreaming-Kanal:

So löschst du den Live-Streaming-Kanal:

Löschen Sie den Eingabeendpunkt für das Livestreaming:

Löschen Sie den GCS-Bucket:

Löschen Sie die Edge-Cache-Dienstinstanz:

Löschen Sie den Edge-Cache-Ursprung:

Benutzerdefiniertes Dashboard löschen

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

Datei `env_variables` erstellen

Datei `cme-demo.yaml` erstellen