Creare una sessione dal vivo

Con l'API Video Stitcher, crei una sessione live ogni volta che avvii la riproduzione di un live streaming in cui gli annunci pubblicati da Google Ad Manager vengono uniti dinamicamente durante le interruzioni pubblicitarie. La risposta specifica l'URL di riproduzione e la configurazione della sessione live.

Questo documento descrive come creare e gestire una sessione dal vivo. Per ulteriori dettagli, vedi la documentazione REST.

Prima di iniziare

• Crea una configurazione pubblicata. Per l'integrazione con Google Ad Manager, assicurati che l'oggetto gamLiveConfig sia impostato.
• Se specifichi uno slate, assicurati che l'oggetto gamSlate è impostato sullo slate che registri.

Creare una sessione dal vivo

Per creare una sessione dal vivo utilizzando direttamente l'API, utilizza il metodo projects.locations.liveSessions.create.

Il campo liveConfig è l'unico campo obbligatorio nel corpo JSON. Puoi impostare oppure sostituisci i seguenti parametri facoltativi per sessione dal vivo (come mostrato in il seguente esempio REST):

• manifestOptions: specifica quali versioni video vengono generate nel file manifest del video unito allo stitching e l'ordine delle rappresentazioni; consulta la documentazione sulle opzioni manifest
• adTracking: seleziona monitoraggio degli annunci lato client o il monitoraggio degli annunci lato server; questo sostituisce il valore nella configurazione in tempo reale per sessione
• targetingParameters: un tag annuncio Google Ad Manager può contenere parametri di targeting aggiornabili per sessione; fornisci una mappatura in questo campo (ad esempio, per sostituire [my_key] con la stringa my_value, vedi l'esempio REST)

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• PROJECT_NUMBER: il numero del tuo progetto Google Cloud nel campo Numero progetto della pagina Impostazioni IAM
• LOCATION: la posizione in cui creare session; utilizza una delle regioni supportate
  Sedi dei negozi
  • us-central1
  • us-east1
  • us-west1
  • asia-east1
  • asia-south1
  • asia-southeast1
  • europe-west1
  • southamerica-east1
• LIVE_CONFIG_ID: l'identificatore definito dall'utente per la configurazione attiva

Per inviare la richiesta, espandi una delle seguenti opzioni:

curl (Linux, macOS o Cloud Shell)

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

cat > request.json << 'EOF'
{
  "liveConfig": "projects/PROJECT_NUMBER/locations/LOCATION/liveConfigs/LIVE_CONFIG_ID",
  "manifestOptions": {
    "includeRenditions": [
      {
        "bitrateBps": 150000,
        "codecs": "hvc1.1.4.L126.B0"
      },
      {
        "bitrateBps": 440000,
        "codecs": "hvc1.1.4.L126.B0"
      }
    ],
    "bitrateOrder": "DESCENDING"
  },
  "adTracking": "SERVER",
  "gamSettings": {
    "targetingParameters": {
      "my_key": "my_value",
    },
  }
}
EOF

Quindi, esegui il seguente comando per inviare la richiesta REST:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://videostitcher.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/liveSessions"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso alla CLI gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

@'
{
  "liveConfig": "projects/PROJECT_NUMBER/locations/LOCATION/liveConfigs/LIVE_CONFIG_ID",
  "manifestOptions": {
    "includeRenditions": [
      {
        "bitrateBps": 150000,
        "codecs": "hvc1.1.4.L126.B0"
      },
      {
        "bitrateBps": 440000,
        "codecs": "hvc1.1.4.L126.B0"
      }
    ],
    "bitrateOrder": "DESCENDING"
  },
  "adTracking": "SERVER",
  "gamSettings": {
    "targetingParameters": {
      "my_key": "my_value",
    },
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi, esegui questo comando per inviare la richiesta REST:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://videostitcher.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/liveSessions" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/liveSessions/SESSION_ID",
  "playUri": "PLAY_URI",
  "manifestOptions": {
    "includeRenditions": [
      {
        "bitrateBps": 150000,
        "codecs": "hvc1.1.4.L126.B0"
      },
      {
        "bitrateBps": 440000,
        "codecs": "hvc1.1.4.L126.B0"
      }
    ],
    "bitrateOrder": "DESCENDING"
  },
  "gamSettings": {
    "streamId": "STREAM_ID"
  },
  "liveConfig": "projects/PROJECT_NUMBER/locations/LOCATION/liveConfigs/LIVE_CONFIG_ID",
  "adTracking": "SERVER"
}

C#

Prima di provare questo esempio, segui le istruzioni per la configurazione di C# nel Guida rapida dell'API Video Stitcher con librerie client. Per ulteriori informazioni, consulta API C# dell'API Video Stitcher documentazione di riferimento.

Per autenticarti all'API Video Stitcher, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

using Google.Cloud.Video.Stitcher.V1;

public class CreateLiveSessionSample
{
    public LiveSession CreateLiveSession(
        string projectId, string location, string liveConfigId)
    {
        // Create the client.
        VideoStitcherServiceClient client = VideoStitcherServiceClient.Create();

        CreateLiveSessionRequest request = new CreateLiveSessionRequest
        {
            Parent = $"projects/{projectId}/locations/{location}",
            LiveSession = new LiveSession
            {
                LiveConfig = LiveConfigName.FormatProjectLocationLiveConfig(projectId, location, liveConfigId)
            }
        };

        // Call the API.
        LiveSession session = client.CreateLiveSession(request);

        // Return the result.
        return session;
    }
}

Go

Prima di provare questo esempio, segui le Goistruzioni di configurazione riportate nella guida rapida all'API Video Stitcher che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Video Stitcher Go.

Per autenticarti all'API Video Stitcher, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

	stitcher "cloud.google.com/go/video/stitcher/apiv1"
	"cloud.google.com/go/video/stitcher/apiv1/stitcherpb"
)

// createLiveSession creates a livestream session in which to insert ads.
// Live sessions are ephemeral resources that expire after a few minutes.
func createLiveSession(w io.Writer, projectID, liveConfigID string) error {
	// projectID := "my-project-id"
	// liveConfigID := "my-live-config"
	location := "us-central1"
	ctx := context.Background()
	client, err := stitcher.NewVideoStitcherClient(ctx)
	if err != nil {
		return fmt.Errorf("stitcher.NewVideoStitcherClient: %w", err)
	}
	defer client.Close()

	req := &stitcherpb.CreateLiveSessionRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		LiveSession: &stitcherpb.LiveSession{
			LiveConfig: fmt.Sprintf("projects/%s/locations/%s/liveConfigs/%s", projectID, location, liveConfigID),
		},
	}
	// Creates the live session.
	response, err := client.CreateLiveSession(ctx, req)
	if err != nil {
		return fmt.Errorf("client.CreateLiveSession: %w", err)
	}

	fmt.Fprintf(w, "Live session: %v\n", response.GetName())
	fmt.Fprintf(w, "Play URI: %v", response.GetPlayUri())
	return nil
}

Java

Prima di provare questo esempio, segui le Javaistruzioni di configurazione riportate nella guida rapida all'API Video Stitcher che utilizza le librerie client. Per ulteriori informazioni, consulta API Java dell'API Video Stitcher documentazione di riferimento.

Per autenticarti all'API Video Stitcher, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.video.stitcher.v1.CreateLiveSessionRequest;
import com.google.cloud.video.stitcher.v1.LiveConfigName;
import com.google.cloud.video.stitcher.v1.LiveSession;
import com.google.cloud.video.stitcher.v1.LocationName;
import com.google.cloud.video.stitcher.v1.VideoStitcherServiceClient;
import java.io.IOException;

public class CreateLiveSession {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String location = "us-central1";
    String liveConfigId = "my-live-config-id";

    createLiveSession(projectId, location, liveConfigId);
  }

  // Creates a live session given the parameters in the supplied live config.
  // For more information, see
  // https://cloud.google.com/video-stitcher/docs/how-to/managing-live-sessions.
  public static LiveSession createLiveSession(
      String projectId, String location, String liveConfigId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (VideoStitcherServiceClient videoStitcherServiceClient =
        VideoStitcherServiceClient.create()) {
      CreateLiveSessionRequest createLiveSessionRequest =
          CreateLiveSessionRequest.newBuilder()
              .setParent(LocationName.of(projectId, location).toString())
              .setLiveSession(
                  LiveSession.newBuilder()
                      .setLiveConfig(LiveConfigName.format(projectId, location, liveConfigId)))
              .build();

      LiveSession response = videoStitcherServiceClient.createLiveSession(createLiveSessionRequest);
      System.out.println("Created live session: " + response.getName());
      System.out.println("Play URI: " + response.getPlayUri());
      return response;
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida dell'API Video Stitcher con librerie client. Per ulteriori informazioni, consulta API Node.js dell'API Video Stitcher documentazione di riferimento.

Per autenticarti all'API Video Stitcher, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// projectId = 'my-project-id';
// location = 'us-central1';
// liveConfigId = 'my-live-config-id';

// Imports the Video Stitcher library
const {VideoStitcherServiceClient} =
  require('@google-cloud/video-stitcher').v1;
// Instantiates a client
const stitcherClient = new VideoStitcherServiceClient();

async function createLiveSession() {
  // Construct request
  const request = {
    parent: stitcherClient.locationPath(projectId, location),
    liveSession: {
      liveConfig: stitcherClient.liveConfigPath(
        projectId,
        location,
        liveConfigId
      ),
    },
  };

  const [session] = await stitcherClient.createLiveSession(request);
  console.log(`Live session: ${session.name}`);
  console.log(`Play URI: ${session.playUri}`);
}

createLiveSession().catch(err => {
  console.error(err.message);
  process.exitCode = 1;
});

PHP

Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida dell'API Video Stitcher con librerie client. Per ulteriori informazioni, consulta API PHP dell'API Video Stitcher documentazione di riferimento.

Per autenticarti all'API Video Stitcher, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

use Google\Cloud\Video\Stitcher\V1\Client\VideoStitcherServiceClient;
use Google\Cloud\Video\Stitcher\V1\CreateLiveSessionRequest;
use Google\Cloud\Video\Stitcher\V1\LiveSession;

/**
 * Creates a live session. Live sessions are ephemeral resources that expire
 * after a few minutes.
 *
 * @param string $callingProjectId     The project ID to run the API call under
 * @param string $location             The location of the session
 * @param string $liveConfigId         The live config ID to use to create the
 *                                     live session
 */
function create_live_session(
    string $callingProjectId,
    string $location,
    string $liveConfigId
): void {
    // Instantiate a client.
    $stitcherClient = new VideoStitcherServiceClient();

    $parent = $stitcherClient->locationName($callingProjectId, $location);
    $liveConfig = $stitcherClient->liveConfigName($callingProjectId, $location, $liveConfigId);
    $liveSession = new LiveSession();
    $liveSession->setLiveConfig($liveConfig);

    // Run live session creation request
    $request = (new CreateLiveSessionRequest())
        ->setParent($parent)
        ->setLiveSession($liveSession);
    $response = $stitcherClient->createLiveSession($request);

    // Print results
    printf('Live session: %s' . PHP_EOL, $response->getName());
}

Python

Prima di provare questo esempio, segui le Pythonistruzioni di configurazione riportate nella guida rapida all'API Video Stitcher che utilizza le librerie client. Per ulteriori informazioni, consulta API Python dell'API Video Stitcher documentazione di riferimento.

Per autenticarti all'API Video Stitcher, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import argparse

from google.cloud.video import stitcher_v1
from google.cloud.video.stitcher_v1.services.video_stitcher_service import (
    VideoStitcherServiceClient,
)


def create_live_session(
    project_id: str, location: str, live_config_id: str
) -> stitcher_v1.types.LiveSession:
    """Creates a live session. Live sessions are ephemeral resources that expire
    after a few minutes.
    Args:
        project_id: The GCP project ID.
        location: The location in which to create the session.
        live_config_id: The user-defined live config ID.

    Returns:
        The live session resource.
    """

    client = VideoStitcherServiceClient()

    parent = f"projects/{project_id}/locations/{location}"
    live_config = (
        f"projects/{project_id}/locations/{location}/liveConfigs/{live_config_id}"
    )

    live_session = stitcher_v1.types.LiveSession(live_config=live_config)

    response = client.create_live_session(parent=parent, live_session=live_session)
    print(f"Live session: {response.name}")
    return response

Ruby

Prima di provare questo esempio, segui le istruzioni per la configurazione di Ruby nel Guida rapida dell'API Video Stitcher con librerie client. Per ulteriori informazioni, consulta API Ruby dell'API Video Stitcher documentazione di riferimento.

Per autenticarti all'API Video Stitcher, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

require "google/cloud/video/stitcher"

##
# Create a live stream session. Live sessions are ephemeral resources
# that expire after a few minutes.
#
# @param project_id [String] Your Google Cloud project (e.g. `my-project`)
# @param location [String] The location (e.g. `us-central1`)
# @param live_config_id [String] Your live config name (e.g. `my-live-config`)
#
def create_live_session project_id:, location:, live_config_id:
  # Create a Video Stitcher client.
  client = Google::Cloud::Video::Stitcher.video_stitcher_service

  # Build the resource name of the parent.
  parent = client.location_path project: project_id, location: location

  # Build the resource name of the live config.
  live_config_name = client.live_config_path project: project_id,
                                             location: location,
                                             live_config: live_config_id

  # Set the session fields.
  new_live_session = {
    live_config: live_config_name
  }

  response = client.create_live_session parent: parent,
                                        live_session: new_live_session

  # Print the live session name.
  puts "Live session: #{response.name}"
end

L'API Video Stitcher genera un ID sessione univoco per ogni richiesta. R scade se l'playUri non è stata richiesta negli ultimi 5 minuti.

Puoi utilizzare il valore STREAM_ID restituito per esaminare la sessione dal vivo.

Controllare le sessioni dal vivo attivate da Google Ad Manager

Per visualizzare i dettagli dei tag annuncio per le sessioni, utilizza il Monitoraggio attività di streaming in Ad Manager per visualizzare i dettagli sulle richieste di annunci. Puoi usare STREAM_ID per eseguire il debug della sessione di streaming. Per trovare il STREAM_ID per una sessione dal vivo, vedi Creare una sessione.