Questa pagina è stata tradotta dall'API Cloud Translation.

Live streaming su Google Cloud con Media CDN e API Live Streaming

1. Introduzione

Le reti CDN (Content Delivery Network) migliorano le prestazioni degli utenti memorizzando nella cache i contenuti a cui si accede di frequente più vicino agli utenti finali, terminando le connessioni più vicino ai client, riutilizzando le connessioni all'origine e adottando protocolli e personalizzazioni di rete moderni. Per gli utenti (e i nostri clienti), ciò significa latenza inferiore, maggiore affidabilità e costi ridotti, con un conseguente miglioramento delle vendite, dell'esperienza web e un aumento netto dell'esperienza utente. Oggigiorno, pochissimi siti e piattaforme di streaming video moderni operano senza una CDN.

Obiettivi didattici

Questo laboratorio illustra i passaggi per implementare un ambiente di flusso di lavoro di live streaming con Media CDN (CDN) + API Cloud Media Live Streaming (transcodifica video in diretta) + Cloud Storage (spazio di archiviazione per i video) + Video Player (VLC, Google Shaka Player e così via, player compatibile con HLS + MPEG-DASH).

Configurare i componenti dell'API Live Streaming (Input, Channel) e avviare un feed live su Input/Channel con FFmpeg (FFmpeg può generare un segnale di test in tempo reale). L'API Live Streaming transcodifica il feed dal vivo. Il manifest e i segmenti video transcodificati verranno archiviati in un bucket Cloud Storage. Poi configureremo Media CDN con il bucket Cloud Storage dei video in diretta come origine. Infine, VLC Player verrà utilizzato per riprodurre i contenuti live memorizzati nella cache tramite Media CDN. Configuraremo anche una dashboard di Cloud Monitoring per visualizzare l'attività di Media CDN.

Cosa creerai

In questo lab configureremo l'ambiente in base alla seguente architettura:

Nell'ambito del lab configureremo i seguenti componenti ed eseguiremo le seguenti attività:

Crea un bucket Google Cloud Storage (GCS) per archiviare i video transcodificati in tempo reale
Configura l'API Live Streaming per transcodificare il video in più formati: HLS + MPEG DASH, SD e HD
Configurare i componenti del live streaming: input/canale
Avviare il canale live streaming
Configura Media CDN con il bucket GCS come origine
Configurare FFmpeg per alimentare il canale in diretta
Riprodurre in streaming il feed live transcodificato con un video player
Configura una dashboard di Cloud Monitoring per monitorare l'attività di Media CDN (latenza, hit della cache, mancate hit della cache e così via)

Nota: per questo lab, presupponiamo che gli utenti abbiano accesso alla console Google Cloud e che abbiano già configurato un progetto. Inoltre, presupponiamo che gli utenti inizino con un ambiente nuovo e non abbiano configurato nulla per questa demo.

Tutte le azioni di configurazione verranno eseguite tramite la riga di comando in Cloud Shell. Possiamo sempre controllare i componenti configurati tramite la riga di comando nella console. Durante il lab vedrai dei riferimenti alla console Google Cloud.

2. Prima di iniziare

L'accesso alla CDN multimediale è limitato. Per ottenere l'accesso a Media CDN, contatta il team dedicato al tuo account. Può creare una richiesta di accesso per tuo conto. Se fai parte di Google e vuoi testare il live streaming con Media CDN, contatta il PM di Media CDN per richiedere l'accesso a Media CDN.

3. Configurazione e requisiti

Avvia Cloud Shell

Sebbene Google Cloud possa essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Nella console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Dovrebbe richiedere solo pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere qualcosa di simile a questo:

Questa macchina virtuale contiene tutti gli strumenti di sviluppo di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione di rete. Tutto il lavoro in questo codelab può essere svolto in un browser. Non devi installare nulla.

4. Versione Google Cloud SDK

Al momento della stesura di questo documento, 408.0.0 è la versione più recente di Google Cloud SDK. Tutti i comandi di questo lab sono stati testati utilizzando la versione più recente del Google Cloud SDK. Prima di procedere, assicurati che Cloud Shell utilizzi la versione più recente dell'SDK.

Controllo della versione dell'SDK

Utilizzeremo il comando gcloud version per controllare la versione dell'SDK.

Comando

gcloud version | grep "Google Cloud SDK"

Esempio di output

Google Cloud SDK 408.0.0

Passaggi successivi

Se la versione dell'SDK è 408.0.0 o successiva, vai alla sezione successiva.
Se la versione dell'SDK è precedente a 408.0.0, esegui il comando elencato di seguito per aggiornare l'SDK.

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

5. Prerequisiti

Prima di iniziare a configurare le risorse Google Cloud, dobbiamo:

Configura le variabili di ambiente
Abilita le API di servizio richieste

1. Configura le variabili di ambiente

In questo lab, eseguiremo i comandi gcloud e curl con alcune variabili. Dobbiamo configurare le seguenti variabili di ambiente.

ID progetto
Numero progetto
Nome utente
Regione
ID input
ID canale

ID progetto e nome utente

Queste variabili di ambiente sono generalmente preconfigurate in Cloudshell. Utilizzeremo il comando env per la verifica.

Comando

env | grep -E 'DEVSHELL_PROJECT_ID=|LOGNAME'

Esempio di output

DEVSHELL_PROJECT_ID=<YOUR_PROJECT_ID>
LOGNAME=<YOUR_USERNAME>

Crea il file `env_variables`

Utilizza il comando cat per creare il file env_variables.txt. Il comando seguente crea il file env_variables.txt nella home directory dell'utente.

Comandi

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

Configura le variabili di ambiente

Useremo il comando source per impostare le variabili di ambiente

Comando

source ~/env_variables.txt

Verificare che le variabili siano impostate

Verifichiamo che tutte le variabili di ambiente richieste siano impostate. Dovresti vedere un totale di 6 variabili di ambiente nell'output.

Comando

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

Esempio di output

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. Abilita le API di servizio richieste

Dobbiamo assicurarci che le seguenti API siano abilitate nel nostro progetto.

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

Abilita l'API Network Services

Per abilitare l'API Network Services, esegui il seguente comando:

Comando

gcloud services enable networkservices.googleapis.com

Abilita l'API Certificate Manager

Per abilitare l'API Certificate Manager, esegui il comando seguente:

Comando

gcloud services enable certificatemanager.googleapis.com

Abilita l'API Live Stream

Per abilitare l'API Live Stream, esegui il comando seguente:

Comando

gcloud services enable livestream.googleapis.com

Abilita l'API Media CDN Edge Cache

Per abilitare l'API Media CDN Edge Cache, esegui il seguente comando:

Comando

gcloud services enable edgecache.googleapis.com

Verificare che le API siano abilitate

Esegui il comando gcloud services list per elencare tutte le API abilitate. Nell'output dovremmo vedere 4 API.

Comando

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

Esempio di output

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

6. Crea il bucket Cloud Storage

In questa sezione:

Crea un bucket Cloud Storage
Rendi il bucket accessibile pubblicamente

Più avanti nel lab, utilizzeremo questo bucket per archiviare i file video transcodificati. Questo bucket fungerà anche da spazio di archiviazione di origine per il servizio Media CDN.

1. Crea il bucket

Utilizzeremo il comando gsutil mb per creare il bucket:

Comando

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

2. Rendi il bucket pubblicamente accessibile

Utilizzeremo il comando gsutil iam per rendere i file disponibili pubblicamente:

Comando

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

7. Configurazione dell'ambiente dell'API Live Streaming

I componenti della catena di API di live streaming sono strutturati come segue:

Abbiamo creato il bucket Cloud Storage live-streaming-storage-$LOGNAME nella sezione precedente. Nelle due sezioni successive creeremo le seguenti risorse:

Input live streaming:un endpoint di input è un endpoint a cui il codificatore invia lo stream di input. Puoi utilizzare l'endpoint di input per specificare le configurazioni per lo stream, ad esempio la risoluzione di input, il tipo di input e il ritaglio del video.
Canale di live streaming:un canale è una risorsa che importa lo stream di input tramite un endpoint di input, lo transcodifica in più versioni e pubblica i live streaming di output in determinati formati nella posizione specificata. Puoi includere uno stream di input principale e uno di backup nello stesso canale.

Creeremo le seguenti risorse più avanti nel lab:

Codificatore:un codificatore è un programma utilizzato per inviare flussi di input. In questo lab utilizzeremo FFmpeg.

8. Crea e configura l'endpoint di input

Creare il file input.json

Creeremo un file input.json per specificare il tipo di segnale del live streaming. In questo lab utilizziamo l'indicatore in tempo reale RTMP.

Comando

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

Crea l'endpoint di input

Al momento della stesura di questo lab, non è previsto il supporto di gcloud per l'API Live Stream. Utilizzeremo il comando curl per effettuare le chiamate API.

Comando

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"

Esempio di output

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

L'output contiene molte informazioni utili, ma al momento dobbiamo concentrarci su due campi:

ID operazione:dall'output, copia e prendi nota dell'ID operazione. Di seguito è riportato l'ID operazione dell'esempio di output. Puoi trovarlo nella riga di output che inizia con "name". "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4"
Stato: dobbiamo attendere che lo stato passi da "done": false a "done": true

Controlla lo stato

Prima di procedere, dobbiamo verificare che l'endpoint di input sia stato creato correttamente e sia pronto.

Nel comando seguente, sostituisci <OPERATION> con l'ID dell'operazione che abbiamo appena ottenuto sopra. In questo esempio è "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4".

Comando

export OPERATION_ID_1=<OPERATION>

Comando

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"

Esempio di output

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

Esegui di nuovo il comando finché non viene visualizzato "done:true" a indicare che l'endpoint di input è stato creato ed è pronto.

Salva l'URI

Utilizzeremo URI dell'output precedente più avanti nel lab. Al momento, impostiamo una variabile di ambiente per URI.

Comando

export URI=<uri>

Sostituisci <uri> con l'URI che hai appena annotato sopra. Facoltativamente, puoi anche utilizzare il metodo GET per recuperare l'URI

Comando

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. Creare e configurare il canale di live streaming

Creiamo il canale di live streaming associato all'endpoint di input che abbiamo appena creato nella sezione precedente. L'esempio seguente crea un canale che genera un live streaming HLS composto da una singola rappresentazione ad alta definizione (1280 x 720). Il canale verrà associato all'endpoint di input e al bucket di archiviazione che abbiamo creato in precedenza.

Crea il file channel.json

Nel terminale Cloud Shell, digita il seguente comando per creare un file "channel.json":

Comando

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

Creare il canale

Esegui il seguente comando curl per creare il canale:

Comando

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"

Esempio di output

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

Prendi nota e copia l'ID operazione. Ne avremo bisogno in uno dei passaggi successivi. Puoi trovarlo nella riga di output che inizia con "name".

Controlla lo stato

Prima di procedere, dobbiamo verificare che il canale sia stato creato correttamente e sia pronto.

Nel comando seguente, sostituisci <OPERATION> con l'ID dell'operazione che abbiamo appena ottenuto sopra. In questo esempio è operation-1661405972853-5e70a38d6f27f-79100d00-310671b4

Comando

export OPERATION_ID_2=<OPERATION>

Comando

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"

Esempio di output

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

Esegui di nuovo il comando finché non viene visualizzato "done:true" a indicare che l'endpoint di input è stato creato ed è pronto.

Tieni presente che al momento il "streamingState" è "STOPPED". Avvieremo il canale nella sezione successiva.

10. Avviare il canale di live streaming

Ora che abbiamo creato il canale live streaming, avviamolo. In questa sezione:

Avviare il canale Live Streaming
Controlla lo stato del canale, dobbiamo assicurarci che streamingState sia "AWAITING INPUT"

1. Avvia il canale

In Cloud Shell, esegui il seguente comando curl per avviare il canale:

Comando

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"

Esempio di output

{
  "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. Controllare lo stato del canale

Esegui il seguente comando curl per ottenere lo stato del canale:

Comando

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"

Esempio di output

"streamingState": "AWAITING_INPUT",

Esegui di nuovo il comando finché non viene visualizzato "AWAITING_INPUT", a indicare che il canale è in esecuzione ed è pronto per ricevere un segnale.

11. Configura Media CDN

In questa sezione eseguiremo il deployment di Media CDN, l'infrastruttura CDN. Creeremo le seguenti risorse:

Origine cache perimetrale
Servizio cache perimetrale

1. Creare un'origine cache perimetrale

Un'origine della cache Edge rappresenta una posizione dei contenuti, ad esempio un bucket Cloud Storage, una posizione di archiviazione di terze parti o un bilanciatore del carico. In termini di CDN, l'origine (o il server di origine) è la posizione in cui si trova l'origine dei contenuti che vogliamo distribuire, ad esempio tutti i CSS, JavaScript, HTML, le immagini e così via. Per questo lab, creeremo un'origine che si mappa al bucket Cloud Storage che abbiamo creato all'inizio del lab. Chiameremo l'origine della cache perimetrale cme-origin. L'origine di una rete CDN è il luogo in cui vengono archiviati tutti i contenuti di origine prima di essere distribuiti ai server cache edge.

Utilizzeremo il comando gcloud edge-cache origins create per creare l'origine. Il completamento del comando richiederà alcuni minuti.

Comando

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

Output di esempio

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. Creare un servizio Edge Cache

Ora che abbiamo configurato un'origine cache perimetrale, possiamo creare il servizio cache perimetrale stesso.

Crea il file `cme-demo.yaml`

La configurazione del servizio Edge Cache viene eseguita tramite un file YAML. In Cloud Shell, crea un file locale denominato cme-demo.yaml. Utilizza vi, nano o qualsiasi altro editor e incolla le seguenti righe nel file 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

Lasceremo invariate tutte le impostazioni predefinite del servizio Edge Cache. Nel file riportato sopra sono presenti tre valori di campo che gli utenti potrebbero voler aggiornare:

name: il nome dell'istanza Media CDN, in questo caso cme-demo
hosts: l'elenco dei nomi di dominio che verranno risolti da questo servizio Media CDN: demo.cme.com. Lo utilizzeremo durante questa demo. Utilizzeremo l'indirizzo IP dell'istanza Media CDN.
Origin: questa è l'origine cache perimetrale che abbiamo appena creato nel passaggio precedente. Impostalo su cme-origin, il nome dell'origine Media CDN.

Per ulteriori informazioni sulle diverse variabili che puoi utilizzare nel file YAML, consulta la guida alla configurazione del servizio Edge Cache.

Crea il servizio Edge Cache

Creeremo un servizio Edge Cache denominato cme-demo nell'origine cache perimetrale cme-origin con host demo.cme.com. Per creare il servizio, esegui il seguente comando in Cloud Shell:

Comando

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

La creazione del servizio cache perimetrale potrebbe richiedere alcuni minuti.

Esempio di output

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'

Prendi nota e copia il ipv4Addresses dell'istanza del servizio Edge Cache, qui 34.104.36.157. Lo utilizzeremo per aggiornare il file cme-demo.yaml e in un secondo momento per riprodurre in streaming il video transcodificato.

Aggiorna il servizio Edge Cache

A questo punto, è buona norma aggiornare la configurazione del servizio Edge Cache per poter utilizzare l'IP del servizio per lo streaming del video in un secondo momento. Il file YAML del servizio cache perimetrale ci consente di elencare tutti i nomi/IP host da cui il servizio cache perimetrale accetterà le richieste. A questo punto abbiamo specificato solo demo.cme.com come host. Per fornire la risoluzione dei nomi per questo dominio, puoi configurare una zona DNS. Tuttavia, una soluzione più semplice sarebbe aggiungere l'indirizzo IP all'elenco di host nel file yaml. Modifica di nuovo il file YAML in modo che assuma il seguente aspetto:

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

Per applicare le modifiche, dobbiamo solo importare nuovamente il file YAML. Nel terminale Cloud Shell, esegui il seguente comando:

Comando

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

Controlla l'output del comando e verifica che l'IP sia presente nell'elenco degli host.

A questo punto, l'istanza di Edge Cache Service accetterà le richieste con "demo.cme.com" o l'indirizzo IP come host.

12. Genera l'indicatore di input

Ora che abbiamo configurato tutti i servizi richiesti, generiamo il segnale di input del live streaming. In questa sezione:

Installa FFmpeg, un software open source senza costi
Invia un segnale di test in tempo reale all'input/al canale

1. Installa FFmpeg

FFmpeg è un progetto di software open source senza costi composto da una suite di librerie e programmi per la gestione di file e stream video, audio e multimediali. Nel terminale Cloud Shell, utilizza il seguente comando per installare FFmpeg:

Comando

sudo apt install ffmpeg -y

Al termine dell'installazione, verifica che FFmpeg sia stato installato correttamente controllandone la versione:

Comando

ffmpeg -version

Esempio di output

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

FFmpeg è stato installato correttamente.

2. Avvia l'indicatore del live streaming all'ingresso/al canale.

Ora che FFmpeg è installato, invieremo un flusso di input di test all'endpoint di input per generare il live streaming.

Nel terminale Cloud Shell, esegui il seguente comando utilizzando la variabile di ambiente URI che abbiamo creato nella sezione "Crea e configura l'endpoint di input".

Comando

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

Dovresti vedere FFmpeg che invia l'indicatore di live test. Il comando non restituirà il prompt. L'indicatore verrà generato finché non lo interrompi. Dovrai aprire una nuova finestra Cloud Shell per il resto del lab.

13. Apri nuova Cloud Shell

A questo punto dovrai aprire una nuova finestra Cloud Shell per continuare il lab, poiché FFmpeg verrà eseguito in modo permanente finché non premi <CTRL+C> per interrompere il comando e quindi la generazione del segnale in tempo reale.

Fai clic sul segno "+" accanto al nome del terminale Cloud Shell corrente. Si aprirà un'altra finestra di Cloud Shell.

Esegui il resto del laboratorio nella finestra Cloud Shell appena aperta.

Configura le variabili di ambiente

Poiché si tratta di una nuova Cloud Shell, dobbiamo impostare di nuovo le variabili di ambiente. Utilizzeremo il comando source per impostare le variabili di ambiente.

Comando

source ~/env_variables.txt

Verificare che le variabili siano impostate

Verifichiamo che tutte le variabili di ambiente richieste siano impostate. Dovresti vedere un totale di 6 variabili di ambiente nell'output.

Comando

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

Esempio di output

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. Verificare che il segnale dal vivo venga transcodificato

Eseguiremo un curl per descrivere il canale. Nell'output dovremmo vedere che streamingState è passato da "AWAITING_INPUT" a "STREAMING"

Comando

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"

Nella risposta del file JSON di output dovresti vedere "streamingState": "STREAMING", che indica che il canale è in streaming e che il segnale dal vivo viene transcodificato.

Verifichiamo anche i contenuti del bucket, dove dovremmo trovare un file manifest e diversi segmenti video TS. Esegui il comando seguente in Cloud Shell per elencare i contenuti del bucket che abbiamo creato all'inizio del lab e utilizzato dall'API Live Streaming per generare il manifest del segnale dal vivo e i segmenti video TS transcodificati:

Comando

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

Esempio di output

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

Dovresti vedere:

il file manifest HLS: main.m3u8
I segmenti video TS corrispondenti: una serie di file numerati segment-000000000X.ts

A questo punto abbiamo completato quanto segue:

API Live Streaming: il segnale in diretta viene generato e transcodificato in un bucket tramite l'API Live Streaming
Media CDN: configura Media CDN con il bucket di archiviazione Live Streaming come origine di Media CDN.

Nelle sezioni successive convalideremo il servizio Edge Cache e poi trasmetteremo in streaming il video transcodificato utilizzando l'indirizzo IP anycast della Media CDN.

15. Verificare il funzionamento dell'istanza del servizio Edge Cache

In questa sezione verificheremo che l'istanza del servizio di cache perimetrale funzioni come previsto. A tale scopo, tenteremo di accedere a un file dall'istanza del servizio Edge Cache utilizzando l'indirizzo IP del servizio. La prima volta che si accede a un oggetto, non viene ancora memorizzato nella cache. Dovremmo osservare una cache MISS. Per la prima richiesta, l'oggetto viene letto dall'origine e memorizzato nella cache all'edge. Tutti i tentativi successivi di accedere allo stesso file restituiranno una cache HIT poiché l'oggetto è ora memorizzato nella cache all'edge. Vediamo come funziona:

Esegui il seguente comando curl in Cloud Shell per accedere al file manifest video transcodificato archiviato nell'origine cache Edge:

Comando

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

Tieni presente la risoluzione in cui utilizziamo l'indirizzo IP dell'istanza del servizio Edge Cache per risolvere il nome. Assicurati di utilizzare demo.cme.com:<IP>, dove IP è l'indirizzo IP dell'istanza del servizio Edge Cache che abbiamo appena creato.

Cerca l'intestazione x-cache-status nell'output.

Esempio di output

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

Tieni presente la mancata corrispondenza della cache perché l'oggetto non è ancora stato memorizzato nella cache e viene letto dall'origine.

Ora effettueremo più richieste per il file m3u8 e, se tutto è configurato correttamente, la CDN Media dovrebbe iniziare a pubblicare i contenuti dalla cache. Il comando riportato di seguito invierà 10 richieste curl e stamperà solo l'intestazione x-cache-status.

Comando

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

L'output dovrebbe essere un mix di cache hit e miss. Se visualizzi hit della cache nell'output, significa che Media CDN funziona come previsto.

Esempio di output

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

Nota l'hit della cache perché l'oggetto ora è memorizzato nella cache all'edge. Il servizio Cloud Media Edge funziona come previsto.

16. Riprodurre in streaming il video del segnale dal vivo transcodificato con VLC

Questa è la parte in cui colleghiamo i puntini e colleghiamo tutti i passaggi su cui abbiamo lavorato finora:

Abbiamo creato un bucket denominato live-streaming-storage-$LOGNAME che riceve il risultato del segnale dal vivo transcodificato in contenuti HLS dall'API Live Streaming.
Abbiamo configurato l'API Live Streaming.
Abbiamo avviato un segnale RTMP dal vivo con FFmpeg che alimenta l'input/il canale dell'API Live Streaming.
Abbiamo verificato che l'indicatore in tempo reale sia stato inviato al canale e che il canale fosse in modalità streaming.
Abbiamo verificato che i file transcodificati risultanti (manifest + segmenti TS) siano stati generati e archiviati nel bucket live-streaming-storage-$LOGNAME.
È stata configurata un'origine cache perimetrale denominata cme-origin con il bucket GCS live-streaming-storage-$LOGNAME come origine.
È stata configurata un'istanza Edge Cache denominata cme-demo con cme-origin come origine.
Abbiamo verificato il comportamento (mancata corrispondenza nella cache, hit nella cache) dell'istanza del servizio Edge Cache.

Ora possiamo utilizzare un video player per trasmettere in streaming l'indicatore in diretta transcodificato tramite la cache Media CDN. A questo scopo utilizzeremo VLC Player. VLC Player è un framework e un player multimediale multipiattaforma senza costi e open source che riproduce la maggior parte dei file multimediali. Riproduce formati multimediali adattivi (come DASH e HLS). Utilizza il principio dello streaming adattivo: in base alla qualità della connessione di rete e alla larghezza di banda disponibile, il player adeguerà la qualità del video riprodotto. Con il processo di transcodifica che abbiamo appena eseguito, abbiamo utilizzato le preimpostazioni predefinite e generato "solo" due qualità: SD e HD. Quando iniziamo a riprodurre il video nel player, dovresti vedere che inizia a essere riprodotto in formato SD e passa rapidamente al formato HD se la connessione di rete è sufficientemente buona.

Trasmetteremo in streaming il segnale live transcodificato HLS (formato video Apple ampiamente supportato). Il file corrispondente si chiama main.m3u8 ed è il manifest HLS. Il manifest rimanda ai segmenti video TS.

Per utilizzare VLC Player, vai alla pagina https://www.videolan.org/vlc/ e scarica una versione del player per il sistema operativo del tuo laptop. VLC è disponibile per Windows, MacOSX, Linux, Android e iOS.

Installa il Player sul laptop e avvialo. Per i passaggi successivi utilizzeremo la versione per macOSX del player.

Per riprodurre un video, vai a "File" / "Apri emittente":

Configuralo con:

URL: http://<Replace_With_Edge_Cache_IP>/main.m3u8. Questo è l'URL del video che vogliamo riprodurre in streaming. Attenzione:
L'IP dell'istanza Media CDN: 34.105.35.246. Sostituisci con l'IP del servizio Cloud Media che hai disegnato.
Il percorso del file video manifest: "/". Questo è il percorso utilizzato nel bucket live-streaming-storage-$LOGNAME per archiviare i file di indicatori live transcodificati. Il percorso è il percorso principale: "/".
Il nome del file video manifest: il file manifest HLS, main.m3u8.

e fai clic su "Apri". Dovresti vedere che il video live transcodificato inizia a essere riprodotto. Il video avrà l'aspetto dello screenshot riportato di seguito. Il contatore sullo schermo verrà eseguito con incrementi di 1 e dovresti sentire un beep continuo.

Si tratta di un segnale in diretta di test RTMP di base generato da FFmpeg, transcodificato in HLS dall'API Live Streaming e pubblicato tramite la cache Media CDN:

Se vuoi, puoi utilizzare qualsiasi altro player HLS e MPEG DASH. Ecco alcuni che potresti prendere in considerazione:

Quicktime Player, installato per impostazione predefinita sui Mac. Lo stesso qui: apri una connessione di rete a http://34.104.36.157/main.m3u8. Sostituisci l'indirizzo IP con quello della tua istanza Edge Cache Service.

17. Monitoraggio di Media CDN

Il team di esperti in materia ha creato un modello di dashboard Media CDN: https://gist.github.com/elithrar/1c511d00f5cd3736fb2a3897867209c1.

Per installarlo, esegui i seguenti comandi nella finestra Cloud Shell:

Scarica il file YAML:

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

Crea la dashboard per Cloud Monitoring:

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

La configurazione potrebbe richiedere alcuni minuti. Vai alla console Google Cloud e fai clic sulle tre barre > Operations > Monitoring > Dashboard. Dovresti vedere una dashboard denominata "Metriche Media Edge". Fai clic su questa opzione per visualizzare le metriche:

18. Ripulire l'ambiente del lab

Complimenti per aver completato il lab. In questa sezione elimineremo tutte le risorse create durante il lab.

Interrompi l'indicatore FFmpeg:

Premi <CTRL+C> sul terminale Cloud Shell in cui è in esecuzione FFmpeg.

Interrompi il canale di live streaming:

Comando

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"

Elimina il canale di live streaming:

Comando

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"

Elimina l'endpoint di input del live streaming:

Comando

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"

Elimina il bucket GCS:

Comando

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

Elimina l'istanza del servizio cache perimetrale:

Comando

gcloud edge-cache services delete cme-demo

Conferma l'eliminazione inserendo "Y" quando richiesto

Elimina l'origine della cache perimetrale:

Comando

gcloud edge-cache origins delete cme-origin

Conferma l'eliminazione inserendo "Y" quando richiesto

Eliminare la dashboard personalizzata

Comando

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

Live streaming su Google Cloud con Media CDN e API Live Streaming

1. Introduzione

Obiettivi didattici

Cosa creerai

2. Prima di iniziare

3. Configurazione e requisiti

Avvia Cloud Shell

4. Versione Google Cloud SDK

Controllo della versione dell'SDK

Passaggi successivi

5. Prerequisiti

1. Configura le variabili di ambiente

ID progetto e nome utente

Crea il file env_variables

Configura le variabili di ambiente

Verificare che le variabili siano impostate

2. Abilita le API di servizio richieste

Abilita l'API Network Services

Abilita l'API Certificate Manager

Abilita l'API Live Stream

Abilita l'API Media CDN Edge Cache

Verificare che le API siano abilitate

6. Crea il bucket Cloud Storage

1. Crea il bucket

2. Rendi il bucket pubblicamente accessibile

7. Configurazione dell'ambiente dell'API Live Streaming

8. Crea e configura l'endpoint di input

Creare il file input.json

Crea l'endpoint di input

Controlla lo stato

Salva l'URI

9. Creare e configurare il canale di live streaming

Crea il file channel.json

Creare il canale

Controlla lo stato

10. Avviare il canale di live streaming

1. Avvia il canale

2. Controllare lo stato del canale

11. Configura Media CDN

1. Creare un'origine cache perimetrale

2. Creare un servizio Edge Cache

Crea il file cme-demo.yaml

Crea il servizio Edge Cache

Aggiorna il servizio Edge Cache

12. Genera l'indicatore di input

1. Installa FFmpeg

2. Avvia l'indicatore del live streaming all'ingresso/al canale.

13. Apri nuova Cloud Shell

Configura le variabili di ambiente

Verificare che le variabili siano impostate

14. Verificare che il segnale dal vivo venga transcodificato

15. Verificare il funzionamento dell'istanza del servizio Edge Cache

16. Riprodurre in streaming il video del segnale dal vivo transcodificato con VLC

17. Monitoraggio di Media CDN

18. Ripulire l'ambiente del lab

Interrompi l'indicatore FFmpeg:

Interrompi il canale di live streaming:

Elimina il canale di live streaming:

Elimina l'endpoint di input del live streaming:

Elimina il bucket GCS:

Elimina l'istanza del servizio cache perimetrale:

Elimina l'origine della cache perimetrale:

Eliminare la dashboard personalizzata

Crea il file `env_variables`

Crea il file `cme-demo.yaml`