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

1. Introduzione

Le Content Delivery Network (CDN) 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 conseguente miglioramento delle vendite, dell'esperienza web e un aumento netto dell'esperienza utente. Al giorno d'oggi, pochissimi siti moderni e piattaforme di streaming video funzionano senza una CDN.

Obiettivi didattici

Questo lab ci guiderà attraverso i passaggi per implementare un ambiente di flusso di lavoro di live streaming con Media CDN (CDN) + API Cloud Media Live Streaming (transcodifica video live) + Cloud Storage (storage per i video) + Video Player (VLC, Google Shaka Player e così via - player pronto per HLS + MPEG-DASH).

Configureremo i componenti dell'API Live Streaming (input, canale) e avvieremo un feed live all'input/al canale con FFmpeg (FFmpeg può generare un segnale di test live). L'API Live Streaming transcodificherà il feed live. Il manifest e i segmenti del video transcodificato verranno archiviati in un bucket Cloud Storage. Poi configureremo Media CDN con il bucket Cloud Storage del video live come origine. Infine, VLC Player verrà utilizzato per riprodurre i contenuti live memorizzati nella cache tramite la CDN per i contenuti multimediali. Configureremo 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:

Configureremo i seguenti componenti ed eseguiremo le seguenti attività nell'ambito del lab:

Crea un bucket Google Cloud Storage (GCS) per archiviare i video transcodificati live
Configura l'API Live Streaming per transcodificare il video in più formati: HLS + MPEG DASH, SD e HD
Configura 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 live
Riproduci in streaming il feed live transcodificato con un lettore video
Configura una dashboard di Cloud Monitoring per monitorare l'attività di Media CDN (latenza, hit della cache, mancata corrispondenza 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. Supponiamo inoltre 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. Nel lab vedrai dei suggerimenti che ti indirizzeranno alla console Google Cloud.

2. Prima di iniziare

L'accesso alla CDN dei contenuti multimediali è limitato. Per accedere a Media CDN, contatta il team dedicato al tuo account. Possono 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 gestito 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:

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere un risultato simile a questo:

Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori 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 della rete. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non devi installare nulla.

4. Versione di Google Cloud SDK

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

Controllare la 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 successive, vai alla sezione successiva.
Se la versione dell'SDK è precedente alla 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 GCP, dobbiamo fare quanto segue:

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 Cloud Shell. 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 riportato di seguito creerà 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

Utilizzeremo il comando source per impostare le variabili di ambiente

Comando

source ~/env_variables.txt

Verifica che le variabili siano impostate

Verifichiamo che tutte le variabili di ambiente richieste siano impostate. Nell'output dovremmo visualizzare un totale di sei variabili di ambiente.

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 questo comando:

Comando

gcloud services enable networkservices.googleapis.com

Abilita l'API Certificate Manager

Per abilitare l'API Certificate Manager, esegui questo comando:

Comando

gcloud services enable certificatemanager.googleapis.com

Abilita l'API Live Stream

Per abilitare l'API Live Stream, esegui questo comando:

Comando

gcloud services enable livestream.googleapis.com

Abilita l'API Media CDN Edge Cache

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

Comando

gcloud services enable edgecache.googleapis.com

Verifica che le API siano abilitate

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

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 faremo quanto segue:

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. Rendere il bucket accessibile pubblicamente

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 API Live Streaming

I componenti della catena dell'API Live Streaming sono strutturati nel seguente modo:

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

Input live streaming:un endpoint di input è un endpoint a cui il codificatore invia il flusso 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 acquisisce 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ù tardi 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 di live streaming. In questo lab, utilizziamo il segnale live RTMP.

Comando

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

Crea l'endpoint di input

Al momento della stesura di questo lab, non è disponibile 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 annota l'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 cambi da "done": false a "done": true

Controllare 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 dall'output precedente più avanti nel lab. A questo punto, impostiamo una variabile di ambiente per URI.

Comando

export URI=<uri>

Sostituisci <uri> con l'URI che hai annotato sopra. Facoltativamente, puoi utilizzare anche 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 costituito da un'unica riproduzione ad alta definizione (1280x720). 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 questo 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 questo 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".

Controllare 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 "streamingState" è "STOPPED". Inizieremo il canale nella sezione successiva.

10. Avviare il canale Live Streaming

Ora che abbiamo creato il nostro canale Live Stream, avviamolo. In questa sezione, faremo quanto segue:

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

1. Avviare il canale

In Cloud Shell, esegui questo 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 questo 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 nuovamente il comando finché non viene visualizzato "AWAITING_INPUT", a indicare che il canale è in esecuzione e pronto a ricevere un segnale.

11. Configura Media CDN

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

Origine della edge cache
Servizio di edge cache

1. Crea un'origine edge cache

Un'origine Edge Cache 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, i JavaScript, l'HTML, le immagini e così via. Per questo lab, creeremo un'origine che esegue il mapping al bucket Cloud Storage che abbiamo creato all'inizio del lab. Chiameremo l'origine della cache perimetrale cme-origin. L'origine di una CDN è il luogo in cui vengono archiviati tutti i contenuti di origine prima di essere distribuiti ai server di cache perimetrale.

Utilizzeremo il comando gcloud edge-cache origins create per creare l'origine. Il completamento del comando richiede 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. Crea un servizio Edge Cache

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

Creare 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 di configurazione del servizio Edge Cache. Nel file riportato sopra, gli utenti potrebbero voler aggiornare tre valori dei campi:

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. In questo caso: demo.cme.com. Lo utilizzeremo durante questa demo. Utilizzeremo l'indirizzo IP dell'istanza Media CDN.
Origin: è l'origine della cache perimetrale che abbiamo appena creato nel passaggio precedente. Imposta il valore su cme-origin - nome dell'origine Media CDN.

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

Crea il servizio Edge Cache

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

Comando

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

La creazione del servizio di 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 l'ipv4Addresses dell'istanza del servizio Edge Cache, qui 34.104.36.157. Lo utilizzeremo per aggiornare il file cme-demo.yaml e in seguito per riprodurre in streaming il video transcodificato.

Aggiorna il servizio Edge Cache

A questo punto, è consigliabile aggiornare la configurazione del servizio di edge cache per poter utilizzare l'IP del servizio per lo streaming del video in un secondo momento. Il file YAML del servizio edge cache ci consente di elencare tutti i nomi/IP host da cui il servizio edge cache 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 degli host nel file yaml. Modifica di nuovo il file YAML in modo che sia simile a quello riportato di seguito:

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 riflettere le modifiche, è sufficiente reimportare il file YAML. Nel terminale Cloud Shell, esegui questo comando:

Comando

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

Controlla l'output del comando e verifica che l'IP venga visualizzato nell'elenco degli host.

A questo punto, l'istanza del servizio di edge cache 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, faremo quanto segue:

Installa FFmpeg, un software open source senza costi
Invia un segnale live di test all'input/canale

1. Installare FFmpeg

FFmpeg è un progetto software open source senza costi costituito da una suite di librerie e programmi per la gestione di video, audio e altri file e stream 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 Live Stream Signal to the Input/Channel

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

Nel terminale Cloud Shell, esegui il comando seguente utilizzando la variabile di ambiente URI creata 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 inviare il segnale di test in diretta. Il comando non restituirà il prompt. Il segnale verrà generato finché non lo interrompi. Per il resto del lab, dovrai aprire una nuova finestra di Cloud Shell.

13. Apri New Cloud Shell

A questo punto, devi aprire una nuova finestra di 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 live.

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

Esegui il resto del lab nella finestra di Cloud Shell appena aperta.

Configura le variabili di ambiente

Poiché questa è una nuova Cloud Shell, dobbiamo impostare nuovamente le variabili di ambiente. Utilizzeremo il comando source per impostare le variabili di ambiente.

Comando

source ~/env_variables.txt

Verifica che le variabili siano impostate

Verifichiamo che tutte le variabili di ambiente richieste siano impostate. Nell'output dovremmo visualizzare un totale di sei variabili di ambiente.

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. Verifica che il segnale live venga transcodificato

Eseguiremo un curl per descrivere il canale. Nell'output dovremmo vedere che streamingState è cambiato 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 visualizzare "streamingState": "STREAMING", che indica che il canale sta trasmettendo in streaming e che il segnale live viene transcodificato.

Verifichiamo anche i contenuti del bucket in cui dovremmo vedere un file manifest e diversi segmenti video TS. Esegui il seguente comando 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 live transcodificato e i segmenti video TS:

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 le seguenti operazioni:

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

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

15. Verifica che l'istanza del servizio Edge Cache funzioni

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

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

Comando

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

Nota la risoluzione in cui utilizziamo l'indirizzo IP dell'istanza del servizio Edge Cache per risolvere il relativo nome. Assicurati di utilizzare demo.cme.com:<IP>, dove IP è l'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

Nota l'errore della cache, poiché 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, Media CDN dovrebbe iniziare a pubblicare i contenuti dalla cache. Il comando riportato di seguito effettuerà 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 nell'output vengono visualizzati successi della cache, 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, poiché l'oggetto ora è memorizzato nella cache perimetrale. Cloud Media Edge Service funziona come previsto.

16. Riproduci in streaming il video del segnale live transcodificato con VLC

In questa parte colleghiamo i puntini e uniamo tutti i passaggi su cui abbiamo lavorato finora:

Abbiamo creato un bucket denominato live-streaming-storage-$LOGNAME che riceve il risultato del segnale live transcodificato in contenuti HLS dall'API Live Streaming.
Abbiamo configurato l'API Live Streaming.
Abbiamo avviato un segnale live RTMP con FFmpeg che alimenta l'input/il canale dell'API Live Streaming.
Abbiamo verificato che il segnale live 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 edge cache denominata cme-origin con il bucket GCS live-streaming-storage-$LOGNAME come origine.
È stata configurata un'istanza di Edge Cache denominata cme-demo con cme-origin come origine.
Abbiamo verificato il comportamento (cache miss, cache hit) dell'istanza del servizio Edge Cache.

Ora possiamo utilizzare un video player per riprodurre in streaming il segnale live transcodificato tramite la cache di Media CDN. Per farlo, utilizzeremo VLC Player. VLC Player è un framework e 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 adatta la qualità del video riprodotto. Con il job di transcodifica appena eseguito, abbiamo utilizzato i preset predefiniti e generato "solo" due qualità: SD e HD. Quando il video inizia a essere riprodotto nel player, dovresti vederlo in formato SD e passare rapidamente al formato HD se la connessione di rete è sufficiente.

Trasmetteremo in streaming il segnale live transcodificato HLS (formato video Apple ampiamente supportato). Il file corrispondente si chiama main.m3u8, ovvero il manifest HLS. Il manifest punta 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. Utilizzeremo la versione MacOSX del player per i prossimi passaggi.

Per riprodurre un video, vai su "File" / "Apri rete":

Configuralo con:

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

e fai clic su "Apri". Dovresti vedere l'inizio della riproduzione del video live transcodificato. Il video avrà un aspetto simile a quello dello screenshot riportato di seguito. Il contatore sullo schermo aumenterà di 1 e dovresti sentire un segnale acustico continuo.

Si tratta di un segnale live 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. Anche qui: apri una connessione di rete a http://34.104.36.157/main.m3u8. Sostituisci l'indirizzo IP con quello della tua istanza di Edge Cache Service.

17. Monitoraggio di Media CDN

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

Per installarlo, esegui questi 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 > Operazioni > Monitoring > Dashboard. Dovresti visualizzare una dashboard chiamata "Metriche Edge media". Fai clic su questo elemento per visualizzare le metriche:

18. Pulisci l'ambiente del lab

Complimenti per aver completato il lab. In questa sezione elimineremo tutte le risorse che abbiamo creato durante il lab.

Interrompi il segnale FFmpeg:

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

Interrompere 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 di edge cache:

Comando

gcloud edge-cache services delete cme-demo

Conferma l'eliminazione inserendo "Y" quando ti viene richiesto

Elimina l'origine della cache perimetrale:

Comando

gcloud edge-cache origins delete cme-origin

Conferma l'eliminazione inserendo "Y" quando ti viene 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 di Google Cloud SDK

Controllare la 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

Verifica 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

Verifica che le API siano abilitate

6. Crea il bucket Cloud Storage

1. Crea il bucket

2. Rendere il bucket accessibile pubblicamente

7. Configurazione dell'ambiente API Live Streaming

8. Crea e configura l'endpoint di input

Creare il file input.json

Crea l'endpoint di input

Controllare lo stato

Salva l'URI

9. Creare e configurare il canale di live streaming

Crea il file channel.json

Creare il canale

Controllare lo stato

10. Avviare il canale Live Streaming

1. Avviare il canale

2. Controllare lo stato del canale

11. Configura Media CDN

1. Crea un'origine edge cache

2. Crea un servizio Edge Cache

Creare il file cme-demo.yaml

Crea il servizio Edge Cache

Aggiorna il servizio Edge Cache

12. Genera l'indicatore di input

1. Installare FFmpeg

2. Avvia Live Stream Signal to the Input/Channel

13. Apri New Cloud Shell

Configura le variabili di ambiente

Verifica che le variabili siano impostate

14. Verifica che il segnale live venga transcodificato

15. Verifica che l'istanza del servizio Edge Cache funzioni

16. Riproduci in streaming il video del segnale live transcodificato con VLC

17. Monitoraggio di Media CDN

18. Pulisci l'ambiente del lab

Interrompi il segnale FFmpeg:

Interrompere 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 di edge cache:

Elimina l'origine della cache perimetrale:

Eliminare la dashboard personalizzata

Crea il file `env_variables`

Creare il file `cme-demo.yaml`