Ta strona została przetłumaczona przez Cloud Translation API.

Transmitowanie na żywo w Google Cloud z użyciem Media CDN i interfejsu Live Streaming API

1. Wprowadzenie

Sieci dystrybucji treści (CDN) zwiększają wydajność dla użytkowników dzięki przechowywaniu w pamięci podręcznej treści, do których użytkownicy często uzyskują dostęp, kończeniu połączeń bliżej klientów, ponownemu używaniu połączeń z punktem początkowym oraz wdrażaniu nowoczesnych protokołów sieciowych i dostosowań. Dla użytkowników (i naszych klientów) oznacza to mniejsze opóźnienia, większą niezawodność i niższe koszty, co przekłada się na lepsze wyniki sprzedaży, wygodę korzystania z internetu i ogólne zwiększenie wygody użytkowników. Obecnie bardzo niewiele nowoczesnych witryn i platform do strumieniowego przesyłania filmów działa bez sieci CDN.

Czego się nauczysz

W tym laboratorium dowiesz się, jak wdrożyć środowisko przepływu pracy dotyczące strumieniowego przesyłania danych na żywo za pomocą Media CDN (CDN) + interfejsu Cloud Media Live Streaming API (transkodowanie wideo na żywo) + Cloud Storage (magazyn dla filmów) + odtwarzacz wideo (VLC, Google Shaka Player itp. – odtwarzacz obsługujący HLS i MPEG-DASH).

Skonfigurujemy komponenty interfejsu Live Streaming API – Input (wejście) i Channel (kanał) – oraz uruchomimy transmisję na żywo do wejścia lub kanału za pomocą FFmpeg (FFmpeg może wygenerować sygnał testowy na żywo). Interfejs Live Streaming API przekoduje transmisję na żywo. Przetworzony manifest wideo i segmenty zostaną zapisane w zasobniku Cloud Storage. Następnie skonfigurujemy Media CDN, używając zasobnika Cloud Storage z filmem na żywo jako punktu początkowego. Odtwarzacz VLC będzie też służył do odtwarzania treści na żywo z pamięci podręcznej w sieci CDN Media. Skonfigurujemy też panel Cloud Monitoring, aby wizualizować aktywność Media CDN.

Co utworzysz

W tym laboratorium skonfigurujemy środowisko oparte na tej architekturze:

W ramach tego modułu skonfigurujemy te komponenty i wykonamy te zadania:

Utwórz zasobnik Google Cloud Storage (GCS) na potrzeby przechowywania transkodowanych filmów z transmisji na żywo.
Skonfiguruj interfejs Live Streaming API, aby przekonwertować wideo do wielu formatów: HLS + MPEG DASH, SD i HD.
Skonfiguruj komponenty transmisji na żywo: wejście/kanał
Uruchamianie kanału transmisji na żywo
Konfigurowanie Media CDN z zasobnikiem GCS jako punktem początkowym
Skonfiguruj FFmpeg do przesyłania danych do kanału na żywo
Transkodowany przekaz na żywo można przesyłać strumieniowo za pomocą odtwarzacza wideo.
Skonfiguruj panel Cloud Monitoring, aby monitorować aktywność Media CDN (czas oczekiwania, trafienia w pamięci podręcznej, braki w pamięci podręcznej itd.).

Uwaga: w tym praktycznym laboratorium zakładamy, że użytkownicy mają dostęp do konsoli Google Cloud i mają już skonfigurowany projekt. Zakładamy też, że użytkownicy zaczynają od świeżego środowiska i nie mają nic skonfigurowanego na potrzeby tego demonstracyjnego scenariusza.

Wszystkie działania związane z konfiguracją będą wykonywane w wierszu poleceń w Cloud Shell. Skonfigurowane komponenty możesz zawsze sprawdzić w konsoli za pomocą wiersza poleceń. W trakcie tego modułu będziemy korzystać z konsoli Google Cloud.

2. Zanim zaczniesz

Dostęp do CDN multimediów jest ograniczony. Aby uzyskać dostęp do Media CDN, skontaktuj się z zespołem ds. kont. Będzie on mógł poprosić o dostęp w Twoim imieniu. Jeśli pracujesz w Google i chcesz przetestować strumieniowe przesyłanie danych za pomocą Media CDN, skontaktuj się z Menedżerem produktu Media CDN, aby poprosić o dostęp do tej usługi.

3. Konfiguracja i wymagania

Uruchamianie Cloud Shell

Google Cloud można obsługiwać zdalnie z laptopa, ale w tym ćwiczeniu będziesz używać Google Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.

W konsoli Google Cloud kliknij ikonę Cloud Shell na pasku narzędzi w prawym górnym rogu:

Uzyskanie dostępu do środowiska i połączenie się z nim powinno zająć tylko kilka chwil. Po jego zakończeniu powinno wyświetlić się coś takiego:

Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie poprawia wydajność sieci i uwierzytelnianie. Wszystkie zadania w tym CodeLab możesz wykonać w przeglądarce. Nie musisz niczego instalować.

4. Wersja Google Cloud SDK

W chwili powstawania tego tekstu najnowsza wersja pakietu Google Cloud SDK to 408.0.0. Wszystkie polecenia w tym module zostały przetestowane za pomocą najnowszej wersji pakietu Google Cloud SDK. Zanim przejdziesz dalej, sprawdź, czy Cloud Shell używa najnowszej wersji pakietu SDK.

Sprawdzanie wersji pakietu SDK

Aby sprawdzić wersję pakietu SDK, użyjemy polecenia gcloud version.

Command

gcloud version | grep "Google Cloud SDK"

Przykład danych wyjściowych

Google Cloud SDK 408.0.0

Następne kroki

Jeśli wersja pakietu SDK to 408.0.0 lub nowsza, przejdź do następnej sekcji.
Jeśli wersja pakietu SDK jest niższa niż 408.0.0, uaktualnij go, wykonując podane niżej polecenie.

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

5. Wymagania wstępne

Zanim zaczniemy konfigurować zasoby GCP, musimy wykonać te czynności:

Konfigurowanie zmiennych środowiskowych
Włączanie wymaganych interfejsów API usługi

1. Konfigurowanie zmiennych środowiskowych

W tym laboratorium będziemy uruchamiać polecenia gcloud i curl z kilkoma zmiennymi. Musimy skonfigurować te zmienne środowiskowe.

Identyfikator projektu
Numer projektu
Nazwa użytkownika
Region
Identyfikator wejścia
Identyfikator kanału

Identyfikator projektu i nazwa użytkownika

Te zmienne środowiskowe są zwykle wstępnie skonfigurowane w Cloudshell. Aby to sprawdzić, użyjemy polecenia env.

Command

env | grep -E 'DEVSHELL_PROJECT_ID=|LOGNAME'

Przykład danych wyjściowych

DEVSHELL_PROJECT_ID=<YOUR_PROJECT_ID>
LOGNAME=<YOUR_USERNAME>

Tworzenie pliku `env_variables`

Aby utworzyć plik env_variables.txt, użyj polecenia cat. To polecenie utworzy plik env_variables.txt w katalogu głównym użytkownika.

Polecenia

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

Konfigurowanie zmiennych środowiskowych

Aby ustawić zmienne środowiskowe, użyjemy polecenia source.

Command

source ~/env_variables.txt

Sprawdź, czy zmienne są ustawione

Sprawdźmy, czy wszystkie wymagane zmienne środowiskowe są ustawione. W wyjściu powinno być łącznie 6 zmiennych środowiskowych.

Command

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

Przykład danych wyjściowych

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. Włączanie wymaganych interfejsów API usług

Musimy się upewnić, że w naszym projekcie są włączone te interfejsy API.

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

Włącz interfejs Network Services API

Aby włączyć interfejs Network Services API, uruchom to polecenie:

Command

gcloud services enable networkservices.googleapis.com

Włącz interfejs Certificate Manager API

Aby włączyć interfejs Certificate Manager API, uruchom to polecenie:

Command

gcloud services enable certificatemanager.googleapis.com

Włączanie interfejsu Live Stream API

Aby włączyć interfejs Live Stream API, uruchom to polecenie:

Command

gcloud services enable livestream.googleapis.com

Włącz interfejs Media CDN Edge Cache API

Aby włączyć interfejs Media CDN Edge Cache API, uruchom to polecenie:

Command

gcloud services enable edgecache.googleapis.com

Sprawdź, czy interfejsy API są włączone

Uruchom polecenie gcloud services list, aby wyświetlić listę wszystkich włączonych interfejsów API. W wyniku powinny się pojawić 4 interfejsy API.

Command

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

Przykład danych wyjściowych

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

6. Tworzenie zasobnika Cloud Storage

W tej sekcji:

Tworzenie zasobnika Cloud Storage
Ustawianie zasobnika jako dostępnego publicznie

W dalszej części modułu użyjemy tego zasobnika do przechowywania transkodowanych plików wideo. Ten zasobnik będzie też pełnić rolę źródła dla usługi Media CDN.

1. Tworzenie zasobnika

Aby utworzyć zasób, użyjemy polecenia gsutil mb:

Command

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

2. Ustawianie zasobnika jako dostępnego publicznie

Aby udostępnić pliki publicznie, użyjemy polecenia gsutil iam:

Command

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

7. Konfigurowanie środowiska interfejsu Live Streaming API

Komponenty łańcucha interfejsu Live Streaming API są skonfigurowane w ten sposób:

W poprzedniej sekcji utworzyliśmy zasobnik Cloud Storage live-streaming-storage-$LOGNAME. W następnych 2 sekcjach utworzymy te zasoby:

Transmitowanie na żywo: punkt końcowy wejścia to punkt końcowy, do którego koder wysyła strumień wejściowy. Za pomocą punktu końcowego wejścia możesz określić konfiguracje strumienia, takie jak rozdzielczość wejścia, typ wejścia i przycinanie filmu.
Kanał transmisji na żywo: kanał to zasób, który przetwarza strumień wejściowy za pomocą punktu końcowego wejściowego, transkoduje strumień wejściowy na wiele wersji i publikuje wyjściowe transmisje na żywo w określonych formatach w określonym miejscu. Możesz umieścić główny i zapasowy strumień danych na tym samym kanale.

W dalszej części tego modułu utworzymy te zasoby:

Kodowanie: koder to program służący do wysyłania strumieni danych wejściowych. W tym module użyjemy FFmpeg.

8. Tworzenie i konfigurowanie wejściowego punktu końcowego

Tworzenie pliku input.json

Utworzymy plik input.json, aby określić typ sygnału transmisji na żywo. W tym laboratorium używamy sygnału RTMP na żywo.

Command

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

Tworzenie wejściowego punktu końcowego

W momencie pisania tego laboratorium interfejs Live Stream API nie był obsługiwany przez gcloud. Do wywoływania interfejsu API użyjemy polecenia curl.

Command

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"

Przykład danych wyjściowych

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

Wyjście zawiera wiele przydatnych informacji, ale w tej chwili musimy skupić się na 2 polach:

Identyfikator operacji: skopiuj z wyjścia identyfikator operacji. Poniżej znajduje się identyfikator operacji z przykładu danych wyjściowych. Znajdziesz go w wierszu wyjściowym zaczynającym się od "name". "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4"
Stan: musimy zaczekać, aż stan zmieni się z "done": false na "done": true.

Sprawdzanie stanu

Zanim przejdziemy dalej, musimy sprawdzić, czy punkt końcowy danych wejściowych został utworzony i czy jest gotowy do użycia.

W poniższym poleceniu zastąp <OPERATION> identyfikatorem operacji, który właśnie otrzymaliśmy. W tym przykładzie jest to "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4".

Command

export OPERATION_ID_1=<OPERATION>

Command

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"

Przykład danych wyjściowych

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

Ponownie uruchom polecenie, aż zobaczysz "done:true", co oznacza, że wejściowy punkt końcowy został utworzony i jest gotowy.

Zapisz identyfikator URI

W dalszej części tego modułu użyjemy URI z poprzednich danych wyjściowych. Skonfigurujmy teraz zmienną środowiskową dla URI.

Command

export URI=<uri>

Zastąp <uri> adresem URI zapisanym powyżej. Opcjonalnie możesz też użyć metody GET, aby pobrać identyfikator URI.

Command

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. Tworzenie i konfigurowanie kanału transmisji na żywo

Utwórz kanał transmisji na żywo powiązany z wejściowym punktem końcowym utworzonym w poprzedniej sekcji. W tym przykładzie tworzymy kanał generujący transmisję na żywo HLS, która składa się z jednej wersji w wysokiej rozdzielczości (1280 × 720). Kanał zostanie powiązany z wejściowym punktem końcowym i zasobnikiem na dane utworzonym wcześniej.

Tworzenie pliku channel.json

Aby utworzyć plik "channel.json", w terminalu Cloud Shell wpisz to polecenie:

Command

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

Tworzenie kanału

Aby utworzyć kanał, uruchom to polecenie curl:

Command

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"

Przykład danych wyjściowych

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

Zapisz i skopiuj identyfikator operacji. Będziemy go potrzebować w jednym z kolejnych kroków. Znajdziesz go w wierszu wyjściowym zaczynającym się od "name".

Sprawdzanie stanu

Zanim przejdziemy dalej, musimy sprawdzić, czy kanał został utworzony i czy jest gotowy.

W poniższym poleceniu zastąp <OPERATION> identyfikatorem operacji, który właśnie otrzymaliśmy. W tym przykładzie jest to operation-1661405972853-5e70a38d6f27f-79100d00-310671b4

Command

export OPERATION_ID_2=<OPERATION>

Command

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"

Przykład danych wyjściowych

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

Ponownie uruchom polecenie, aż zobaczysz "done:true", co oznacza, że wejściowy punkt końcowy został utworzony i jest gotowy.

Pamiętaj, że "streamingState" w tej chwili to "STOPPED". Kanał uruchomimy w następnej sekcji.

10. Uruchamianie kanału transmisji na żywo

Utworzyliśmy już kanał transmisji na żywo, więc możemy go uruchomić. W tej sekcji:

Uruchamianie kanału transmisji na żywo
Sprawdź stan kanału. Musimy się upewnić, że streamingState to "AWAITING INPUT"

1. Uruchom kanał

Aby uruchomić kanał, w Cloud Shell uruchom to polecenie: curl

Command

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"

Przykład danych wyjściowych

{
  "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. Sprawdzanie stanu kanału

Aby uzyskać stan kanału, uruchom to polecenie curl:

Command

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"

Przykład danych wyjściowych

"streamingState": "AWAITING_INPUT",

Ponownie uruchom polecenie, aż zobaczysz „AWAITING_INPUT”, co oznacza, że kanał działa i jest gotowy do odbioru sygnału.

11. Konfigurowanie Media CDN

W tej sekcji wdrożymy Media CDN, czyli infrastrukturę CDN. Utworzymy te zasoby:

Punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych
Usługa tymczasowego przechowywania danych na serwerach brzegowych

1. Tworzenie punktu początkowego tymczasowego przechowywania danych na serwerach brzegowych

Źródło pamięci podręcznej Edge reprezentuje lokalizację treści, np. zasobnik Cloud Storage, zewnętrzna lokalizacja pamięci masowej lub system równoważenia obciążenia. W terminologii CDN źródło (lub serwer źródłowy) to lokalizacja, w której znajduje się źródło treści, które chcemy rozpowszechniać, np. wszystkie pliki CSS, JavaScript, HTML, obrazy itp. W tym module utworzymy źródło, które odwzorowuje zasobnik Cloud Storage utworzony na początku tego modułu. Punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych będzie nazywał się cme-origin. Punkt początkowy sieci CDN to miejsce, w którym przechowywane są wszystkie treści źródłowe przed ich rozpowszechnieniem na serwerach tymczasowego przechowywania danych na serwerach brzegowych.

Użyjemy polecenia gcloud edge-cache origins create, aby utworzyć źródło. Wykonanie tego polecenia może potrwać kilka minut.

Command

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

Przykładowe dane wyjściowe

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. Tworzenie usługi tymczasowego przechowywania danych na serwerach brzegowych

Gdy skonfigurujemy punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych, możemy utworzyć samą usługę tymczasowego przechowywania danych na serwerach brzegowych.

Tworzenie pliku `cme-demo.yaml`

Konfiguracja usługi tymczasowego przechowywania danych na serwerach brzegowych jest wykonywana za pomocą pliku YAML. W Cloud Shell utwórz lokalny plik o nazwie cme-demo.yaml. Użyj edytora vi, nano lub dowolnego innego i wklej te wiersze w pliku 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

Wszystkie ustawienia usługi tymczasowego przechowywania danych na serwerach brzegowych pozostaną domyślne. W tym pliku znajdują się 3 wartości pól, które użytkownicy mogą zmienić:

name: nazwa instancji Media CDN – tutaj: cme-demo
hosts: lista nazw domen, które zostaną rozwiązane przez tę usługę CDN Media – tutaj: demo.cme.com. Użyjemy go w trakcie tego pokazu. Użyjemy adresu IP instancji CDN multimediów.
Origin: to punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych utworzony w poprzednim kroku. Ustaw wartość na cme-origin – nazwę punktu początkowego Media CDN.

Więcej informacji o różnych zmiennych, których można używać w pliku YAML, znajdziesz w przewodniku po konfigurowaniu usługi Edge Cache Service.

Tworzenie usługi tymczasowego przechowywania danych na serwerach brzegowych

Utworzymy usługę tymczasowego przechowywania danych na serwerach brzegowych o nazwie cme-demo w punkcie początkowym tymczasowego przechowywania danych na serwerach brzegowych cme-origin z hostem demo.cme.com. Aby utworzyć usługę, uruchom w Cloud Shell to polecenie:

Command

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

Tworzenie usługi tymczasowego przechowywania danych na serwerach brzegowych może potrwać kilka minut.

Przykład danych wyjściowych

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'

Zanotuj i skopiuj ipv4Addresses instancji usługi tymczasowego przechowywania danych na serwerach brzegowych – tutaj 34.104.36.157. Użyjemy go do zaktualizowania pliku cme-demo.yaml, a później do strumieniowego przesyłania transkodowanego filmu.

Aktualizowanie usługi tymczasowego przechowywania danych na serwerach brzegowych

W tym momencie warto zaktualizować konfigurację usługi Edge Cache Service, aby móc później używać adresu IP tej usługi do strumieniowego przesyłania filmów. Plik YAML usługi tymczasowego przechowywania danych na serwerach brzegowych umożliwia podanie listy wszystkich nazw hostów lub adresów IP, z których usługa tymczasowego przechowywania danych na serwerach brzegowych będzie przyjmować żądania. Na tym etapie jako hosta określono tylko demo.cme.com. Aby zapewnić rozpoznawanie nazw w tej domenie, skonfiguruj strefę DNS. Łatwiej jednak będzie dodać adres IP do listy hostów w pliku yaml. Ponownie otwórz plik YAML i zmień go tak, aby wyglądał jak poniżej:

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

Aby odzwierciedlić zmiany, wystarczy ponownie zaimportować plik YAML. W terminalu Cloud Shell uruchom to polecenie:

Command

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

Sprawdź dane wyjściowe polecenia i sprawdź, czy adres IP znajduje się na liście hostów.

W tym momencie instancja usługi Edge Cache Service będzie akceptować żądania z wartością "demo.cme.com" lub adresem IP jako hostem.

12. Generowanie sygnału wejściowego

Skonfigurowaliśmy już wszystkie wymagane usługi, więc wygenerujmy sygnał wejściowy transmisji na żywo. W tej sekcji:

Zainstaluj FFmpeg, czyli bezpłatne oprogramowanie open source.
Wysyłanie testowego sygnału na żywo do wejścia/kanału

1. Instalowanie FFmpeg

FFmpeg to bezpłatny projekt oprogramowania typu open source, który składa się z pakietu bibliotek i programów do obsługi plików i strumieni wideo, dźwięku i innych plików multimedialnych. Aby zainstalować FFmpeg, w terminalu Cloud Shell użyj tego polecenia:

Command

sudo apt install ffmpeg -y

Po zakończeniu instalacji sprawdź, czy FFmpeg zostało prawidłowo zainstalowane. Aby to zrobić, sprawdź jego wersję:

Command

ffmpeg -version

Przykład danych wyjściowych

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

FFmpeg został prawidłowo zainstalowany.

2. Rozpocznij transmisję na żywo do wejścia/kanału.

Po zainstalowaniu FFmpeg wyślemy testowy strumień wejściowy do wejściowego punktu końcowego, aby wygenerować transmisję na żywo.

W terminalu Cloud Shell uruchom to polecenie, używając zmiennej środowiskowej URI utworzonej w sekcji „Tworzenie i konfigurowanie punktu końcowego danych wejściowych”.

Command

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

Powinieneś zobaczyć, że FFmpeg wysyła sygnał testowy na żywo. Polecenie nie zwróci prompta. Sygnał będzie generowany, dopóki go nie przerwiesz. Na potrzeby dalszej części laboratorium musisz otworzyć nowe okno Cloud Shell.

13. Otwieranie nowej sesji Cloud Shell

Aby kontynuować pracę z tym laboratorium, musisz otworzyć nowe okno Cloud Shell, ponieważ FFmpeg będzie działać do momentu, aż nie wciśniesz <CTRL+C>, aby zatrzymać polecenie i w ten sposób zatrzymać generowanie sygnału na żywo.

Kliknij znak „+” obok nazwy bieżącego terminala Cloud Shell. Otworzy się dodatkowe okno Cloud Shell.

Przeprowadź pozostałą część ćwiczenia w nowo otwartym oknie Cloud Shell.

Konfigurowanie zmiennych środowiskowych

Ponieważ jest to nowa sesja Cloud Shell, musimy ponownie ustawić zmienne środowiskowe. Aby ustawić zmienne środowiskowe, użyjemy polecenia source.

Command

source ~/env_variables.txt

Sprawdź, czy zmienne są ustawione

Sprawdźmy, czy wszystkie wymagane zmienne środowiskowe są ustawione. W wyjściu powinno być łącznie 6 zmiennych środowiskowych.

Command

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

Przykład danych wyjściowych

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. Sprawdź, czy sygnał na żywo jest przekodowywany

Uruchomimy curl, aby opisać kanał. W wyniku powinno być widać, że stan streamingState zmienił się z "AWAITING_INPUT" na "STREAMING"

Command

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"

W odpowiedzi w pliku wyjściowym JSON powinien pojawić się element "streamingState": "STREAMING", co oznacza, że kanał jest przesyłany strumieniowo, a sygnał na żywo jest transkodowany.

Sprawdźmy też zawartość zasobnika, w którym powinniśmy znaleźć plik manifestu i kilka segmentów wideo TS. Uruchom to polecenie w Cloud Shell, aby wyświetlić zawartość zasobnika utworzonego na początku modułu, którego używa interfejs Live Streaming API do generowania przetranskodowanego pliku manifestu sygnału na żywo i segmentów wideo TS:

Command

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

Przykład danych wyjściowych

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

Zobaczysz, że:

plik manifestu HLS: main.m3u8
Odpowiednie segmenty wideo TS: seria ponumerowanych plików segment-000000000X.ts

W tym momencie skończyliśmy:

Interfejs Live Streaming API: sygnał na żywo jest generowany i transkodowany do puli za pomocą interfejsu Live Streaming API.
Media CDN: skonfigurowana usługa Media CDN z zasobnikiem do przechowywania danych do transmisji na żywo jako punktem początkowym.

W kolejnych sekcjach zweryfikujemy usługę Edge Cache Service, a następnie strumieniowo prześlemy przekonwertowane wideo, korzystając z adresu IP anycast Media CDN.

15. Sprawdzanie, czy instancja usługi Edge Cache Service działa

W tej sekcji sprawdzimy, czy instancja usługi tymczasowego przechowywania danych na serwerach brzegowych działa zgodnie z oczekiwaniami. W tym celu spróbujemy uzyskać dostęp do pliku z instancji usługi Edge Cache Service przy użyciu adresu IP usługi Edge Cache Service. Gdy po raz pierwszy uzyskujesz dostęp do obiektu, nie jest on jeszcze zapisany w pamięci podręcznej. Powinniśmy zaobserwować pamięć podręczną MISS. W przypadku pierwszego żądania obiekt jest odczytywany z źródła i przechowywany w pamięci podręcznej na brzegu. Wszystkie kolejne próby uzyskania dostępu do tego samego pliku będą zwracać pamięć podręczną HIT, ponieważ obiekt jest teraz przechowywany w pamięci podręcznej na brzegu. Sprawdźmy to zachowanie:

Aby uzyskać dostęp do przetworzonego pliku manifestu wideo, który jest przechowywany w Edge Cache Origin, uruchom w Cloud Shell to polecenie: curl.

Command

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

Zwróć uwagę, że do rozpoznawania nazwy używamy adresu IP instancji usługi Edge Cache Service. Upewnij się, że używasz demo.cme.com:<IP>, gdzie IP to adres IP utworzonej przez nas instancji usługi Edge Cache Service.

W wyniku odszukaj nagłówek x-cache-status.

Przykład danych wyjściowych

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

Zwróć uwagę na brak odpowiedzi z pamięci podręcznej, ponieważ obiekt nie został jeszcze zapisany w pamięci podręcznej i jest odczytywany z źródła.

Teraz wyślemy kilka żądań pliku m3u8. Jeśli wszystko jest prawidłowo skonfigurowane, CDN Media powinien zacząć dostarczać treści z pamięci podręcznej. To polecenie wyśle 10 żądań curl i wydrukuje tylko nagłówek x-cache-status.

Command

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

Dane wyjściowe powinny być kombinacją pamięci podręcznej hit i miss. Jeśli w wynikach widzisz trafienia w pamięci podręcznej, oznacza to, że Media CDN działa zgodnie z oczekiwaniami.

Przykład danych wyjściowych

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

Zwróć uwagę na trafienie do pamięci podręcznej, ponieważ obiekt jest teraz przechowywany w pamięci podręcznej na brzegu sieci. Usługa Cloud Media Edge działa zgodnie z oczekiwaniami.

16. Transkodowanie transmisji wideo z sygnału na żywo i strumieniowanie za pomocą VLC

W tej części połączymy kropki i połączymy wszystkie kroki, nad którymi pracowaliśmy do tej pory:

Utworzyliśmy zbiornik o nazwie live-streaming-storage-$LOGNAME, który odbiera sygnał z transmisji na żywo przekodowany na treści HLS przez interfejs Live Streaming API.
Skonfigurowaliśmy interfejs Live Streaming API.
Rozpoczęliśmy przesyłanie sygnału RTMP za pomocą FFmpeg do wejścia/kanału interfejsu Live Streaming API.
Potwierdzono, że sygnał na żywo został przesłany na kanał i że kanał był w trybie streaming.
Potwierdzono, że wygenerowane pliki po transkodowaniu (manifest i segmenty TS) zostały utworzone i zapisane w zasobniku live-streaming-storage-$LOGNAME.
Punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych o nazwie cme-origin został skonfigurowany z zasobnikiem GCS live-streaming-storage-$LOGNAME jako punktem początkowym.
Konfiguracja instancji tymczasowego przechowywania danych na serwerach brzegowych o nazwie cme-demo z użyciem punktu początkowego cme-origin.
Zweryfikowaliśmy działanie (niepowodzenie pamięci podręcznej, trafienie do pamięci podręcznej) instancji usługi Edge Cache Service.

Obecnie możemy używać odtwarzacza wideo do przesyłania strumieniowego transkodowanego sygnału na żywo za pomocą pamięci podręcznej CDN Media. Aby to zrobić, użyjemy odtwarzacza VLC. VLC Player to bezpłatny, oparty na open source odtwarzacz multimedialny i środowisko programistyczne, które obsługuje większość plików multimedialnych. Odtwarza adaptacyjne formaty multimediów (np. DASH i HLS). Korzysta on z zasady adaptacyjnego strumieniowania – w zależności od jakości połączenia z internetem i dostępnej przepustowości odtwarzacz dostosowuje jakość odtwarzanego filmu. Podczas ostatniego procesu transkodowania użyliśmy domyślnych wstępnie ustawionych wartości i wygenerowaliśmy „tylko” 2 jakości: SD i HD. Gdy zaczniemy odtwarzać film w odtwarzaczu, powinien on zacząć odtwarzać w formacie SD, a następnie szybko przełączyć się na format HD, jeśli połączenie z siecią będzie wystarczająco dobre.

Transkodujemy sygnał na żywo i prześlemy go strumieniowo w formacie HLS (powszechnie obsługiwanym formacie wideo Apple). Odpowiedni plik nosi nazwę main.m3u8 i jest plikiem manifestu HLS. Plik manifestu wskazuje na segmenty wideo TS.

Aby korzystać z odtwarzacza VLC, otwórz stronę https://www.videolan.org/vlc/ i pobierz wersję odtwarzacza dla systemu operacyjnego laptopa. VLC jest dostępny na systemy Windows, MacOSX, Linux, Android i iOS.

Zainstaluj odtwarzacz na laptopie i uruchom go. W kolejnych krokach użyjemy odtwarzacza w wersji na MacOSX.

Aby odtworzyć film, kliknij „Plik” lub „Otwórz sieć”:

Skonfiguruj je za pomocą:

Adres URL: http://<Replace_With_Edge_Cache_IP>/main.m3u8. To jest adres URL filmu, który chcemy przesyłać strumieniowo. Uwaga:
Adres IP instancji Media CDN: 34.105.35.246. Zastąp adresem IP zaimplementowanej usługi Cloud Media Service.
Ścieżka do pliku manifestu wideo: „/”. Jest to ścieżka użyta w zasobniku live-streaming-storage-$LOGNAME do przechowywania transkodowanych plików sygnału na żywo. Ścieżka to tutaj ścieżka katalogu głównego: „/”.
Nazwa pliku wideo manifestu: plik manifestu HLS, main.m3u8.

Kliknij „Otwórz”. Powinien rozpocząć się odtwarzanie przetranskodowanego filmu na żywo. Film będzie wyglądał jak na zrzucie ekranu poniżej. Licznik na ekranie będzie odliczać w krokach po 1 i powinieneś usłyszeć ciągły sygnał dźwiękowy.

Jest to podstawowy sygnał testowy RTMP wygenerowany przez FFmpeg, przekonwertowany do HLS przez interfejs Live Streaming API i przesłany przez pamięć podręczną Media CDN:

Jeśli chcesz, możesz użyć dowolnego innego odtwarzacza HLS i MPEG DASH. Oto kilka opcji do rozważenia:

Odtwarzacz Quicktime – domyślnie instalowany na komputerach Mac. U mnie to samo: otwórz połączenie sieciowe z http://34.104.36.157/main.m3u8 – zastąp adres IP adresem instancji usługi Edge Cache Service.

17. Monitorowanie Media CDN

Szablon panelu Media CDN został utworzony przez zespół SME: https://gist.github.com/elithrar/1c511d00f5cd3736fb2a3897867209c1.

Aby go zainstalować, uruchom w oknie Cloud Shell te polecenia:

Pobierz plik YAML:

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

Utwórz panel Cloud Monitoring:

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

Konfiguracja może potrwać kilka minut. Otwórz konsolę Google Cloud i kliknij 3 paski > Operacje > Monitorowanie > Panele. Powinien wyświetlić się panel o nazwie „Dane Media Edge”. Kliknij go, aby wyświetlić dane:

18. Czyszczenie środowiska modułu

Gratulujemy ukończenia laboratorium. W tej sekcji usuniemy wszystkie zasoby utworzone w ramach tego modułu.

Zatrzymanie sygnału FFmpeg:

Naciśnij <CTRL+C> w terminalu Cloud Shell, w którym działa FFmpeg.

Zatrzymanie kanału transmisji na żywo:

Command

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"

Aby usunąć kanał transmisji na żywo:

Command

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"

Usuń punkt końcowy wejścia transmisji na żywo:

Command

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"

Usuwanie zasobnika GCS:

Command

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

Usuwanie instancji usługi tymczasowego przechowywania danych na serwerach brzegowych:

Command

gcloud edge-cache services delete cme-demo

Potwierdź usunięcie, wpisując „Y” (tak), gdy pojawi się odpowiedni komunikat

Usuwanie punktu początkowego tymczasowego przechowywania danych na serwerach brzegowych:

Command

gcloud edge-cache origins delete cme-origin

Potwierdź usunięcie, wpisując „Y” (tak), gdy pojawi się odpowiedni komunikat

Usuwanie panelu niestandardowego

Command

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

Transmitowanie na żywo w Google Cloud z użyciem Media CDN i interfejsu Live Streaming API

1. Wprowadzenie

Czego się nauczysz

Co utworzysz

2. Zanim zaczniesz

3. Konfiguracja i wymagania

Uruchamianie Cloud Shell

4. Wersja Google Cloud SDK

Sprawdzanie wersji pakietu SDK

Następne kroki

5. Wymagania wstępne

1. Konfigurowanie zmiennych środowiskowych

Identyfikator projektu i nazwa użytkownika

Tworzenie pliku env_variables

Konfigurowanie zmiennych środowiskowych

Sprawdź, czy zmienne są ustawione

2. Włączanie wymaganych interfejsów API usług

Włącz interfejs Network Services API

Włącz interfejs Certificate Manager API

Włączanie interfejsu Live Stream API

Włącz interfejs Media CDN Edge Cache API

Sprawdź, czy interfejsy API są włączone

6. Tworzenie zasobnika Cloud Storage

1. Tworzenie zasobnika

2. Ustawianie zasobnika jako dostępnego publicznie

7. Konfigurowanie środowiska interfejsu Live Streaming API

8. Tworzenie i konfigurowanie wejściowego punktu końcowego

Tworzenie pliku input.json

Tworzenie wejściowego punktu końcowego

Sprawdzanie stanu

Zapisz identyfikator URI

9. Tworzenie i konfigurowanie kanału transmisji na żywo

Tworzenie pliku channel.json

Tworzenie kanału

Sprawdzanie stanu

10. Uruchamianie kanału transmisji na żywo

1. Uruchom kanał

2. Sprawdzanie stanu kanału

11. Konfigurowanie Media CDN

1. Tworzenie punktu początkowego tymczasowego przechowywania danych na serwerach brzegowych

2. Tworzenie usługi tymczasowego przechowywania danych na serwerach brzegowych

Tworzenie pliku cme-demo.yaml

Tworzenie usługi tymczasowego przechowywania danych na serwerach brzegowych

Aktualizowanie usługi tymczasowego przechowywania danych na serwerach brzegowych

12. Generowanie sygnału wejściowego

1. Instalowanie FFmpeg

2. Rozpocznij transmisję na żywo do wejścia/kanału.

13. Otwieranie nowej sesji Cloud Shell

Konfigurowanie zmiennych środowiskowych

Sprawdź, czy zmienne są ustawione

14. Sprawdź, czy sygnał na żywo jest przekodowywany

15. Sprawdzanie, czy instancja usługi Edge Cache Service działa

16. Transkodowanie transmisji wideo z sygnału na żywo i strumieniowanie za pomocą VLC

17. Monitorowanie Media CDN

18. Czyszczenie środowiska modułu

Zatrzymanie sygnału FFmpeg:

Zatrzymanie kanału transmisji na żywo:

Aby usunąć kanał transmisji na żywo:

Usuń punkt końcowy wejścia transmisji na żywo:

Usuwanie zasobnika GCS:

Usuwanie instancji usługi tymczasowego przechowywania danych na serwerach brzegowych:

Usuwanie punktu początkowego tymczasowego przechowywania danych na serwerach brzegowych:

Usuwanie panelu niestandardowego

Tworzenie pliku `env_variables`

Tworzenie pliku `cme-demo.yaml`