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 le contenu fréquemment consulté au plus près des utilisateurs finaux, en interrompant les connexions au plus près des clients, en réutilisant les connexions jusqu'à l'origine et en adoptant des protocoles et personnalisations de réseau modernes. Pour les utilisateurs (et nos clients), cela se traduit par une latence réduite, une plus grande fiabilité et une réduction des coûts, ce qui se traduit par une amélioration des ventes, de l'expérience sur le Web et une nette augmentation de l'expérience utilisateur. À l'heure actuelle, très peu de sites et de plates-formes de streaming vidéo modernes fonctionnent sans CDN.

Points abordés

Cet atelier va vous guider tout au long du déploiement d'un environnement de workflow de diffusion en direct avec Media CDN (CDN) et l'API Cloud Media Live Streaming (transcodage de vidéos en direct), Cloud Storage (stockage pour les vidéos) et lecteur vidéo (VLC, Google Shaka Player, etc. – HLS + lecteur MPEG-DASH).

Nous configurerons les composants de l'API Live Streaming (entrée, chaîne) et lancerons un flux en direct sur l'entrée/la chaîne 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 vidéo transcodé et les segments associés seront stockés dans un bucket Cloud Storage. Ensuite, nous configurerons Media CDN en utilisant le bucket Cloud Storage de vidéos en direct comme origine. Enfin, VLC Player servira à lire du 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:

Nous allons configurer les composants suivants et effectuer les tâches suivantes dans le cadre de cet atelier:

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 diffusion en direct: entrée/chaîne
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
Diffuser le flux en direct transcodé à l'aide d'un lecteur vidéo
Configurer un tableau de bord Cloud Monitoring pour surveiller l'activité de Media CDN (latence, succès de cache, défaut de cache, etc.)

Remarque: Pour cet atelier, nous partons du principe que les utilisateurs ont accès à la console Google Cloud et qu'ils disposent déjà d'un projet. Nous supposons également que les utilisateurs partent d'un nouvel environnement 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, des pointeurs vous redirigeront 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. Il peut créer une demande d'accès en votre nom. Si vous faites partie de Google et que vous souhaitez tester la diffusion 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 ce document, 408.0.0 correspond à la dernière version du SDK Google Cloud. Toutes les commandes de cet atelier ont été testées à l'aide de la dernière version de Google Cloud SDK. 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 antérieure à 408.0.0, exécutez la commande ci-dessous pour le mettre à jour.

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 les variables d'environnement

Tout au long de cet atelier, nous allons exécuter 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 Cloudshell. Pour cela, nous allons utiliser la commande env.

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 le résultat.

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 apparaître 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 iam gsutil pour rendre les fichiers publics:

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 d'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 auquel votre encodeur envoie votre flux d'entrée. Vous pouvez utiliser le point de terminaison d'entrée pour spécifier les configurations de votre flux, telles que la résolution d'entrée, le type d'entrée et le recadrage de la vidéo.
Canal de diffusion en direct:un canal est une ressource qui ingère le flux d'entrée via un point de terminaison d'entrée, le convertit en plusieurs rendus et publie les flux en direct de sortie dans certains formats et à l'emplacement spécifié. Vous pouvez inclure un flux d'entrée principal et un flux d'entrée de secours sur le même canal.

Nous créerons les ressources suivantes dans la suite de l'atelier:

Encodeur:un encodeur est un 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, gcloud n'est pas compatible avec l'API Live Stream. Nous allons utiliser 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 le moment, nous devons nous concentrer sur deux champs:

ID de l'opération:à partir du résultat, copiez l'ID de l'opération et notez-le. Vous trouverez ci-dessous l'ID d'opération de l'exemple de sortie. Il se trouve 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, indiquant que le point de terminaison d'entrée a été créé et est prêt.

Enregistrer l'URI

Nous utiliserons la valeur URI de la sortie précédente dans la suite de l'atelier. À ce stade, nous allons définir 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 diffusion 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 générant un flux en direct HLS composé d'un seul rendu haute définition (1 280 x 720). Le canal est 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 d'opération. Nous en aurons besoin à l'une des prochaines étapes. Il se trouve 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, indiquant que le point de terminaison d'entrée a été créé et est prêt.

Notez que "streamingState" est actuellement "STOPPED". nous allons lancer la chaîne dans la section suivante.

10. Lancer une 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:

Créer une chaîne pour la diffusion en direct
Vérifiez l'état de la chaîne. Nous devons nous assurer que streamingState est bien "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. indiquant 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 de mise en cache périphérique 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 fichiers CSS, JavaScript, HTML, images, etc. Pour cet atelier, nous allons créer une origine qui est mappée 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 mise en cache périphérique.

Nous allons utiliser la commande gcloud edge-cache origins create pour créer l'origine. L'exécution de la 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 est effectuée à l'aide d'un fichier YAML. Dans Cloud Shell, créez un fichier local appelé cme-demo.yaml. Utilisez vi, nano ou tout autre éditeur et 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 du service de mise en cache périphérique par défaut. 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: : liste des noms de domaine qui seront résolus par ce service Media CDN, ici : demo.cme.com. Nous l'utiliserons pendant cette démonstration. Nous allons utiliser l'adresse IP de l'instance Media CDN.
Origin: : origine de mise en cache périphérique 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 Edge Cache Service.

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 de mise en cache périphérique 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 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, puis 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 mise en cache périphérique afin de pouvoir utiliser l'adresse IP du service pour diffuser la vidéo ultérieurement. Le fichier YAML du service de mise en cache périphérique nous permet de lister tous les noms et toutes les adresses IP des hôtes dont le service de mise en cache périphérique acceptera les requêtes. À ce stade, nous n'avons spécifié que demo.cme.com en tant qu'hôte. Pour assurer la résolution de noms de ce domaine, vous devez configurer une zone DNS dans le cloud. 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 à l'exemple 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 répercuter les modifications, il nous 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 de service de mise en cache périphérique accepte les requêtes avec "demo.cme.com" ou l'adresse IP en tant qu'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 sur l'entrée/le canal

1. Installer FFmpeg

FFmpeg est un projet logiciel libre et Open Source qui se compose d'une suite de bibliothèques et de programmes permettant de gérer des fichiers et flux vidéo, audio et autres. Dans le terminal Cloud Shell, installez FFmpeg à l'aide de la commande suivante:

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émarrez le signal de flux en direct sur l'entrée/la chaîne.

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 constater que FFmpeg envoie le signal en direct de test. 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 la suite de l'atelier.

13. Ouvrir une nouvelle fenêtre Cloud Shell

À ce stade, vous devrez ouvrir une nouvelle fenêtre Cloud Shell pour poursuivre l'atelier, car FFmpeg s'exécutera de façon permanente jusqu'à ce que vous appuyiez sur <CTRL+C>. la commande pour l'arrêter et ainsi arrêter la génération du signal en direct.

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

Exécutez le reste de l'atelier dans la fenêtre Cloud Shell que vous venez d'ouvrir.

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 le résultat.

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 "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, "streamingState": "STREAMING" devrait indiquer que la chaîne est en streaming et que le signal en direct est en cours de transcodage.

Vérifions également le contenu du bucket dans lequel nous devrions voir un fichier manifeste et plusieurs séquences vidéo de dépannage. 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 séquences 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é ce qui suit:

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 validerons le service de mise en cache périphérique, puis nous diffuserons la vidéo transcodée en streaming à l'aide de l'adresse IP Anycast Media CDN.

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

Dans cette section, nous allons vérifier que l'instance de service de mise en cache périphérique fonctionne comme prévu. Pour ce faire, nous essaierons d'accéder à un fichier à partir de l'instance du service de mise en cache périphérique en utilisant l'adresse IP de ce service. Le premier accès à un objet n'est pas encore mis en cache. Nous devons observer un MISS de cache. Pour la première requête, l'objet est lu depuis l'origine et mis en cache à la périphérie. Toutes les tentatives suivantes pour accéder 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é qui est stocké dans l'origine de mise en cache périphérique:

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 mise en cache périphérique pour résoudre son nom. Utilisez demo.cme.com:<IP>, où IP correspond à l'adresse IP de l'instance de service de mise en cache périphérique 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 la présence de miss dans le cache, car l'objet n'a pas encore été mis en cache et est lu à partir de l'origine.

Nous allons maintenant envoyer 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

La sortie doit combiner des valeurs de cache hit et miss. Si vous voyez des succès de cache 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 le hit de cache, car l'objet est désormais mis en cache en périphérie. Le service Cloud Medie Edge fonctionne comme prévu.

16. Lire en streaming une vidéo en direct transcodée avec VLC

C'est dans cette partie que nous faisons le lien et le lien entre 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 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 était transmis à la chaîne et que celle-ci était en mode streaming.
Nous avons vérifié que les fichiers transcodés obtenus (manifeste et segments TS) ont bien é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 de mise en cache périphérique appelée cme-demo a été configurée avec cme-origin comme origine.
Nous avons vérifié le comportement (défaut de cache, succès de cache) de l'instance de service de mise en cache périphérique.

Nous sommes arrivés au stade où nous pouvons 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 framework et un lecteur multimédia multiplate-forme sans frais et Open Source qui permet de lire la plupart des fichiers multimédias. Elle lit les formats multimédias adaptatifs (DASH et HLS, par exemple). Elle applique le principe de la diffusion adaptative : en fonction de la qualité de votre connexion réseau et de la bande passante disponible, la qualité de la vidéo lue s'adapte. Pour le job de transcodage que nous venons d'effectuer, nous avons utilisé les préréglages par défaut et généré "uniquement" deux qualités : SD et HD. Lorsque nous entamons la lecture de la vidéo dans le lecteur, celle-ci doit se lancer au format SD. Si votre connexion réseau est suffisamment bonne, elle doit passer rapidement au format HD.

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

Pour utiliser VLC Player, accédez à la page 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 étapes suivantes.

Pour lire une vidéo, accédez à "Fichier" / "Réseau ouvert" :

Configuration avec:

URL: http://<Replace_With_Edge_Cache_IP>/main.m3u8. Il s'agit de l'URL de la vidéo que nous voulons diffuser. Remarques :
Adresse IP de l'instance Media CDN: 34.105.35.246. Remplacez-la par l'adresse IP de Cloud Media Service 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 signaux en direct transcodés. Ici, le chemin d'accès racine est le chemin d'accès racine : "/".
Nom du fichier vidéo manifeste: le fichier manifeste HLS, main.m3u8.

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

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

Si vous le souhaitez, vous pouvez utiliser n'importe quel autre lecteur HLS et MPEG DASH. En voici quelques-uns à prendre en compte:

Lecteur Quicktime : installé par défaut sur les Mac Idem ici: ouvrez une connexion réseau à http://34.104.36.157/main.m3u8 - remplacez l'adresse IP par celle de votre instance de service de mise en cache périphérique.

17. Monitoring Media CDN

Un modèle de tableau de bord Media CDN a été créé par l'équipe PME : 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 et cliquez sur les trois barres > Opérations > Surveillance > Tableaux de bord. Vous devriez voir un tableau de bord appelé "Media Edge Metrics". Cliquez dessus pour afficher les métriques:

18. Nettoyer l'environnement de l'atelier

Félicitations ! Vous avez terminé cet atelier. Dans cette section, nous allons supprimer toutes les ressources que nous avons créées tout au long de l'atelier.

Arrêt du signal FFmpeg:

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

Arrêter la chaîne de streaming 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 la chaîne 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/channels/$CHANNEL_ID"

Supprimez le point de terminaison d'entrée pour 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 du SDK Google Cloud

Vérifier la version du SDK

Étapes suivantes

5. Prérequis

1. Configurer les variables d'environnement

ID du projet et nom d'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 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 diffusion en direct

Créer le fichier channel.json

Créer la chaîne

Vérifier l'état

10. Lancer une 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émarrez le signal de flux en direct sur l'entrée/la chaîne.

13. Ouvrir une nouvelle fenêtre 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 de service de mise en cache périphérique fonctionne

16. Lire en streaming une vidéo en direct transcodée avec VLC

17. Monitoring Media CDN

18. Nettoyer l'environnement de l'atelier

Arrêt du signal FFmpeg:

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

Supprimez la chaîne de diffusion en direct:

Supprimez le point de terminaison d'entrée pour 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`