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 dostarczania treści (CDN) zwiększają wydajność użytkowników przez buforowanie często używanych treści bliżej użytkowników, przerywanie połączeń bliżej klientów, ponowne wykorzystywanie połączeń ze źródłem oraz stosowanie nowoczesnych protokołów sieciowych i dostosowań. W przypadku użytkowników (i naszych klientów) oznacza to krótszy czas oczekiwania, większą niezawodność i mniejsze koszty, a w efekcie wzrost sprzedaży i wygody korzystania z internetu oraz zwiększona satysfakcja użytkowników. Obecnie bardzo niewiele witryn i platform streamingowych nie ma sieci CDN.

Czego się nauczysz

W tym module dowiesz się, jak wdrożyć środowisko strumieniowania na żywo: Media CDN (CDN) + Cloud Media Live Streaming API (transkodowanie wideo na żywo) + Cloud Storage (miejsce na filmy) + odtwarzacz wideo (VLC, Google Shaka Player itp. – odtwarzacz obsługujący HLS + MPEG-DASH).

Skonfigurujemy komponenty interfejsu Live Streaming API – dane wejściowe i kanał – oraz uruchomimy transmisję na żywo do wejścia/kanału za pomocą FFmpeg (FFmpeg może wygenerować sygnał testowy na żywo). Interfejs Live Streaming API transkoduje transmisję na żywo. Transkodowany plik manifestu i segmenty wideo będą przechowywane w zasobniku Cloud Storage. Następnie skonfigurujemy Media CDN z zasobnikiem Cloud Storage na żądanie na żywo. VLC Player będzie też służyć do odtwarzania treści na żywo zapisanych w pamięci podręcznej przez Media CDN. Skonfigurowamy też panel Cloud Monitoring, w którym będzie można wizualizować aktywność Media CDN.

Co utworzysz

W tym module skonfigurujemy środowisko zgodnie z tą architekturą:

W ramach modułu skonfigurujemy następujące elementy i wykonamy następujące zadania:

Tworzenie zasobnika Google Cloud Storage (GCS) do przechowywania transkodowanych filmów na żywo
Skonfiguruj interfejs Live Streaming API, aby transkodować filmy na wiele formatów: HLS + MPEG DASH, SD i HD.
Konfigurowanie komponentów transmisji na żywo: wejście/kanał
Uruchom kanał transmisji na żywo
Skonfiguruj Media CDN z zasobnikiem GCS jako punktem początkowym
Skonfiguruj FFmpeg, aby promować kanał na żywo
Transmitowanie transkodowanego kanału na żywo 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 itp.)

Uwaga: w tym module zakładamy, że użytkownicy mają dostęp do konsoli Google Cloud i mają już skonfigurowany projekt. Zakładamy też, że użytkownicy uruchamiają nowe środowisko i nie mają nic skonfigurowanego w tej wersji demonstracyjnej.

Wszystkie działania konfiguracyjne będą wykonywane w wierszu poleceń w Cloud Shell. Możemy w każdej chwili sprawdzić komponenty skonfigurowane w wierszu poleceń w konsoli. W całym module zobaczysz wskaźniki wskazujące konsolę Google Cloud.

2. Zanim zaczniesz

Dostęp do Media CDN jest ograniczony. Aby uzyskać dostęp do Media CDN, skontaktuj się z zespołem ds. kont. Będzie on mógł utworzyć prośbę o dostęp w Twoim imieniu. Jeśli korzystasz z usług Google i chcesz przetestować transmitowanie na żywo w Media CDN, skontaktuj się z menedżerem Media CDN, aby poprosić o dostęp do Media CDN.

3. Konfiguracja i wymagania

Uruchamianie Cloud Shell

Google Cloud można obsługiwać zdalnie z laptopa, ale w ramach tego ćwiczenia z programowania wykorzystasz Google Cloud Shell – środowisko wiersza poleceń działające w chmurze.

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

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

Ta maszyna wirtualna ma wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, znacząco zwiększając wydajność sieci i uwierzytelnianie. Wszystkie zadania w ramach tego ćwiczenia z programowania można wykonywać w przeglądarce. Nie musisz niczego instalować.

4. Wersja pakietu SDK Google Cloud

W momencie pisania wiadomości pakiet 408.0.0 jest najnowszą wersją pakietu SDK Google Cloud. Wszystkie polecenia w tym module zostały przetestowane przy użyciu najnowszej wersji pakietu SDK Google Cloud. Zanim przejdziesz dalej, sprawdź, czy Cloud Shell używa najnowszej wersji pakietu SDK.

Sprawdzanie wersji pakietu SDK

Użyjemy polecenia gcloud version, aby sprawdzić wersję pakietu SDK.

Polecenie

gcloud version | grep "Google Cloud SDK"

Przykład wyjściowy

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, uruchom podane poniżej polecenie, aby zaktualizować pakiet SDK.

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

5. Wymagania wstępne

Zanim rozpoczniemy konfigurowanie zasobów GCP, musimy wykonać te czynności:

Skonfiguruj zmienne środowiskowe
Włącz wymagane interfejsy API usługi

1. Skonfiguruj zmienne środowiskowe

W tym module uruchomimy polecenia gcloud i curl z kilkoma zmiennymi. Musimy skonfigurować wymienione poniżej zmienne środowiskowe.

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

Identyfikator projektu i nazwa użytkownika

Te zmienne środowiskowe są zwykle wstępnie skonfigurowane w Cloud Shell. Do weryfikacji użyjemy polecenia env.

Polecenie

env | grep -E 'DEVSHELL_PROJECT_ID=|LOGNAME'

Przykład wyjściowy

DEVSHELL_PROJECT_ID=<YOUR_PROJECT_ID>
LOGNAME=<YOUR_USERNAME>

Utwórz plik `env_variables`

Użyj polecenia cat, aby utworzyć plik env_variables.txt. Poniższe 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

Konfiguracja zmiennych środowiskowych

Do ustawiania zmiennych środowiskowych użyjemy polecenia source

Polecenie

source ~/env_variables.txt

Sprawdź, czy zmienne są ustawione

Sprawdźmy, czy wszystkie wymagane zmienne środowiskowe są ustawione. W danych wyjściowych powinno pojawić się łącznie 6 zmiennych środowiskowych.

Polecenie

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

Przykład wyjściowy

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łącz wymagane interfejsy API usługi

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

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

Włączanie interfejsu Network Services API

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

Polecenie

gcloud services enable networkservices.googleapis.com

Włączanie interfejsu Certificate Manager API

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

Polecenie

gcloud services enable certificatemanager.googleapis.com

Włączanie interfejsu Live Stream API

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

Polecenie

gcloud services enable livestream.googleapis.com

Włączanie interfejsu Media CDN Edge Cache API

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

Polecenie

gcloud services enable edgecache.googleapis.com

Sprawdzanie, czy interfejsy API są włączone

Uruchom polecenie gcloud services list, aby wyświetlić listę wszystkich włączonych interfejsów API. W danych wyjściowych powinny być widoczne 4 interfejsy API.

Polecenie

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

Przykład wyjściowy

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ż działać jako pamięć punktu początkowego dla usługi Media CDN.

1. Tworzenie zasobnika

Do utworzenia zasobnika użyjemy polecenia gsutil mb:

Polecenie

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

2. Ustawianie zasobnika jako dostępnego publicznie

Użyjemy polecenia gsutil iam, aby udostępnić pliki publicznie:

Polecenie

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

7. Konfigurowanie środowiska interfejsu Live Streaming API

Architektura łańcucha interfejsu Live Streaming API jest taka:

W poprzedniej sekcji utworzyliśmy zasobnik Cloud Storage live-streaming-storage-$LOGNAME. W 2 kolejnych sekcjach utworzymy następujące zasoby:

Wejście transmisji na żywo: wejściowy punkt końcowy to punkt końcowy, do którego koder wysyła strumień wejściowy. Wejściowego punktu końcowego możesz użyć do określenia konfiguracji strumienia, np. rozdzielczości wejściowej, typu danych wejściowych i przycięcia filmu.
Kanał transmisji na żywo: kanał to zasób, który pozyskuje strumień wejściowy przez wejściowy punkt końcowy, transkoduje go na wiele odtworzeń i publikuje wyjściowe transmisje na żywo w określonych formatach w określonej lokalizacji. W tym samym kanale możesz umieścić główny i zapasowy strumień wejściowy.

W dalszej części modułu utworzymy następujące zasoby:

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

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

Tworzenie plikuinput.json

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

Polecenie

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

Tworzenie wejściowego punktu końcowego

W momencie tworzenia tego modułu interfejs Live Stream API nie jest obsługiwany przez gcloud. Do wywoływania interfejsu API będziemy używać polecenia curl.

Polecenie

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 wyjściowy

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

Dane wyjściowe zawierają wiele przydatnych informacji, ale obecnie musimy skupić się na 2 polach:

Identyfikator operacji: skopiuj identyfikator operacji i zapisz go w danych wyjściowych. Poniżej znajdziesz identyfikator operacji z przykładu danych wyjściowych. Możesz go znaleźć w wierszu wyjściowym rozpoczynającym się od "name". "operation-1661405972853-5e70a38d6f27f-79100d00-310671b4"
Stan: musimy poczekać na zmianę stanu z "done": false na "done": true

Sprawdzanie stanu

Zanim przejdziemy dalej, musimy sprawdzić, czy wejściowy punkt końcowy został utworzony i czy jest gotowy.

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

Polecenie

export OPERATION_ID_1=<OPERATION>

Polecenie

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 wyjściowy

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

Ponawiaj polecenie, aż zobaczysz komunikat "done:true" wskazujący, że wejście do punktu końcowego zostało utworzone i jest gotowe.

Zapisz identyfikator URI

W dalszej części tego modułu użyjemy funkcji URI z poprzednich wyników. Ustawmy teraz zmienną środowiskową dla interfejsu URI.

Polecenie

export URI=<uri>

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

Polecenie

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. Utwórz & Konfigurowanie kanału transmisji na żywo

Utwórzmy kanał transmisji na żywo powiązany z wejściowym punktem końcowym utworzonym w poprzedniej sekcji. Ten przykład pozwala utworzyć kanał generujący transmisję na żywo HLS składającą się z pojedynczej wersji w wysokiej rozdzielczości (1280 × 720). Kanał zostanie powiązany z wejściowym punktem końcowym i utworzonym wcześniej zasobnikiem na dane.

Tworzenie pliku channel.json

W terminalu Cloud Shell wpisz to polecenie, aby utworzyć plik "channel.json":

Polecenie

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

Utwórz kanał

Aby utworzyć kanał, uruchom to polecenie curl:

Polecenie

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 wyjściowy

{
  "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ędzie nam potrzebna w jednym z nadchodzących kroków. Możesz go znaleźć w wierszu wyjściowym rozpoczynają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órą właśnie zrobiliśmy. W tym przykładzie jest to operation-1661405972853-5e70a38d6f27f-79100d00-310671b4

Polecenie

export OPERATION_ID_2=<OPERATION>

Polecenie

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 wyjściowy

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

Ponawiaj polecenie, aż zobaczysz komunikat "done:true" wskazujący, że wejście do punktu końcowego zostało utworzone i jest gotowe.

Pamiętaj, że "streamingState" to obecnie "STOPPED"; uruchomimy kanał w następnej sekcji.

10. Uruchom kanał transmisji na żywo

Skoro mamy już kanał z transmisją na żywo, czas go uruchomić. W tej sekcji:

Zakładanie kanału Transmitowanie na żywo
Sprawdź stan kanału, musimy się upewnić, że streamingState ma stan "AWAITING INPUT"

1. Uruchom kanał

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

Polecenie

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 wyjściowy

{
  "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. Jak sprawdzić stan kanału

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

Polecenie

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 wyjściowy

"streamingState": "AWAITING_INPUT",

Ponawiaj polecenie, aż zobaczysz „AWAITING_INPUT” oznacza, że kanał działa i jest gotowy do odbierania sygnału.

11. Skonfiguruj Media CDN

W tej sekcji wdrożymy Media CDN – 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

Punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych reprezentuje lokalizację treści, taką jak zasobnik Cloud Storage, lokalizacja pamięci innej firmy lub system równoważenia obciążenia. W kontekście CDN punkt początkowy (lub serwer pierwotny) to lokalizacja, w której znajduje się źródło treści, które chcemy rozpowszechniać, np. wszystkie fragmenty CSS, JavaScript, HTML, obrazy itp. W tym module utworzymy punkt początkowy zmapowany na zasobnik Cloud Storage, który utworzyliśmy na początku tego modułu. Punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych to cme-origin. Źródło sieci CDN to miejsce, w którym przechowywana jest cała treść źródłowa, zanim zostanie rozpowszechniona na serwerach tymczasowego przechowywania danych na serwerach brzegowych.

Do utworzenia punktu początkowego użyjemy polecenia gcloud edge-cache origins create. Wykonanie polecenia może zająć kilka minut.

Polecenie

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

Teraz, gdy mamy już skonfigurowany punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych, możemy utworzyć samą usługę tymczasowego przechowywania danych na serwerach brzegowych.

Utwórz plik `cme-demo.yaml`

Konfigurowanie usługi tymczasowego przechowywania danych na serwerach brzegowych odbywa się za pomocą pliku YAML. W Cloud Shell utwórz plik lokalny o nazwie cme-demo.yaml. Użyj narzędzia vi, nano lub innego edytora 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

Pozostawimy wszystkie domyślne ustawienia konfiguracji usługi tymczasowego przechowywania danych na serwerach brzegowych. W pliku powyżej znajdują się 3 wartości pól, które użytkownicy mogą chcieć zaktualizować:

name: nazwa instancji Media CDN – tutaj: cme-demo
hosts: listę nazw domen, które zostaną przetworzone przez tę usługę Media CDN – tutaj: demo.cme.com. Wykorzystamy to podczas prezentacji. Użyjemy adresu IP instancji Media CDN.
Origin: to jest punkt początkowy tymczasowego przechowywania danych na serwerach brzegowych, który właśnie utworzyliśmy w poprzednim kroku. Ustaw ją na cme-origin – nazwa punktu początkowego Media CDN.

Więcej informacji na temat różnych zmiennych, których możesz użyć w pliku YAML, znajdziesz w przewodniku po konfiguracji usługi tymczasowego przechowywania danych na serwerach brzegowych (w języku angielskim).

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 cme-origin dla tymczasowego przechowywania danych na serwerach brzegowych z hostem demo.cme.com. Aby utworzyć usługę, uruchom w Cloud Shell to polecenie:

Polecenie

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

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

Przykład wyjściowy

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'

Zapisz i skopiuj adres ipv4Addresses instancji usługi tymczasowego przechowywania danych na serwerach brzegowych – tutaj 34.104.36.157. Wykorzystamy go do aktualizacji pliku cme-demo.yaml, a później umożliwimy strumieniowanie transkodowanego filmu.

Aktualizowanie usługi tymczasowego przechowywania danych na serwerach brzegowych

W tym momencie warto zaktualizować konfigurację usługi tymczasowego przechowywania danych na serwerach brzegowych, aby móc używać adresu IP tej usługi do późniejszego strumieniowego przesyłania filmu. Plik YAML usługi tymczasowego przechowywania danych na serwerach brzegowych umożliwia nam wyświetlanie listy wszystkich nazw lub adresów IP hostów, z których usługa tymczasowego przechowywania danych na serwerach brzegowych akceptuje żądania. Na tym etapie jako hosta określiliśmy tylko demo.cme.com. Aby zapewnić rozpoznawanie nazw dla tej domeny, skonfiguruj strefę DNS w chmurze. Łatwiejszym rozwiązaniem jest jednak dodanie adresu IP do listy hostów w pliku yaml. Ponownie zmodyfikuj plik YAML, aby wyglądał tak 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, musimy ponownie zaimportować plik YAML. W terminalu Cloud Shell uruchom to polecenie:

Polecenie

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

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

W tym momencie instancja usługi tymczasowego przechowywania danych na serwerach brzegowych będzie akceptować żądania z hostem "demo.cme.com" lub adresem IP.

12. Generowanie sygnału wejściowego

Skoro mamy już skonfigurowane wszystkie wymagane usługi, możemy wygenerować sygnał wejściowy transmisji na żywo. W tej sekcji:

Zainstaluj FFmpeg – bezpłatne oprogramowanie typu open source.
Wyślij testowy sygnał na żywo do wejścia/kanału

1. Zainstaluj FFmpeg

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

Polecenie

sudo apt install ffmpeg -y

Po zakończeniu instalacji sprawdźmy, czy program FFmpeg został poprawnie zainstalowany. W tym celu sprawdź jego wersję:

Polecenie

ffmpeg -version

Przykład wyjściowy

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

Plik FFmpeg został poprawnie zainstalowany.

2. Uruchom sygnał transmisji na żywo do wejścia/kanału.

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

W terminalu Cloud Shell uruchom podane niżej polecenie, używając zmiennej środowiskowej URI utworzonej w sekcji „Create and Configure the wejściowych Endpoint” (Tworzenie i konfigurowanie wejściowego punktu końcowego). .

Polecenie

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

Aplikacja FFmpeg powinna wysłać testowy sygnał aktywny. To polecenie nie zwróci promptu. Sygnał będzie generowany, dopóki go nie zatrzymasz. Do końca tego modułu musisz otworzyć nowe okno Cloud Shell.

13. Otwórz nową wersję Cloud Shell

W tym momencie musisz otworzyć nowe okno Cloud Shell, aby kontynuować moduł, ponieważ program FFmpeg będzie działać na stałe, dopóki nie naciśniesz <CTRL+C> polecenie zatrzymania go i w ten sposób zatrzymania generowania sygnałów na żywo.

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

Uruchom pozostałą część modułu w nowo otwartym oknie Cloud Shell.

Konfiguracja zmiennych środowiskowych

To nowa powłoka CloudShell, więc musimy jeszcze raz ustawić zmienne środowiskowe. Do ustawiania zmiennych środowiskowych użyjemy polecenia source.

Polecenie

source ~/env_variables.txt

Sprawdź, czy zmienne są ustawione

Sprawdźmy, czy wszystkie wymagane zmienne środowiskowe są ustawione. W danych wyjściowych powinno pojawić się łącznie 6 zmiennych środowiskowych.

Polecenie

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

Przykład wyjściowy

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. Sprawdzanie, czy sygnał na żywo jest transkodowany

Uruchomimy zapytanie curl, aby opisać kanał. W danych wyjściowych powinniśmy zobaczyć, że parametr streamingState zmienił się z "AWAITING_INPUT" na "STREAMING"

Polecenie

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 z wyjściowym plikiem JSON powinien być widoczny znak "streamingState": "STREAMING". Oznacza on, że kanał jest przesyłany strumieniowo, a sygnał transmisji na żywo jest transkodowany.

Sprawdźmy też zawartość zasobnika, w którym powinien być plik manifestu i kilka segmentów wideo TS. Uruchom w Cloud Shell to polecenie, aby wyświetlić zawartość zasobnika, który został utworzony na początku modułu i który został użyty przez interfejs Live Streaming API do wygenerowania transkodowanego pliku manifestu sygnału na żywo i segmentów wideo TS:

Polecenie

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

Przykład wyjściowy

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

Na tym etapie zajmujemy się następującymi sprawami:

Interfejs Live Streaming API: sygnał na żywo jest generowany i transkodowany do zasobnika przez interfejs Live Streaming API.
Media CDN: jako punkt początkowy Media CDN skonfigurowano zasobnik na dane transmisji na żywo.

W kolejnych sekcjach zweryfikujemy usługę tymczasowego przechowywania danych na serwerach brzegowych i będziemy przesyłać strumieniowo transkodowany film za pomocą adresu IP anycast Media CDN.

15. Sprawdzanie działania instancji usługi tymczasowego przechowywania danych na serwerach brzegowych

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 tymczasowego przechowywania danych na serwerach brzegowych przy użyciu adresu IP tej usługi. Przy pierwszym dostępie do obiektu nie jest on jeszcze buforowany. Powinniśmy obserwować pamięć podręczną MISS. W przypadku pierwszego żądania obiekt jest odczytywany ze punktu początkowego i buforowany na brzegu. Każda kolejna próba uzyskania dostępu do tego samego pliku spowoduje zwrócenie HIT pamięci podręcznej, ponieważ obiekt jest teraz w pamięci podręcznej. Sprawdźmy to:

Uruchom w Cloud Shell to polecenie curl, aby uzyskać dostęp do transkodowanego pliku manifestu wideo zapisanego w punkcie początkowym tymczasowego przechowywania danych na serwerach brzegowych:

Polecenie

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

Zwróć uwagę na punkt rozpoznawania, w którym do rozpoznania nazwy instancji usługi tymczasowego przechowywania danych na serwerach brzegowych używamy adresu IP. Użyj zasady demo.cme.com:<IP>, w której IP to adres IP utworzonej właśnie instancji usługi tymczasowego przechowywania danych na serwerach brzegowych.

W danych wyjściowych poszukaj nagłówka x-cache-status.

Przykład wyjściowy

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

Zauważ, że w pamięci podręcznej brakuje obiektu, ponieważ obiekt nie został jeszcze umieszczony w pamięci podręcznej i jest odczytywany z pierwotnego miejsca.

Teraz wyślemy kilka żądań do pliku m3u8. Jeśli wszystko jest skonfigurowane prawidłowo, Media CDN powinna zacząć wyświetlać treści ze swojej pamięci podręcznej. Poniższe polecenie spowoduje wysłanie 10 żądań curl i wydrukowanie tylko nagłówka x-cache-status.

Polecenie

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

Wynikiem powinny być zawartość pamięci podręcznej hit i miss. Jeśli w danych wyjściowych zobaczysz trafienia w pamięci podręcznej, oznacza to, że Media CDN działa zgodnie z oczekiwaniami.

Przykład wyjściowy

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 działanie w pamięci podręcznej, ponieważ obiekt jest teraz w pamięci podręcznej na krawędziach. Usługa Cloud Medie Edge działa zgodnie z oczekiwaniami.

16. Transmituj transkodowany sygnał wideo na żywo przez VLC

W tym miejscu łączymy wszystkie elementy, nad którymi dotychczas pracowaliśmy:

Utworzyliśmy zasobnik o nazwie live-streaming-storage-$LOGNAME, do którego dotarła transmisja sygnału transkodowanego na żywo na treści HLS przez interfejs Live Streaming API.
Skonfigurowaliśmy interfejs Live Streaming API.
Zaczęliśmy we współpracy z FFmpeg sygnał na żywo RTMP, który przesyła dane wejściowe/kanał interfejsu Live Streaming API.
Upewniliśmy się, że sygnał na żywo jest przesłany do kanału i upewniliśmy się, że kanał działa w trybie streaming.
Sprawdziliśmy, czy transkodowane pliki (plik manifestu + segmenty TS) zostały wygenerowane 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.
Instancja tymczasowego przechowywania danych na serwerach brzegowych o nazwie cme-demo została skonfigurowana z punktem początkowym cme-origin.
Zweryfikowaliśmy zachowanie instancji usługi tymczasowego przechowywania danych na serwerach brzegowych pod kątem działania (brak w pamięci podręcznej, trafienie w pamięci podręcznej).

Doszliśmy właśnie do momentu, w którym będziemy mogli używać odtwarzacza wideo do transmitowania transkodowanego sygnału na żywo przez pamięć podręczną Media CDN. Użyjemy do tego odtwarzacza VLC. VLC Player to bezpłatny, międzyplatformowy odtwarzacz multimedialny typu open source, który umożliwia odtwarzanie większości plików multimedialnych. Odtwarzane są adaptacyjne formaty multimediów (takie jak DASH i HLS). Wykorzystuje zasadę adaptacyjnego strumieniowego przesyłania danych – w zależności od jakości połączenia sieciowego i dostępnej przepustowości odtwarzacz dostosowuje jakość odtwarzanego filmu. W ramach właśnie wykonanego zadania transkodowania użyliśmy domyślnych gotowych ustawień i wygenerowaliśmy „tylko” 2 jakości: SD i HD. Gdy zaczniemy odtwarzać film w odtwarzaczu, powinien on zacząć odtwarzać treści w formacie SD i szybko przełączyć się na format HD, jeśli połączenie sieciowe będzie wystarczająco dobre.

Będziemy przesyłać strumieniowo transkodowany sygnał HLS (powszechnie obsługiwany format wideo Apple). Powiązany plik nazywa się main.m3u8 – jest to plik manifestu HLS. Plik manifestu wskazuje segmenty wideo TS.

Aby używać odtwarzacza VLC Player, wejdź na https://www.videolan.org/vlc/ i pobierz jego wersję na swój system operacyjny laptopa. Aplikacja VLC jest dostępna dla systemów Windows, MacOSX, Linux, Android i iOS.

Zainstaluj odtwarzacz na laptopie i uruchom go. W kolejnych kilku krokach będziemy używać odtwarzacza w wersji na system MacOSX.

Aby odtworzyć film, przejdź do „Plik” / "Otwarta sieć":

Skonfiguruj za pomocą:

Adres URL: http://<Replace_With_Edge_Cache_IP>/main.m3u8. To jest adres URL filmu, który chcesz transmitować. Uwaga:
Adres IP instancji Media CDN: 34.105.35.246. Zastąp go adresem IP wdrożonej usługi Cloud Media.
Ścieżka do pliku wideo manifestu: „/”. Ścieżka, którą użyliśmy w zasobniku live-streaming-storage-$LOGNAME do przechowywania transkodowanych plików sygnałów na żywo. Ścieżka jest ścieżką główną tutaj: „/”.
Nazwa pliku wideo manifestu: plik manifestu HLS, main.m3u8.

I kliknij „Otwórz”. Powinna zacząć się odtwarzać transkodowana transmisja wideo na żywo. Film będzie wyglądać tak jak na zrzucie ekranu poniżej. Licznik na ekranie uruchamia się w przyrostach co 1. Powinno być słychać nieprzerwany sygnał.

To podstawowy testowy sygnał RTMP wygenerowany przez FFmpeg, transkodowany na HLS przez interfejs Live Streaming API i udostępniany przez pamięć podręczną Media CDN:

Możesz użyć dowolnego innego odtwarzacza HLS lub MPEG DASH. Oto kilka kwestii, które warto wziąć pod uwagę:

Quicktime Player – instalowany domyślnie na komputerach Mac. To samo: otwórz połączenie sieciowe pod adresem http://34.104.36.157/main.m3u8 – zastąp adres IP adresem z instancji usługi tymczasowego przechowywania danych na serwerach brzegowych.

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 usługi 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 się wyświetlić panel o nazwie „Media Edge Metrics”. Kliknij tę pozycję, aby wyświetlić dane:

18. Uporządkuj środowisko modułu

Gratulujemy ukończenia modułu. W tej sekcji usuniemy wszystkie zasoby utworzone w tym module.

Zatrzymaj sygnał FFmpeg:

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

Zatrzymaj kanał transmisji na żywo:

Polecenie

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"

Usuń kanał transmisji na żywo:

Polecenie

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 wprowadzania danych transmisji na żywo:

Polecenie

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:

Polecenie

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

Usuń instancję usługi tymczasowego przechowywania danych na serwerach brzegowych:

Polecenie

gcloud edge-cache services delete cme-demo

Potwierdź usunięcie, wpisując „Y” po wyświetleniu monitu

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

Polecenie

gcloud edge-cache origins delete cme-origin

Potwierdź usunięcie, wpisując „Y” po wyświetleniu monitu

Usuwanie panelu niestandardowego

Polecenie

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 pakietu SDK Google Cloud

Sprawdzanie wersji pakietu SDK

Następne kroki

5. Wymagania wstępne

1. Skonfiguruj zmienne środowiskowe

Identyfikator projektu i nazwa użytkownika

Utwórz plik env_variables

Konfiguracja zmiennych środowiskowych

Sprawdź, czy zmienne są ustawione

2. Włącz wymagane interfejsy API usługi

Włączanie interfejsu Network Services API

Włączanie interfejsu Certificate Manager API

Włączanie interfejsu Live Stream API

Włączanie interfejsu Media CDN Edge Cache API

Sprawdzanie, 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 plikuinput.json

Tworzenie wejściowego punktu końcowego

Sprawdzanie stanu

Zapisz identyfikator URI

9. Utwórz & Konfigurowanie kanału transmisji na żywo

Tworzenie pliku channel.json

Utwórz kanał

Sprawdzanie stanu

10. Uruchom kanał transmisji na żywo

1. Uruchom kanał

2. Jak sprawdzić stan kanału

11. Skonfiguruj Media CDN

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

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

Utwórz plik 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. Zainstaluj FFmpeg

2. Uruchom sygnał transmisji na żywo do wejścia/kanału.

13. Otwórz nową wersję Cloud Shell

Konfiguracja zmiennych środowiskowych

Sprawdź, czy zmienne są ustawione

14. Sprawdzanie, czy sygnał na żywo jest transkodowany

15. Sprawdzanie działania instancji usługi tymczasowego przechowywania danych na serwerach brzegowych

16. Transmituj transkodowany sygnał wideo na żywo przez VLC

17. Monitorowanie Media CDN

18. Uporządkuj środowisko modułu

Zatrzymaj sygnał FFmpeg:

Zatrzymaj kanał transmisji na żywo:

Usuń kanał transmisji na żywo:

Usuń punkt końcowy wprowadzania danych transmisji na żywo:

Usuwanie zasobnika GCS:

Usuń instancję usługi tymczasowego przechowywania danych na serwerach brzegowych:

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

Usuwanie panelu niestandardowego

Utwórz plik `env_variables`

Utwórz plik `cme-demo.yaml`