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 mettant fin aux connexions au plus près des clients, en réutilisant les connexions à l'origine et en adoptant des protocoles et des personnalisations de mise en réseau modernes. Pour les utilisateurs (et nos clients), cela signifie une latence plus faible, 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 globale. 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 dans 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 et chaîne) et démarrer un flux en direct vers l'entrée/la chaîne avec FFmpeg (FFmpeg peut générer un signal de test en direct). L'API Live Streaming transcodera le flux en direct. Le fichier manifeste et les segments de la vidéo transcodée 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 le contenu 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éez 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 diffusion en direct : entrée/chaîne
Démarrer 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
Diffuser le flux en direct transcodé avec un lecteur vidéo
Configurer un tableau de bord Cloud Monitoring pour surveiller l'activité Media CDN (latence, cache touché, cache manqué, etc.)

Remarque : Pour cet atelier, nous partons du principe que les utilisateurs ont accès à la console Google Cloud et qu'ils ont déjà configuré un projet. Nous partons également du principe que les utilisateurs commencent avec un environnement vierge 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 trouverez des pointeurs vers la console Google Cloud.

2. Avant de commencer

L'accès à Media CDN est limité. Pour accéder à Media CDN, contactez l'équipe chargée de votre 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 de Google Cloud SDK

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 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 exécuterons les 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 d'utilisateur

Ces variables d'environnement sont généralement préconfigurées dans Cloud Shell. Nous utiliserons la commande env pour effectuer la vérification.

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 utiliserons la commande source pour définir les variables d'environnement.

Commande

source ~/env_variables.txt

Vérifiez que les variables sont définies.

Vérifions que toutes les variables d'environnement requises sont définies. Le résultat doit afficher un total de six variables d'environnement.

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. Quatre API devraient s'afficher 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, nous allons effectuer les opérations suivantes :

Créer un bucket Cloud Storage
Rendre le bucket accessible publiquement

Plus tard dans l'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 publiquement

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

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 diffusion en direct : un point de terminaison d'entrée est un 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.
Canal de streaming en direct : un canal est une ressource qui ingère le flux d'entrée via un point de terminaison d'entrée, transcode le flux d'entrée en plusieurs rendus et publie les flux en direct de sortie dans certains formats à l'emplacement spécifié. Vous pouvez inclure un flux d'entrée principal et un flux de sauvegarde dans le même canal.

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
}

Le résultat contient de nombreuses informations utiles, mais pour l'instant, nous devons nous concentrer sur deux champs :

ID de l'opération : copiez et notez l'ID de l'opération à partir du résultat. Vous trouverez ci-dessous l'ID d'opération de l'exemple de résultat. 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. 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 le URI de la sortie précédente plus loin dans l'atelier. Pour l'instant, 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 la chaîne de diffusion en direct associée 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 qui génère un flux linéaire HLS composé d'une seule version haute définition (1280x720). Le canal sera associé au point de terminaison d'entrée et au bucket de stockage que nous avons créé 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 prochaine étape. 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. 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 de "streamingState" est actuellement "STOPPED". Nous allons démarrer le canal dans la section suivante.

10. Démarrer la chaîne de streaming en direct

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

Démarrer 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. Démarrer 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 la 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 Edge Cache 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 où se trouve la source du contenu que nous voulons distribuer (par exemple, tous les fichiers CSS, JavaScript, HTML, images, etc.). Pour cet atelier pratique, 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 périphériques.

Nous utiliserons 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 Edge Cache

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 allons conserver tous les paramètres de configuration par défaut du service de mise en cache périphérique. Dans le fichier ci-dessus, les utilisateurs peuvent souhaiter modifier trois valeurs de champ :

name : nom de l'instance Media CDN (ici, cme-demo)
hosts: : liste des noms de domaine qui seront résolus par ce service Media CDN (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 du cache périphérique que nous venons de créer à l'étape précédente. Définissez-le sur cme-origin, le 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 Edge Cache.

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

Nous allons créer un service de mise en cache périphérique nommé cme-demo, sur l'origine de mise en 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 Edge Cache 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 l'ipv4Addresses de l'instance de 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.

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

À ce stade, il est judicieux de mettre à jour la configuration du service de cache périphérique afin de pouvoir utiliser l'adresse IP du service pour diffuser la vidéo ultérieurement. Le fichier YAML Edge Cache Service nous permet de lister tous les noms d'hôte/adresses IP à partir desquels Edge Cache Service acceptera les requêtes. Pour l'instant, nous n'avons spécifié que demo.cme.com comme hôte. Pour fournir la résolution de noms 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 ressemble à celui ci-dessous :

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 que les modifications soient prises en compte, 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 apparaît dans la liste des hôtes.

À ce stade, l'instance Edge Cache Service 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 :

Installez FFmpeg, un logiciel Open Source sans frais.
Envoyer un signal en direct de test à l'entrée/la chaîne

1. Installer FFmpeg

FFmpeg est un projet logiciel Open Source sans frais qui se compose 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

Vous devriez voir FFmpeg envoyer le signal de test en direct. La commande ne renverra pas l'invite. Le signal sera 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 un nouveau Cloud Shell

À ce stade, vous devrez 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 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 fenêtre Cloud Shell qui vient de s'ouvrir.

Configurer les variables d'environnement

Comme il s'agit d'un nouveau Cloud Shell, nous devons définir de nouveau les variables d'environnement. Nous utiliserons la commande source pour définir les variables d'environnement.

Commande

source ~/env_variables.txt

Vérifiez que les variables sont définies.

Vérifions que toutes les variables d'environnement requises sont définies. Le résultat doit afficher un total de six variables d'environnement.

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 le canal. Le résultat doit indiquer que 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 le fichier JSON de réponse, vous devriez voir "streamingState": "STREAMING", ce qui indique que la chaîne diffuse du contenu 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 du 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
Segments vidéo TS correspondants : 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 configuré avec le bucket de stockage Live Streaming comme origine de Media CDN.

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

15. Vérifier que l'instance Edge Cache Service fonctionne

Dans cette section, nous allons vérifier que l'instance Edge Cache Service fonctionne comme prévu. Pour ce faire, nous allons tenter d'accéder à un fichier à partir de l'instance Edge Cache Service à l'aide de l'adresse IP du service Edge Cache. La première fois qu'un objet est consulté, 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 de service de cache périphérique pour résoudre son nom. Assurez-vous d'utiliser demo.cme.com:<IP>, où IP correspond à l'adresse IP de l'instance de service Edge Cache que nous venons de créer.

Recherchez l'en-tête x-cache-status dans le résultat.

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 le cache miss, 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 correctement configuré, Media CDN devrait commencer à diffuser le contenu à partir de son cache. La commande ci-dessous effectue 10 requêtes curl et n'affiche 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 accès au cache s'affichent dans le résultat, 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 désormais mis en cache en périphérie. Le service Cloud Media Edge fonctionne comme prévu.

16. Diffuser la vidéo du signal en direct transcodé avec VLC

C'est la partie où nous relions les points et associons toutes les étapes sur lesquelles nous avons travaillé 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 Stream.
Nous avons configuré l'API Live Streaming.
Nous avons démarré 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 était transmis à la chaîne et que celle-ci était en mode streaming.
Nous avons vérifié que les fichiers transcodés obtenus (segments manifestes et TS) avaient été générés et stockés dans le bucket live-streaming-storage-$LOGNAME.
Une origine de mise en cache périphérique appelée cme-origin a été configurée avec le bucket GCS live-streaming-storage-$LOGNAME comme origine.
Une instance Edge Cache nommée cme-demo a été configurée avec cme-origin comme origine.
Nous avons vérifié le comportement (cache manqué, cache touché) de l'instance Edge Cache Service.

Nous sommes maintenant en mesure d'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 multiplate-forme, Open Source et sans frais, qui permet de lire 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 : le lecteur adapte la qualité de la vidéo lue en fonction de la qualité de votre connexion réseau et de la bande passante disponible. Lors de la tâche de transcodage que nous venons d'effectuer, nous avons utilisé les préréglages par défaut et généré deux qualités "seulement" : SD et HD. Lorsque la vidéo commence à être lue dans le lecteur, vous devriez la voir démarrer au format SD, puis 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 pris en charge). 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 flux 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. Remarques :
Adresse IP de l'instance Media CDN : 34.105.35.246. Remplacez 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 d'accès 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 ici : "/".
Nom du fichier manifeste vidéo : fichier manifeste HLS, main.m3u8.

Cliquez ensuite sur "Ouvrir". La vidéo en direct transcodée devrait commencer à être lue. La vidéo doit ressembler à la capture d'écran ci-dessous. Le compteur à l'écran s'incrémente de 1 et vous devriez entendre un bip continu.

Il s'agit d'un signal en direct RTMP de base 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 exemples :

Lecteur QuickTime : installé par défaut sur les Mac. Ouvrez une connexion réseau vers http://34.104.36.157/main.m3u8. Remplacez l'adresse IP par celle de votre instance Edge Cache Service.

17. Surveiller Media CDN

L'équipe SME 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 tout au long de l'atelier.

Arrêtez le signal FFmpeg :

Appuyez sur <CTRL+C> dans le terminal Cloud Shell dans lequel FFmpeg est en cours d'exécution.

Arrêter 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"

Supprimer la chaîne 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 la 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 de 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 périphérique :

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 de Google Cloud SDK

Vérifier la version du SDK

Étapes suivantes

5. Prérequis

1. Configurer des variables d'environnement

ID du projet et nom d'utilisateur

Créer le fichier env_variables

Configurer les variables d'environnement

Vérifiez 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 publiquement

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. Démarrer la chaîne de streaming en direct

1. Démarrer 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 Edge Cache

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 un nouveau Cloud Shell

Configurer les variables d'environnement

Vérifiez que les variables sont définies.

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

15. Vérifier que l'instance Edge Cache Service fonctionne

16. Diffuser la vidéo du signal en direct transcodé avec VLC

17. Surveiller Media CDN

18. Nettoyer l'environnement de l'atelier

Arrêtez le signal FFmpeg :

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

Supprimer la chaîne de streaming en direct :

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

Supprimez le bucket GCS :

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

Supprimez l'origine de mise en cache périphérique :

Supprimer le tableau de bord personnalisé

Créer le fichier `env_variables`

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