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 frequentemente più vicino agli utenti finali, interrompendo le connessioni più vicine ai client, riutilizzando le connessioni all'origine e attraverso l'adozione di protocolli di rete e personalizzazioni moderni. Per gli utenti (e i nostri clienti), ciò si traduce in minore latenza, maggiore affidabilità e costi ridotti, con conseguente miglioramento delle vendite, dell'esperienza sul web e un netto aumento dell'esperienza utente. Al giorno d'oggi pochissimi siti e piattaforme di streaming video moderni funzionano senza una CDN.

Obiettivi didattici

Questo lab ci guiderà attraverso i passaggi per eseguire il deployment di un ambiente di flusso di lavoro per live streaming con Media CDN (CDN) + API Cloud Media Live Streaming (transcodifica video in tempo reale) + Cloud Storage (archiviazione per i video) + Video Player (VLC, Google Shaka Player ecc - HLS + player pronto per MPEG-DASH).

Imposteremo i componenti dell'API Live Streaming, Input, Channel, e avvieremo un feed live verso l'ingresso/il canale con FFmpeg (FFmpeg può generare un segnale di test live). L'API Live Streaming transcodifica il feed live. Il manifest e i segmenti del video transcodificati verranno archiviati in un bucket Cloud Storage. Quindi configureremo Media CDN con il bucket Cloud Storage del video in diretta come origine. Infine, VLC Player verrà utilizzato per riprodurre i contenuti in tempo reale memorizzati nella cache tramite Media CDN. Configureremo inoltre 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:

Come parte del lab, configureremo i seguenti componenti ed eseguiremo le seguenti attività:

Crea un bucket Google Cloud Storage (GCS) per archiviare i video transcodificati dal vivo
Configura l'API Live Streaming per transcodificare il video in più formati: HLS + MPEG DASH, SD e HD
Impostazione dei componenti Live Streaming: Ingresso/Canale
Avviare il canale in live streaming
Configura Media CDN con il bucket GCS come origine
Configurare FFmpeg per il feed del canale live
Trasmettere in streaming il feed live transcodificato con un video player
Configura una dashboard di Cloud Monitoring per monitorare l'attività di Media CDN (latenza, successo della cache, fallimento della cache e così via)

Nota: per questo lab, supponiamo che gli utenti abbiano accesso alla console Google Cloud e abbiano già configurato un progetto. Inoltre, supponiamo che gli utenti inizino con un ambiente nuovo e che 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 vedremo dei puntatori che rimanderanno alla console Google Cloud.

2. Prima di iniziare

L'accesso a Media CDN è 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

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

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

Dovrebbe richiedere solo qualche istante per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere una schermata simile al seguente:

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

4. Versione Google Cloud SDK

Al momento della scrittura, 408.0.0 è la versione più recente dell'SDK Google Cloud. Tutti i comandi in questo lab sono stati testati utilizzando l'ultima versione di Google Cloud SDK. Prima di procedere, assicurati che Cloud Shell stia utilizzando la versione più recente dell'SDK.

Controllare la versione dell'SDK

Utilizzeremo il comando gcloud version per verificare 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 indicato 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, è necessario:

Configura le variabili di ambiente
Abilita le API di servizio richieste

1. Configura le variabili di ambiente

Nel corso di 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`

Usa il comando cat per creare il file env_variables.txt. Il comando seguente 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

Verifica che tutte le variabili di ambiente richieste siano impostate. Dovremmo 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 API seguenti 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 il comando seguente:

Comando

gcloud services enable certificatemanager.googleapis.com

Attivare 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 il comando seguente:

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

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 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. Configurare l'ambiente dell'API Live Streaming

I componenti della catena dell'API Live Streaming sono strutturati come segue:

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

Input di 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 dello stream, ad esempio risoluzione di input, tipo di input e ritaglio video.
Canale di live streaming:un canale è una risorsa che importa lo stream di input attraverso un endpoint di input, transcodifica lo stream di input in più versioni e pubblica 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 stream di input. In questo lab utilizzeremo FFmpeg.

8. Crea e configura l'endpoint di input

Crea il file input.json

Verrà creato un file input.json per specificare il tipo di indicatore del live streaming. In questo lab utilizzeremo il segnale in tempo reale RTMP.

Comando

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

Crea l'endpoint di input

Alla scrittura 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: nell'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 passi da "done": false a "done": true

Verifica 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 appena eseguita. 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 vedi "done:true" che indica che l'endpoint di input è stato creato ed è pronto.

Salva l'URI

Più avanti nel lab utilizzeremo il valore URI dell'output precedente. A questo punto, impostiamo una variabile di ambiente per URI.

Comando

export URI=<uri>

Sostituisci <uri> con l'URI di cui hai parlato 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. Crea e Configurare il canale di live streaming

Creiamo il canale Live Streaming, associato all'endpoint di input appena creato nella sezione precedente. Il seguente esempio crea un canale che genera un live streaming HLS composto da una singola rappresentazione in 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 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

Crea 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 prossimi passaggi. Puoi trovarlo nella riga di output che inizia con "name".

Verifica 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 appena riportata 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 vedi "done:true" che indica che l'endpoint di input è stato creato ed è pronto.

Tieni presente che il valore di "streamingState" al momento è "STOPPED"; daremo inizio al canale nella prossima sezione.

10. Avviare il canale in live streaming

Ora che abbiamo creato il nostro canale Live Stream, possiamo avviarlo. In questa sezione, eseguiremo le seguenti operazioni:

Avviare il canale in live streaming
Controlla lo stato del canale, dobbiamo assicurarci che streamingState sia "AWAITING INPUT"

1. Avvia 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. Verifica 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 di nuovo il comando finché non vedi "AWAITING_INPUT" che indica che il canale è attivo ed è 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 cache perimetrale
Servizio cache perimetrale

1. Crea un'origine della cache perimetrale

Un'origine della cache perimetrale rappresenta una località del contenuto, 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 server di origine) è la posizione in cui si trova l'origine dei contenuti che vogliamo distribuire, ad esempio tutti i CSS, JavaScript, HTML, immagini e così via. Per questo lab creeremo un'origine che viene mappata al bucket Cloud Storage creato all'inizio del lab. Chiameremo l'origine della cache perimetrale cme-origin. L'origine di una CDN è quella in cui tutti i contenuti di origine vengono archiviati 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 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. Crea un servizio di cache perimetrale

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

Crea il file `cme-demo.yaml`

La configurazione del servizio di cache perimetrale viene eseguita tramite un file YAML. In Cloud Shell, crea un file locale denominato cme-demo.yaml. Usa 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 tutte le impostazioni predefinite di configurazione del servizio cache perimetrale. Il file riportato sopra contiene tre valori di campo che gli utenti potrebbero voler aggiornare:

name: il nome dell'istanza Media CDN. Qui: cme-demo
hosts: l'elenco dei nomi di dominio che verranno risolti da questo servizio Media CDN, qui: demo.cme.com. Lo utilizzeremo durante la demo. Utilizzeremo l'indirizzo IP dell'istanza Media CDN.
Origin: questa è l'origine della cache perimetrale che abbiamo appena creato nel passaggio precedente. Impostalo su cme-origin, il nome dell'origine di 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 di cache perimetrale

Creeremo un servizio di cache perimetrale denominato cme-demo, sull'origine della cache perimetrale 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 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 valore ipv4Addresses dell'istanza del servizio cache perimetrale - qui 34.104.36.157. Lo utilizzeremo per aggiornare il file cme-demo.yaml e successivamente per lo streaming del video transcodificato.

Aggiorna il servizio cache perimetrale

A questo punto, è una buona idea aggiornare la configurazione del servizio di cache perimetrale in modo da poter utilizzare l'IP del servizio per lo streaming del video in un secondo momento. Il file YAML del servizio di cache perimetrale ci consente di elencare tutti i nomi/gli IP degli host da cui il servizio di cache perimetrale accetterà le richieste. Al momento abbiamo specificato solo demo.cme.com come host. Per fornire la risoluzione dei nomi per questo dominio, configura una zona DNS nel cloud. Tuttavia, una soluzione più semplice consiste nell'aggiungere l'indirizzo IP all'elenco di host nel file yaml. Modifica di nuovo il file YAML in modo che abbia 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, basta 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 sia presente nell'elenco degli host.

A questo punto l'istanza del servizio di cache perimetrale accetterà richieste con "demo.cme.com" o l'indirizzo IP come host.

12. Genera il segnale di input

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

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

1. Installa FFmpeg

FFmpeg è un progetto software senza costi e open source 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 comando seguente 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 il segnale del live streaming all'ingresso/canale

Ora che l'interfaccia FFmpeg è installata, invieremo uno stream di input di prova all'endpoint di input per generare il live streaming.

Nel terminale Cloud Shell, esegui questo comando utilizzando la variabile di ambiente URI creata nel passaggio "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 il segnale in tempo reale di prova. Il comando non restituirà il prompt. L'indicatore verrà generato finché non lo interrompi. Dovrai aprire una nuova finestra di Cloud Shell per il resto del lab.

13. Apri nuovo Cloud Shell

A questo punto devi aprire una nuova finestra di Cloud Shell per continuare il lab poiché FFmpeg viene eseguito definitivamente fino a quando non premi <Ctrl+C> il comando per arrestarlo e quindi interrompere la generazione del segnale in tempo reale.

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

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

Configura le variabili di ambiente

Poiché si tratta di un nuovo 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

Verifica che le variabili siano impostate

Verifica che tutte le variabili di ambiente richieste siano impostate. Dovremmo 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 attivo venga transcodificato

Faremo un curl per descrivere il canale. Nell'output dovremmo vedere che lo 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 vedere "streamingState": "STREAMING", che indica che il canale è in streaming e il segnale in tempo reale viene transcodificato.

Verifichiamo anche il contenuto del bucket in cui dovremmo vedere un file manifest e diversi segmenti video TS. Esegui il comando riportato di seguito 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 dei segnali live transcodificati 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 terminato le seguenti operazioni:

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

Nelle sezioni successive convalideremo il servizio Edge Cache, quindi eseguiremo lo streaming del video transcodificato utilizzando l'indirizzo IP anycast di Media CDN.

15. Verifica che l'istanza del servizio di cache perimetrale funzioni

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

Esegui questo comando curl in Cloud Shell per accedere al file manifest del video transcodificato archiviato nell'origine della cache perimetrale:

Comando

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

Osserva la risoluzione in cui utilizziamo l'indirizzo IP dell'istanza del servizio cache perimetrale per risolvere il suo nome. Usa demo.cme.com:<IP>, dove l'IP è l'IP dell'istanza del servizio di cache perimetrale 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 che la cache mancante è indicata perché l'oggetto non è stato ancora 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 propria cache. Il comando seguente 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 una combinazione di cache hit e miss. Se nell'output vedi successi della cache, 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, in quanto l'oggetto è ora memorizzato nella cache a livello perimetrale. Cloud Medie Edge Service funziona come previsto.

16. Riprodurre in streaming un video di segnali in diretta transcodificato con VLC

Qui è il momento in cui uniamo i punti 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 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/canale dell'API Live Streaming.
Abbiamo verificato che il segnale live sia stato trasmesso al canale e verificato che il canale fosse in modalità streaming.
Abbiamo verificato che i file transcodificati (manifest + segmenti TS) risultanti sono stati generati e archiviati nel bucket live-streaming-storage-$LOGNAME.
Un'origine della cache perimetrale denominata cme-origin è stata configurata con il bucket GCS live-streaming-storage-$LOGNAME come origine.
È stata configurata un'istanza della cache perimetrale denominata cme-demo con cme-origin come origine.
Abbiamo verificato il comportamento (fallimento della cache, successo della cache) dell'istanza del servizio cache perimetrale.

Siamo a un punto in cui possiamo utilizzare un video player per trasmettere in streaming il segnale live transcodificato tramite la cache di Media CDN. A questo scopo, utilizzeremo VLC Player. VLC Player è un framework e riproduttore 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 lavoro di transcodifica appena fatto, abbiamo utilizzato le preimpostazioni predefinite e generato due qualità "soltanto": SD e HD. All'avvio della riproduzione del video nel player, dovresti vederne la riproduzione in formato SD e passare 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, che è il manifest HLS. Il file manifest rimanda ai segmenti video TS.

Per utilizzare VLC Player, vai all'indirizzo 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 del player MacOSX nei prossimi passaggi.

Per riprodurre un video, seleziona "File" / "Rete aperta":

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 di cui hai eseguito il deployment.
Il percorso del file video manifest: "/". Questo è il percorso che abbiamo utilizzato nel bucket live-streaming-storage-$LOGNAME per archiviare i file di indicatori dal vivo transcodificati. Il percorso è il percorso principale qui: "/".
Nome del file video manifest: il file manifest HLS, main.m3u8.

Fai clic su "Apri". Dovrebbe iniziare la riproduzione del video in diretta transcodificato. Il video sarà simile allo screenshot seguente. Il contatore visualizzato sullo schermo mostra incrementi di 1 e dovresti riuscire a 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 fornito tramite la cache di Media CDN:

Se vuoi, puoi utilizzare qualsiasi altro player HLS e MPEG DASH. Ecco alcuni suggerimenti:

Player Quicktime: installato per impostazione predefinita sui Mac. Sempre qui: apri una connessione di rete all'indirizzo http://34.104.36.157/main.m3u8, sostituendo l'indirizzo IP con quello della tua istanza del servizio di cache perimetrale.

17. Monitoraggio di Media CDN

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

Per installarlo, esegui questi comandi nella finestra di 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 > Monitoraggio > Dashboard. Dovresti vedere una dashboard chiamata "Media Edge Metrics". Fai clic e vedrai le metriche:

18. Pulisci l'ambiente del lab

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

Interrompi il segnale FFmpeg:

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

Interrompere il canale in 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"

Eliminare il canale in 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 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

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

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

7. Configurare l'ambiente dell'API Live Streaming

8. Crea e configura l'endpoint di input

Crea il file input.json

Crea l'endpoint di input

Verifica lo stato

Salva l'URI

9. Crea e Configurare il canale di live streaming

Crea il file channel.json

Crea il canale

Verifica lo stato

10. Avviare il canale in live streaming

1. Avvia il canale

2. Verifica lo stato del canale

11. Configura Media CDN

1. Crea un'origine della cache perimetrale

2. Crea un servizio di cache perimetrale

Crea il file cme-demo.yaml

Crea il servizio di cache perimetrale

Aggiorna il servizio cache perimetrale

12. Genera il segnale di input

1. Installa FFmpeg

2. Avvia il segnale del live streaming all'ingresso/canale

13. Apri nuovo Cloud Shell

Configura le variabili di ambiente

Verifica che le variabili siano impostate

14. Verificare che il segnale attivo venga transcodificato

15. Verifica che l'istanza del servizio di cache perimetrale funzioni

16. Riprodurre in streaming un video di segnali in diretta transcodificato con VLC

17. Monitoraggio di Media CDN

18. Pulisci l'ambiente del lab

Interrompi il segnale FFmpeg:

Interrompere il canale in live streaming:

Eliminare il canale in live streaming:

Elimina l'endpoint di input del live streaming:

Elimina il bucket GCS:

Elimina l'istanza del servizio di cache perimetrale:

Elimina l'origine della cache perimetrale:

Eliminare la dashboard personalizzata

Crea il file `env_variables`

Crea il file `cme-demo.yaml`