Cette page a été traduite par l'API Cloud Translation.

Diffusion en direct sur Google Cloud avec Media CDN et l'API Live Streaming

1. Introduction

Les réseaux de diffusion de contenu (CDN) améliorent les performances des utilisateurs en mettant en cache les contenus fréquemment consultés au plus près des utilisateurs finaux, en terminant les connexions au plus près des clients, en réutilisant les connexions à l'origine et en adoptant des protocoles et des personnalisations réseau modernes. Pour les utilisateurs (et nos clients), cela signifie une latence réduite, une fiabilité accrue et des coûts réduits, ce qui se traduit par une amélioration des ventes, de l'expérience Web et de l'expérience utilisateur. De nos jours, très peu de sites et de plates-formes de streaming vidéo modernes fonctionnent sans CDN.

Points abordés

Cet atelier vous guidera à travers les étapes de déploiement d'un environnement de workflow de streaming en direct avec Media CDN (CDN) + API Cloud Media Live Streaming (transcodage vidéo en direct) + Cloud Storage (stockage des vidéos) + Lecteur vidéo (VLC, Google Shaka Player, etc. – lecteur compatible HLS et MPEG-DASH).

Nous allons configurer les composants de l'API Live Streaming (entrée, canal) et démarrer un flux en direct vers l'entrée/le canal avec FFmpeg (FFmpeg peut générer un signal de test en direct). L'API Live Streaming transcode le flux en direct. Le fichier manifeste et les segments vidéo transcodés seront stockés dans un bucket Cloud Storage. Nous allons ensuite configurer Media CDN avec le bucket Cloud Storage de la vidéo en direct comme origine. Enfin, VLC Player sera utilisé pour lire les contenus en direct mis en cache via Media CDN. Nous allons également configurer un tableau de bord Cloud Monitoring pour visualiser l'activité de Media CDN.

Objectifs de l'atelier

Dans cet atelier, nous allons configurer l'environnement en fonction de l'architecture suivante:

Dans cet atelier, nous allons configurer les composants suivants et effectuer les tâches suivantes:

Créer un bucket Google Cloud Storage (GCS) pour stocker les vidéos transcodées en direct
Configurer l'API Live Streaming pour transcoder la vidéo dans plusieurs formats: HLS + MPEG DASH, SD et HD
Configurer les composants de streaming en direct: entrée/canal
Lancer la chaîne de diffusion en direct
Configurer Media CDN avec le bucket GCS comme origine
Configurer FFmpeg pour alimenter la chaîne en direct
Diffusez le flux en direct transcodé avec un lecteur vidéo
Configurer un tableau de bord Cloud Monitoring pour surveiller l'activité du CDN multimédia (latence, enregistrement dans le cache, etc.)

Remarque: Pour cet atelier, nous supposons que les utilisateurs ont accès à la console Google Cloud et qu'un projet est déjà configuré. Nous supposons également que les utilisateurs commencent avec un environnement neuf et qu'ils n'ont rien configuré pour cette démonstration.

Toutes les actions de configuration seront effectuées via la ligne de commande dans Cloud Shell. Nous pouvons toujours vérifier les composants configurés via la ligne de commande dans la console. Tout au long de l'atelier, vous verrez des pointeurs vers la console Google Cloud.

2. Avant de commencer

L'accès au Media CDN est limité. Pour accéder à Media CDN, contactez votre équipe chargée de compte. Ils peuvent créer une demande d'accès en votre nom. Si vous faites partie de Google et que vous souhaitez tester le streaming en direct avec Media CDN, contactez le responsable produit de Media CDN pour demander l'accès à Media CDN.

3. Préparation

Démarrer Cloud Shell

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.

4. Version du SDK Google Cloud

Au moment de la rédaction de cet article, 408.0.0 est la dernière version du SDK Google Cloud. Toutes les commandes de cet atelier ont été testées avec la dernière version du SDK Google Cloud. Avant de continuer, assurez-vous que Cloud Shell utilise la dernière version du SDK.

Vérifier la version du SDK

Nous allons utiliser la commande gcloud version pour vérifier la version du SDK.

Commande

gcloud version | grep "Google Cloud SDK"

Exemple de résultat

Google Cloud SDK 408.0.0

Étapes suivantes

Si la version du SDK est 408.0.0 ou ultérieure, passez à la section suivante.
Si la version du SDK est inférieure à 408.0.0, exécutez la commande indiquée ci-dessous pour mettre à jour le SDK.

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

5. Prérequis

Avant de commencer à configurer les ressources GCP, nous devons effectuer les opérations suivantes :

Configurer des variables d'environnement
Activer les API de service requises

1. Configurer des variables d'environnement

Tout au long de cet atelier, nous allons exécuter des commandes gcloud et curl avec quelques variables. Nous devons configurer les variables d'environnement suivantes.

ID du projet
Numéro du projet
Nom d'utilisateur
Région
ID d'entrée
ID de la chaîne

ID du projet et nom de l'utilisateur

Ces variables d'environnement sont généralement préconfigurées dans Cloudshell. Nous allons utiliser la commande env pour le vérifier.

Commande

env | grep -E 'DEVSHELL_PROJECT_ID=|LOGNAME'

Exemple de résultat

DEVSHELL_PROJECT_ID=<YOUR_PROJECT_ID>
LOGNAME=<YOUR_USERNAME>

Créer le fichier `env_variables`

Utilisez la commande cat pour créer le fichier env_variables.txt. La commande ci-dessous crée le fichier env_variables.txt dans le répertoire d'accueil de l'utilisateur.

Commandes

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

Configurer les variables d'environnement

Nous allons utiliser la commande source pour définir les variables d'environnement.

Commande

source ~/env_variables.txt

Vérifier que les variables sont définies

Vérifions que toutes les variables d'environnement requises sont définies. Un total de six variables d'environnement devrait s'afficher dans la sortie.

Commande

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

Exemple de résultat

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. Activer les API de service requises

Nous devons nous assurer que les API suivantes sont activées dans notre projet.

API de services réseau
API Certificate Manager
API Livestream
API Media CDN Edge Cache

Activer l'API Network Services

Pour activer l'API Network Services, exécutez la commande suivante:

Commande

gcloud services enable networkservices.googleapis.com

Activer l'API Certificate Manager

Pour activer l'API Certificate Manager, exécutez la commande suivante :

Commande

gcloud services enable certificatemanager.googleapis.com

Activer l'API Live Stream

Pour activer l'API Live Stream, exécutez la commande suivante:

Commande

gcloud services enable livestream.googleapis.com

Activer l'API Media CDN Edge Cache

Pour activer l'API Media CDN Edge Cache, exécutez la commande suivante:

Commande

gcloud services enable edgecache.googleapis.com

Vérifier que les API sont activées

Exécutez la commande gcloud services list pour obtenir la liste de toutes les API activées. Vous devriez voir quatre API dans le résultat.

Commande

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

Exemple de résultat

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

6. Créer le bucket Cloud Storage

Dans cette section, vous allez effectuer les opérations suivantes:

Créer un bucket Cloud Storage
Rendre le bucket public

Plus tard dans cet atelier, nous utiliserons ce bucket pour stocker les fichiers vidéo transcodés. Ce bucket servira également de stockage d'origine pour le service Media CDN.

1. Créer le bucket

Nous allons utiliser la commande gsutil mb pour créer le bucket:

Commande

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

2. Rendre le bucket accessible au public

Nous allons utiliser la commande iam gsutil pour rendre les fichiers accessibles au public:

Commande

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

7. Configurer l'environnement de l'API Live Streaming

Les composants de la chaîne de l'API Live Streaming sont structurés comme suit:

Nous avons créé le bucket Cloud Storage live-streaming-storage-$LOGNAME dans la section précédente. Dans les deux sections suivantes, nous allons créer les ressources suivantes:

Entrée de streaming en direct:point de terminaison auquel votre encodeur envoie votre flux d'entrée. Vous pouvez utiliser le point de terminaison d'entrée pour spécifier des configurations pour votre flux, telles que la résolution d'entrée, le type d'entrée et le recadrage vidéo.
Chaîne de streaming en direct:une chaîne est une ressource qui ingère le flux d'entrée via un point de terminaison d'entrée, le convertit en plusieurs versions et publie des flux de sortie en direct dans certains formats à l'emplacement spécifié. Vous pouvez inclure un flux d'entrée principal et un flux de sauvegarde dans la même chaîne.

Nous créerons les ressources suivantes plus tard dans l'atelier:

Encodeur:programme utilisé pour envoyer des flux d'entrée. Dans cet atelier, nous allons utiliser FFmpeg.

8. Créer et configurer le point de terminaison d'entrée

Créer le fichier input.json

Nous allons créer un fichier input.json pour spécifier le type de signal de diffusion en direct. Dans cet atelier, nous utilisons le signal en direct RTMP.

Commande

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

Créer le point de terminaison d'entrée

Au moment de la rédaction de cet atelier, l'API Live Stream n'est pas compatible avec gcloud. Nous utiliserons la commande curl pour effectuer les appels d'API.

Commande

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"

Exemple de résultat

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

La sortie contient de nombreuses informations utiles, mais pour le moment, nous devons nous concentrer sur deux champs:

ID de l'opération:dans la sortie, copiez et notez l'ID de l'opération. Vous trouverez ci-dessous l'ID d'opération de l'exemple de sortie. Vous le trouverez sur la ligne de sortie commençant par "name". "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4"
État:nous devons attendre que l'état passe de "done": false à "done": true

Vérifier l'état

Avant de continuer, nous devons vérifier que le point de terminaison d'entrée a bien été créé et qu'il est prêt.

Dans la commande ci-dessous, remplacez <OPERATION> par l'ID de l'opération que nous venons d'obtenir ci-dessus. Dans cet exemple, il s'agit de "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4".

Commande

export OPERATION_ID_1=<OPERATION>

Commande

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"

Exemple de résultat

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

Réexécutez la commande jusqu'à ce que "done:true" s'affiche, ce qui indique que le point de terminaison d'entrée a été créé et est prêt.

Enregistrer l'URI

Nous utiliserons l'URI de la sortie précédente plus tard dans l'atelier. Pour le moment, définissons une variable d'environnement pour URI.

Commande

export URI=<uri>

Remplacez <uri> par l'URI que vous venez de noter ci-dessus. Vous pouvez également utiliser la méthode GET pour récupérer l'URI.

Commande

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. Créer et configurer la chaîne de streaming en direct

Créons le canal de streaming en direct, associé au point de terminaison d'entrée que nous venons de créer dans la section précédente. L'exemple suivant crée un canal générant un flux en direct HLS composé d'une seule version haute définition (1 280 x 720). Le canal sera associé au point de terminaison d'entrée et au bucket de stockage que nous avons créés précédemment.

Créer le fichier channel.json

Dans le terminal Cloud Shell, saisissez la commande suivante pour créer un fichier "channel.json":

Commande

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

Créer la chaîne

Exécutez la commande curl suivante pour créer le canal:

Commande

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"

Exemple de résultat

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

Notez et copiez l'ID de l'opération. Nous en aurons besoin lors d'une des prochaines étapes. Vous le trouverez sur la ligne de sortie commençant par "name".

Vérifier l'état

Avant de continuer, nous devons vérifier que la chaîne a bien été créée et qu'elle est prête.

Dans la commande ci-dessous, remplacez <OPERATION> par l'ID de l'opération que nous venons d'obtenir ci-dessus. Dans cet exemple, il s'agit de operation-1661405972853-5e70a38d6f27f-79100d00-310671b4.

Commande

export OPERATION_ID_2=<OPERATION>

Commande

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"

Exemple de résultat

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

Réexécutez la commande jusqu'à ce que "done:true" s'affiche, ce qui indique que le point de terminaison d'entrée a été créé et est prêt.

Notez que la valeur "streamingState" est actuellement "STOPPED". Nous allons démarrer le canal dans la section suivante.

10. Lancer la chaîne de streaming en direct

Maintenant que nous avons créé notre chaîne de diffusion en direct, commençons-la. Dans cette section, nous allons effectuer les opérations suivantes:

Lancer la chaîne de streaming en direct
Vérifiez l'état de la chaîne. Nous devons nous assurer que streamingState est "AWAITING INPUT".

1. Lancer la chaîne

Dans Cloud Shell, exécutez la commande curl suivante pour démarrer le canal:

Commande

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"

Exemple de résultat

{
  "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. Vérifier l'état de la chaîne

Exécutez la commande curl suivante pour obtenir l'état du canal:

Commande

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"

Exemple de résultat

"streamingState": "AWAITING_INPUT",

Réexécutez la commande jusqu'à ce que "AWAITING_INPUT" s'affiche, ce qui indique que le canal est en cours d'exécution et prêt à recevoir un signal.

11. Configurer Media CDN

Dans cette section, nous allons déployer Media CDN, l'infrastructure CDN. Nous allons créer les ressources suivantes:

Origine de mise en cache périphérique
Service de mise en cache périphérique

1. Créer une origine de mise en cache périphérique

Une origine de cache Edge représente un emplacement de contenu, tel qu'un bucket Cloud Storage, un emplacement de stockage tiers ou un équilibreur de charge. En termes de CDN, l'origine (ou serveur d'origine) est l'emplacement de la source du contenu que nous souhaitons distribuer (par exemple, tous les CSS, JavaScript, HTML, images, etc.). Pour cet atelier, nous allons créer une origine qui correspond au bucket Cloud Storage que nous avons créé au début de l'atelier. Nous appellerons l'origine de mise en cache périphérique cme-origin. L'origine d'un CDN est l'endroit où tout le contenu source est stocké avant d'être distribué aux serveurs de cache de bordure.

Nous allons utiliser la commande gcloud edge-cache origins create pour créer l'origine. L'exécution de cette commande prend quelques minutes.

Commande

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

Exemple de résultat

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. Créer un service de mise en cache périphérique

Maintenant que nous avons configuré une origine de mise en cache périphérique, nous pouvons créer le service de mise en cache périphérique lui-même.

Créer le fichier `cme-demo.yaml`

La configuration du service de mise en cache périphérique s'effectue via un fichier YAML. Dans Cloud Shell, créez un fichier local appelé cme-demo.yaml. Utilisez vi, nano ou tout autre éditeur, puis collez les lignes suivantes dans le fichier YAML:

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

Nous conservons toutes les valeurs par défaut de la configuration du service de mise en cache Edge. Dans le fichier ci-dessus, trois valeurs de champ peuvent être modifiées par les utilisateurs:

name : nom de l'instance Media CDN (ici, cme-demo)
hosts: la liste des noms de domaine qui seront résolus par ce service Media CDN (ici: demo.cme.com). Nous l'utiliserons lors de cette démonstration. Nous utiliserons l'adresse IP de l'instance Media CDN.
Origin: : il s'agit de l'origine de cache Edge que nous venons de créer à l'étape précédente. Définissez-le sur cme-origin, nom de l'origine Media CDN.

Pour en savoir plus sur les différentes variables que vous pouvez utiliser dans le fichier YAML, consultez le guide de configuration du service de cache Edge.

Créer le service de mise en cache périphérique

Nous allons créer un service de cache périphérique nommé cme-demo, sur l'origine de cache périphérique cme-origin, avec l'hôte demo.cme.com. Pour créer le service, exécutez la commande suivante dans Cloud Shell:

Commande

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

La création du service de cache Edge peut prendre quelques minutes.

Exemple de résultat

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'

Notez et copiez le ipv4Addresses de l'instance du service de mise en cache périphérique (ici 34.104.36.157). Nous l'utiliserons pour mettre à jour le fichier cme-demo.yaml et, plus tard, pour diffuser la vidéo transcodée en streaming.

Mettre à jour le service de mise en cache périphérique

À ce stade, il est conseillé de mettre à jour la configuration du service de cache Edge afin de pouvoir utiliser l'adresse IP du service pour diffuser la vidéo plus tard. Le fichier YAML du service de mise en cache périphérique nous permet de lister tous les noms/adresses IP d'hôtes à partir desquels le service de mise en cache périphérique acceptera les requêtes. À ce stade, nous n'avons spécifié que demo.cme.com comme hôte. Pour fournir une résolution de nom pour ce domaine, vous pouvez configurer une zone DNS. Toutefois, une solution plus simple consiste à ajouter l'adresse IP à la liste des hôtes dans le fichier yaml. Modifiez à nouveau le fichier YAML pour qu'il se présente comme suit:

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

Pour refléter les modifications, il suffit de réimporter le fichier YAML. Dans le terminal Cloud Shell, exécutez la commande suivante:

Commande

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

Vérifiez le résultat de la commande et assurez-vous que l'adresse IP figure dans la liste des hôtes.

À ce stade, l'instance du service de cache périphérique accepte les requêtes avec "demo.cme.com" ou l'adresse IP comme hôte.

12. Générer le signal d'entrée

Maintenant que nous avons configuré tous les services requis, générons le signal d'entrée du flux en direct. Dans cette section, nous allons effectuer les opérations suivantes:

Installer FFmpeg, un logiciel Open Source sans frais
Envoyer un signal de test en direct à l'entrée/au canal

1. Installer FFmpeg

FFmpeg est un projet logiciel Open Source et sans frais composé d'une suite de bibliothèques et de programmes permettant de gérer des fichiers et des flux vidéo, audio et multimédias. Dans le terminal Cloud Shell, utilisez la commande suivante pour installer FFmpeg:

Commande

sudo apt install ffmpeg -y

Une fois l'installation terminée, vérifions que FFmpeg a été correctement installé en vérifiant sa version:

Commande

ffmpeg -version

Exemple de résultat

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

FFmpeg a été correctement installé.

2. Démarrer le signal de diffusion en direct vers l'entrée/le canal

Maintenant que FFmpeg est installé, nous allons envoyer un flux d'entrée de test au point de terminaison d'entrée pour générer le flux en direct.

Dans le terminal Cloud Shell, exécutez la commande suivante, en utilisant la variable d'environnement URI que nous avons créée dans la section "Créer et configurer le point de terminaison d'entrée".

Commande

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

FFmpeg devrait envoyer le signal de diffusion en direct de test. La commande ne renvoie pas l'invite. Le signal est généré jusqu'à ce que vous l'arrêtiez. Vous devrez ouvrir une nouvelle fenêtre Cloud Shell pour le reste de l'atelier.

13. Ouvrir une nouvelle session Cloud Shell

À ce stade, vous devez ouvrir une nouvelle fenêtre Cloud Shell pour continuer l'atelier, car FFmpeg s'exécutera en permanence jusqu'à ce que vous appuyiez sur <CTRL+C> pour arrêter la commande et donc arrêter la génération du signal en direct.

Cliquez sur le signe "+" à côté du nom du terminal Cloud Shell actuel. Une fenêtre Cloud Shell supplémentaire s'ouvre.

Exécutez le reste de l'atelier dans la nouvelle fenêtre Cloud Shell qui s'ouvre.

Configurer les variables d'environnement

Comme il s'agit d'une nouvelle session Cloud Shell, nous devons définir à nouveau les variables d'environnement. Nous allons utiliser la commande source pour définir les variables d'environnement.

Commande

source ~/env_variables.txt

Vérifier que les variables sont définies

Vérifions que toutes les variables d'environnement requises sont définies. Un total de six variables d'environnement devrait s'afficher dans la sortie.

Commande

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

Exemple de résultat

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. Vérifier que le signal en direct est transcodé

Nous allons exécuter un curl pour décrire la chaîne. Le résultat devrait indiquer que l'état streamingState est passé de "AWAITING_INPUT" à "STREAMING".

Commande

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"

Dans la réponse du fichier JSON de sortie, vous devriez voir "streamingState": "STREAMING", ce qui indique que la chaîne est en streaming et que le signal en direct est transcodé.

Vérifions également le contenu du bucket, où nous devrions voir un fichier manifeste et plusieurs segments vidéo TS. Exécutez la commande suivante dans Cloud Shell pour lister le contenu du bucket que nous avons créé au début de l'atelier et utilisé par l'API Live Streaming pour générer le fichier manifeste de signal en direct transcodé et les segments vidéo TS:

Commande

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

Exemple de résultat

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

Vous devriez obtenir le résultat suivant :

le fichier manifeste HLS: main.m3u8
Les segments vidéo TS correspondants: une série de fichiers numérotés segment-000000000X.ts

À ce stade, nous avons terminé les opérations suivantes:

API Live Streaming: le signal en direct est généré et transcodé dans un bucket via l'API Live Streaming.
Media CDN: Media CDN a été configuré avec le bucket de stockage de streaming en direct comme origine.

Dans les sections suivantes, nous allons valider le service de cache Edge, puis diffuser la vidéo transcodée à l'aide de l'adresse IP anycast du Media CDN.

15. Vérifier que l'instance du service de mise en cache périphérique fonctionne

Dans cette section, nous allons vérifier que l'instance du service de cache Edge fonctionne comme prévu. Pour ce faire, nous allons essayer d'accéder à un fichier à partir de l'instance du service de cache périphérique à l'aide de l'adresse IP du service de cache périphérique. Lors du premier accès à un objet, il n'est pas encore mis en cache. Nous devrions observer un cache MISS. Pour la première requête, l'objet est lu à partir de l'origine et mis en cache en périphérie. Toutes les tentatives suivantes d'accès au même fichier renverront un HIT de cache, car l'objet est désormais mis en cache en périphérie. Vérifions ce comportement:

Exécutez la commande curl suivante dans Cloud Shell pour accéder au fichier manifeste vidéo transcodé stocké dans l'origine du cache Edge:

Commande

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

Notez la résolution où nous utilisons l'adresse IP de l'instance du service de cache périphérique pour résoudre son nom. Assurez-vous d'utiliser demo.cme.com:<IP>, où l'adresse IP correspond à celle de l'instance du service de cache périphérique que nous venons de créer.

Recherchez l'en-tête x-cache-status dans la sortie.

Exemple de résultat

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

Notez que le cache manque, car l'objet n'a pas encore été mis en cache et est lu à partir de l'origine.

Nous allons maintenant effectuer plusieurs requêtes pour le fichier m3u8. Si tout est configuré correctement, Media CDN devrait commencer à diffuser le contenu à partir de son cache. La commande ci-dessous effectue 10 requêtes curl et n'imprime que l'en-tête x-cache-status.

Commande

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

Le résultat doit être un mélange de cache hit et miss. Si des requêtes du cache s'affichent dans la sortie, cela signifie que Media CDN fonctionne comme prévu.

Exemple de résultat

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

Notez l'accès au cache, car l'objet est maintenant mis en cache en périphérie. Le service Cloud Media Edge fonctionne comme prévu.

16. Diffusez des vidéos de signaux en direct transcodées avec VLC

C'est ici que nous faisons le lien entre toutes les étapes que nous avons suivies jusqu'à présent:

Nous avons créé un bucket appelé live-streaming-storage-$LOGNAME qui reçoit le résultat du signal en direct transcodé en contenu HLS par l'API Live Streaming.
Nous avons configuré l'API Live Streaming.
Nous avons lancé un signal en direct RTMP avec FFmpeg qui alimente l'entrée/le canal de l'API Live Streaming.
Nous avons vérifié que le signal en direct a été transmis à la chaîne et que celle-ci était en mode streaming.
Nous avons vérifié que les fichiers transcodés (fichier manifeste et segments TS) générés et stockés dans le bucket live-streaming-storage-$LOGNAME.
Une origine de cache périphérique appelée cme-origin a été configurée avec le bucket GCS live-streaming-storage-$LOGNAME comme origine.
Une instance de cache Edge appelée cme-demo a été configurée avec cme-origin comme origine.
Nous avons vérifié le comportement (manque de cache, réussite de la mise en cache) de l'instance du service de mise en cache Edge.

Nous pouvons désormais utiliser un lecteur vidéo pour diffuser le signal en direct transcodé via le cache Media CDN. Pour ce faire, nous allons utiliser VLC Player. VLC Player est un lecteur et un framework multimédias multiplates-formes sans frais et Open Source qui lit la plupart des fichiers multimédias. Il lit les formats multimédias adaptatifs (tels que DASH et HLS). Il utilise le principe du streaming adaptatif : en fonction de la qualité de votre connexion réseau et de la bande passante disponible, le lecteur adapte la qualité de la vidéo lue. Pour la tâche de transcodage que nous venons d'effectuer, nous avons utilisé les préréglages par défaut et généré "seulement" deux qualités : SD et HD. Lorsque nous commençons à lire la vidéo dans le lecteur, elle devrait commencer en SD et passer rapidement au format HD si votre connexion réseau est suffisamment bonne.

Nous diffuserons le signal en direct transcodé au format HLS (format vidéo Apple largement accepté). Le fichier correspondant est appelé main.m3u8, qui est le fichier manifeste HLS. Le fichier manifeste pointe vers les segments vidéo TS.

Pour utiliser VLC Player, accédez à https://www.videolan.org/vlc/ et téléchargez une version du lecteur pour le système d'exploitation de votre ordinateur portable. VLC est disponible pour Windows, MacOSX, Linux, Android et iOS.

Installez le lecteur sur votre ordinateur portable et lancez-le. Nous utiliserons la version MacOSX du lecteur pour les prochaines étapes.

Pour lire une vidéo, accédez à "Fichier" / "Ouvrir un réseau":

Configurez-le avec:

URL: http://<Replace_With_Edge_Cache_IP>/main.m3u8. Il s'agit de l'URL de la vidéo que nous souhaitons diffuser en streaming. Remarques :
Adresse IP de l'instance Media CDN: 34.105.35.246. Remplacez-le par l'adresse IP du service Cloud Media que vous avez déployé.
Chemin d'accès au fichier vidéo manifeste: "/". Il s'agit du chemin que nous avons utilisé dans le bucket live-streaming-storage-$LOGNAME pour stocker les fichiers de signal en direct transcodés. Le chemin d'accès est le chemin racine: "/".
Nom du fichier vidéo manifeste: fichier manifeste HLS, main.m3u8.

et cliquez sur "Ouvrir". La vidéo en direct transcodée devrait commencer à être lue. La vidéo ressemblera à la capture d'écran ci-dessous. Le compteur à l'écran s'affiche par incréments de 1, et vous devriez entendre un bip continu.

Il s'agit d'un signal de diffusion en direct de test RTMP généré par FFmpeg, transcodé en HLS par l'API Live Streaming et diffusé via le cache Media CDN:

Vous pouvez utiliser n'importe quel autre lecteur HLS et MPEG-DASH si vous le souhaitez. Voici quelques options à envisager:

QuickTime Player (installé par défaut sur les Mac) Même chose ici: ouvrez une connexion réseau vers http://34.104.36.157/main.m3u8. Remplacez l'adresse IP par celle de votre instance de service de cache périphérique.

17. Surveiller Media CDN

L'équipe d'experts a créé un modèle de tableau de bord Media CDN : https://gist.github.com/elithrar/1c511d00f5cd3736fb2a3897867209c1.

Pour l'installer, exécutez les commandes suivantes dans la fenêtre Cloud Shell:

Téléchargez le fichier YAML:

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

Créez le tableau de bord pour Cloud Monitoring:

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

La configuration peut prendre quelques minutes. Accédez à la console Google Cloud, puis cliquez sur les trois barres > "Opérations" > "Surveillance" > "Tableaux de bord". Un tableau de bord intitulé "Métriques Media Edge" devrait s'afficher. Cliquez dessus pour afficher les métriques:

18. Nettoyer l'environnement de l'atelier

Félicitations, vous avez terminé l'atelier. Dans cette section, nous allons supprimer toutes les ressources que nous avons créées au cours de l'atelier.

Arrêtez le signal FFmpeg:

Appuyez sur <CTRL+C> dans le terminal Cloud Shell dans lequel FFmpeg s'exécute.

Arrêtez la chaîne de diffusion en direct:

Commande

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"

Supprimez le canal de streaming en direct:

Commande

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"

Supprimez le point de terminaison d'entrée de diffusion en direct:

Commande

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"

Supprimez le bucket GCS:

Commande

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

Supprimez l'instance du service de mise en cache périphérique:

Commande

gcloud edge-cache services delete cme-demo

Confirmez la suppression en saisissant "Y" lorsque vous y êtes invité.

Supprimez l'origine de mise en cache Edge:

Commande

gcloud edge-cache origins delete cme-origin

Confirmez la suppression en saisissant "Y" lorsque vous y êtes invité.

Supprimer le tableau de bord personnalisé

Commande

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

Diffusion en direct sur Google Cloud avec Media CDN et l'API Live Streaming

1. Introduction

Points abordés

Objectifs de l'atelier

2. Avant de commencer

3. Préparation

Démarrer Cloud Shell

4. Version du SDK Google Cloud

Vérifier la version du SDK

Étapes suivantes

5. Prérequis

1. Configurer des variables d'environnement

ID du projet et nom de l'utilisateur

Créer le fichier env_variables

Configurer les variables d'environnement

Vérifier que les variables sont définies

2. Activer les API de service requises

Activer l'API Network Services

Activer l'API Certificate Manager

Activer l'API Live Stream

Activer l'API Media CDN Edge Cache

Vérifier que les API sont activées

6. Créer le bucket Cloud Storage

1. Créer le bucket

2. Rendre le bucket accessible au public

7. Configurer l'environnement de l'API Live Streaming

8. Créer et configurer le point de terminaison d'entrée

Créer le fichier input.json

Créer le point de terminaison d'entrée

Vérifier l'état

Enregistrer l'URI

9. Créer et configurer la chaîne de streaming en direct

Créer le fichier channel.json

Créer la chaîne

Vérifier l'état

10. Lancer la chaîne de streaming en direct

1. Lancer la chaîne

2. Vérifier l'état de la chaîne

11. Configurer Media CDN

1. Créer une origine de mise en cache périphérique

2. Créer un service de mise en cache périphérique

Créer le fichier cme-demo.yaml

Créer le service de mise en cache périphérique

Mettre à jour le service de mise en cache périphérique

12. Générer le signal d'entrée

1. Installer FFmpeg

2. Démarrer le signal de diffusion en direct vers l'entrée/le canal

13. Ouvrir une nouvelle session Cloud Shell

Configurer les variables d'environnement

Vérifier que les variables sont définies

14. Vérifier que le signal en direct est transcodé

15. Vérifier que l'instance du service de mise en cache périphérique fonctionne

16. Diffusez des vidéos de signaux en direct transcodées avec VLC

17. Surveiller Media CDN

18. Nettoyer l'environnement de l'atelier

Arrêtez le signal FFmpeg:

Arrêtez la chaîne de diffusion en direct:

Supprimez le canal de streaming en direct:

Supprimez le point de terminaison d'entrée de diffusion en direct:

Supprimez le bucket GCS:

Supprimez l'instance du service de mise en cache périphérique:

Supprimez l'origine de mise en cache Edge:

Supprimer le tableau de bord personnalisé

Créer le fichier `env_variables`

Créer le fichier `cme-demo.yaml`