Guía de inicio rápido de las emisiones en directo de MPEG-DASH

Guía de inicio rápido de las emisiones en directo de MPEG-DASH

En esta página se muestra cómo crear una tarea básica de emisión en directo de MPEG-DASH con la configuración predeterminada de la API Live Stream y curl, PowerShell o las bibliotecas cliente.

Antes de empezar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
Install the Google Cloud CLI.
Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.
Para inicializar gcloud CLI, ejecuta el siguiente comando:
gcloud init
Create or select a Google Cloud project.
Roles required to select or create a project
• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.
• Create a Google Cloud project:

  gcloud projects create PROJECT_ID

  Replace PROJECT_ID with a name for the Google Cloud project you are creating.

• Select the Google Cloud project that you created:

  gcloud config set project PROJECT_ID

  Replace PROJECT_ID with your Google Cloud project name.
Verify that billing is enabled for your Google Cloud project.
Enable the Live Stream API:
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
gcloud services enable livestream.googleapis.com
Create local authentication credentials for your user account:
gcloud auth application-default login
If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.
Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/livestream.editor, roles/storage.admin
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
Replace the following:
• PROJECT_ID: your project ID.
• USER_IDENTIFIER: the identifier for your user account—for example, [e-mail].
• ROLE: the IAM role that you grant to your user account.

Install the Google Cloud CLI.

Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Create or select a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

• Create a Google Cloud project:

  gcloud projects create PROJECT_ID

  Replace PROJECT_ID with a name for the Google Cloud project you are creating.

• Select the Google Cloud project that you created:

  gcloud config set project PROJECT_ID

  Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the Live Stream API:

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

gcloud services enable livestream.googleapis.com

Create local authentication credentials for your user account:

gcloud auth application-default login

If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/livestream.editor, roles/storage.admin

gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

Replace the following:

• PROJECT_ID: your project ID.
• USER_IDENTIFIER: the identifier for your user account—for example, [e-mail].
• ROLE: the IAM role that you grant to your user account.

Crea un segmento de Cloud Storage

Crea un segmento de Cloud Storage para almacenar el archivo de manifiesto y los archivos de segmento de la emisión en directo.

1. Create a Cloud Storage bucket:

   gcloud storage buckets create gs://BUCKET_NAME

   Replace BUCKET_NAME with a bucket name that meets the bucket naming requirements.

   Instalar un codificador

   Para usar la API, necesitas un codificador que genere las secuencias de entrada que procesa la API.

   Instala ffmpeg, ya que en esta página se explica cómo usar ffmpeg para generar flujos de entrada. Puedes instalarlo en Cloud Shell con el siguiente comando.

   sudo apt install ffmpeg
   

   Crear un endpoint de entrada

   Para iniciar una emisión en directo, primero debes usar el método projects.locations.inputs.create para crear un endpoint de entrada. Envías el flujo de entrada a este endpoint.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: ubicación en la que se creará el punto final de entrada. Usa una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • INPUT_ID: identificador definido por el usuario del nuevo endpoint de entrada que se va a crear (al que se envía el flujo de entrada). Este valor debe tener entre 1 y 63 caracteres, empezar y terminar con [a-z0-9], y puede incluir guiones (-) entre caracteres. Por ejemplo, my-input.

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual:

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

   A continuación, ejecuta el siguiente comando para enviar tu solicitud REST:

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

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual:

   @'
   {
     "type": "RTMP_PUSH"
   }
   '@  | Out-File -FilePath request.json -Encoding utf8

   A continuación, ejecuta el siguiente comando para enviar tu solicitud 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://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/inputs?inputId=INPUT_ID" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
       "createTime": CREATE_TIME,
       "target": "projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID",
       "verb": "create",
       "requestedCancellation": false,
       "apiVersion": "v1"
     },
     "done": false
   }
   

   C#

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream C#.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   using Google.Api.Gax.ResourceNames;
   using Google.Cloud.Video.LiveStream.V1;
   using Google.LongRunning;
   using System.Threading.Tasks;
   
   public class CreateInputSample
   {
       public async Task<Input> CreateInputAsync(
            string projectId, string locationId, string inputId)
       {
           // Create the client.
           LivestreamServiceClient client = LivestreamServiceClient.Create();
   
           CreateInputRequest request = new CreateInputRequest
           {
               ParentAsLocationName = LocationName.FromProjectLocation(projectId, locationId),
               InputId = inputId,
               Input = new Input
               {
                   Type = Input.Types.Type.RtmpPush
               }
           };
   
           // Make the request.
           Operation<Input, OperationMetadata> response = await client.CreateInputAsync(request);
   
           // Poll until the returned long-running operation is complete.
           Operation<Input, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
   
           // Retrieve the operation result.
           return completedResponse.Result;
       }
   }

   Go

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Go.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	livestream "cloud.google.com/go/video/livestream/apiv1"
   	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
   )
   
   // createInput creates an input endpoint. You send an input video stream to this
   // endpoint.
   func createInput(w io.Writer, projectID, location, inputID string) error {
   	// projectID := "my-project-id"
   	// location := "us-central1"
   	// inputID := "my-input"
   	ctx := context.Background()
   	client, err := livestream.NewClient(ctx)
   	if err != nil {
   		return fmt.Errorf("NewClient: %w", err)
   	}
   	defer client.Close()
   
   	req := &livestreampb.CreateInputRequest{
   		Parent:  fmt.Sprintf("projects/%s/locations/%s", projectID, location),
   		InputId: inputID,
   		Input: &livestreampb.Input{
   			Type: livestreampb.Input_RTMP_PUSH,
   		},
   	}
   	// Creates the input.
   	op, err := client.CreateInput(ctx, req)
   	if err != nil {
   		return fmt.Errorf("CreateInput: %w", err)
   	}
   	response, err := op.Wait(ctx)
   	if err != nil {
   		return fmt.Errorf("Wait: %w", err)
   	}
   
   	fmt.Fprintf(w, "Input: %v", response.Name)
   	return nil
   }
   

   Java

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Java.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import com.google.cloud.video.livestream.v1.CreateInputRequest;
   import com.google.cloud.video.livestream.v1.Input;
   import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
   import com.google.cloud.video.livestream.v1.LocationName;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class CreateInput {
   
     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 inputId = "my-input-id";
   
       createInput(projectId, location, inputId);
     }
   
     public static void createInput(String projectId, String location, String inputId)
         throws InterruptedException, ExecutionException, TimeoutException, 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. After completing all of your requests, call
       // the "close" method on the client to safely clean up any remaining background resources.
       LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create();
       var createInputRequest =
           CreateInputRequest.newBuilder()
               .setParent(LocationName.of(projectId, location).toString())
               .setInputId(inputId)
               .setInput(Input.newBuilder().setType(Input.Type.RTMP_PUSH).build())
               .build();
       // First API call in a project can take up to 15 minutes.
       Input result =
           livestreamServiceClient.createInputAsync(createInputRequest).get(15, TimeUnit.MINUTES);
       System.out.println("Input: " + result.getName());
       livestreamServiceClient.close();
     }
   }

   Node.js

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Node.js.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // projectId = 'my-project-id';
   // location = 'us-central1';
   // inputId = 'my-input';
   
   // Imports the Livestream library
   const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;
   
   // Instantiates a client
   const livestreamServiceClient = new LivestreamServiceClient();
   
   async function createInput() {
     // Construct request
     const request = {
       parent: livestreamServiceClient.locationPath(projectId, location),
       inputId: inputId,
       input: {
         type: 'RTMP_PUSH',
       },
     };
   
     // Run request
     const [operation] = await livestreamServiceClient.createInput(request);
     const response = await operation.promise();
     const [input] = response;
     console.log(`Input: ${input.name}`);
   }
   
   createInput();

   PHP

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream PHP.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   use Google\Cloud\Video\LiveStream\V1\Input;
   use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
   use Google\Cloud\Video\LiveStream\V1\CreateInputRequest;
   
   /**
    * Creates an input. You send an input video stream to this endpoint.
    *
    * @param string  $callingProjectId   The project ID to run the API call under
    * @param string  $location           The location of the input
    * @param string  $inputId            The ID of the input to be created
    */
   function create_input(
       string $callingProjectId,
       string $location,
       string $inputId
   ): void {
       // Instantiate a client.
       $livestreamClient = new LivestreamServiceClient();
   
       $parent = $livestreamClient->locationName($callingProjectId, $location);
       $input = (new Input())
           ->setType(Input\Type::RTMP_PUSH);
   
       // Run the input creation request. The response is a long-running operation ID.
       $request = (new CreateInputRequest())
           ->setParent($parent)
           ->setInput($input)
           ->setInputId($inputId);
       $operationResponse = $livestreamClient->createInput($request);
       $operationResponse->pollUntilComplete();
       if ($operationResponse->operationSucceeded()) {
           $result = $operationResponse->getResult();
           // Print results
           printf('Input: %s' . PHP_EOL, $result->getName());
       } else {
           $error = $operationResponse->getError();
           // handleError($error)
       }
   }

   Python

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Python.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import argparse
   
   from google.cloud.video import live_stream_v1
   from google.cloud.video.live_stream_v1.services.livestream_service import (
       LivestreamServiceClient,
   )
   
   
   def create_input(
       project_id: str, location: str, input_id: str
   ) -> live_stream_v1.types.Input:
       """Creates an input.
       Args:
           project_id: The GCP project ID.
           location: The location in which to create the input.
           input_id: The user-defined input ID."""
   
       client = LivestreamServiceClient()
   
       parent = f"projects/{project_id}/locations/{location}"
   
       input = live_stream_v1.types.Input(
           type_="RTMP_PUSH",
       )
       operation = client.create_input(parent=parent, input=input, input_id=input_id)
       response = operation.result(900)
       print(f"Input: {response.name}")
   
       return response
   
   

   Ruby

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Ruby.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   require "google/cloud/video/live_stream"
   
   ##
   # Create an input endpoint
   #
   # @param project_id [String] Your Google Cloud project (e.g. "my-project")
   # @param location [String] The location (e.g. "us-central1")
   # @param input_id [String] Your input name (e.g. "my-input")
   #
   def create_input project_id:, location:, input_id:
     # Create a Live Stream client.
     client = Google::Cloud::Video::LiveStream.livestream_service
   
     # Build the resource name of the parent.
     parent = client.location_path project: project_id, location: location
   
     # Set the input fields.
     new_input = {
       type: Google::Cloud::Video::LiveStream::V1::Input::Type::RTMP_PUSH
     }
   
     operation = client.create_input parent: parent, input: new_input, input_id: input_id
   
     # The returned object is of type Gapic::Operation. You can use this
     # object to check the status of an operation, cancel it, or wait
     # for results. Here is how to block until completion:
     operation.wait_until_done!
   
     # Print the input name.
     puts "Input: #{operation.response.name}"
   end

   Copia el OPERATION_ID devuelto para usarlo en la siguiente sección.

   Comprobar el resultado

   Usa el método projects.locations.operations.get para comprobar si se ha creado el endpoint de entrada. Si la respuesta contiene "done: false", repite el comando hasta que la respuesta contenga "done: true". Crear el primer punto final de entrada en una región puede tardar hasta 10 minutos.

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación de tu endpoint de entrada. Usa una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • OPERATION_ID: el identificador de la operación

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   curl -X GET \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID"

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method GET `
       -Headers $headers `
       -Uri "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
       "createTime": CREATE_TIME,
       "endTime": END_TIME,
       "target": "projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID",
       "verb": "create",
       "requestedCancellation": false,
       "apiVersion": "v1"
     },
     "done": true,
     "response": {
       "@type": "type.googleapis.com/google.cloud.video.livestream.v1.Input",
       "name": "projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID",
       "createTime": CREATE_TIME,
       "updateTime": UPDATE_TIME,
       "type": "RTMP_PUSH",
       "uri":  INPUT_STREAM_URI, # For example, "rtmp://1.2.3.4/live/b8ebdd94-c8d9-4d88-a16e-b963c43a953b",
       "tier": "HD"
     }
   }
   

   Busca el campo uri y copia el INPUT_STREAM_URI devuelto para usarlo más adelante en la sección Enviar el flujo de entrada.

   Crear canales

   Para transcodificar el flujo de entrada en un flujo de salida, debes crear un recurso de canal.

   Para crear un canal, usa el método projects.locations.channels.create. En el siguiente ejemplo se crea un canal que genera una emisión en directo MPEG-DASH que consta de una sola representación de alta definición (1280x720).

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación en la que se creará el canal. Usa una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • CHANNEL_ID: identificador definido por el usuario del canal que se va a crear. Este valor debe tener entre 1 y 63 caracteres, empezar y terminar con [a-z0-9], y puede contener guiones (-) entre caracteres.
   • INPUT_ID: identificador definido por el usuario del endpoint de entrada
   • BUCKET_NAME: el nombre del segmento de Cloud Storage que has creado para alojar el manifiesto de la emisión en directo y los archivos de segmento

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual:

   cat > request.json << 'EOF'
   {
     "inputAttachments": [
       {
         "key": "my-input",
         "input": "projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID"
       }
     ],
     "output": {
       "uri": "gs://BUCKET_NAME"
     },
     "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",
         "elementaryStreams": ["es_video"],
         "segmentSettings": { "segmentDuration": "2s" }
       },
       {
         "key": "mux_audio",
         "elementaryStreams": ["es_audio"],
         "segmentSettings": { "segmentDuration": "2s" }
       }
     ],
     "manifests": [
       {
         "key": "manifest_dash",
         "fileName": "main.mpd",
         "type": "DASH",
         "muxStreams": [
           "mux_video",
           "mux_audio"
         ],
         "maxSegmentCount": 5
       }
     ]
   }
   EOF

   A continuación, ejecuta el siguiente comando para enviar tu solicitud REST:

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

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual:

   @'
   {
     "inputAttachments": [
       {
         "key": "my-input",
         "input": "projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID"
       }
     ],
     "output": {
       "uri": "gs://BUCKET_NAME"
     },
     "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",
         "elementaryStreams": ["es_video"],
         "segmentSettings": { "segmentDuration": "2s" }
       },
       {
         "key": "mux_audio",
         "elementaryStreams": ["es_audio"],
         "segmentSettings": { "segmentDuration": "2s" }
       }
     ],
     "manifests": [
       {
         "key": "manifest_dash",
         "fileName": "main.mpd",
         "type": "DASH",
         "muxStreams": [
           "mux_video",
           "mux_audio"
         ],
         "maxSegmentCount": 5
       }
     ]
   }
   '@  | Out-File -FilePath request.json -Encoding utf8

   A continuación, ejecuta el siguiente comando para enviar tu solicitud 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://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels?channelId=CHANNEL_ID" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
       "createTime": CREATE_TIME,
       "target": "projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID",
       "verb": "create",
       "requestedCancellation": false,
       "apiVersion": "v1"
     },
     "done": false
   }
   

   Obtener el canal

   Puedes comprobar el resultado de la operación de creación de canal con el nuevo ID de operación.

   Una vez que se haya creado el canal, usa el método projects.locations.channels.get para consultar el estado del canal.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación de tu canal. Elige una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • CHANNEL_ID: identificador definido por el usuario del canal

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   curl -X GET \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID"

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method GET `
       -Headers $headers `
       -Uri "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID",
     "createTime": CREATE_TIME,
     "updateTime": UPDATE_TIME,
     "inputAttachments": [
       {
         "key": "INPUT_ID",
         "input": "projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID"
       }
     ],
     "activeInput": "INPUT_ID",
     "output": {
       "uri": "gs://BUCKET_NAME"
     },
     "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,
           "channelLayout": ["fl", "fr"],
           "sampleRateHertz": 48000
         },
         "key": "es_audio"
       }
     ],
     "muxStreams": [
       {
         "key": "mux_video",
         "container": "fmp4",
         "elementaryStreams": ["es_video"],
         "segmentSettings": { "segmentDuration": "2s" }
       },
       {
         "key": "mux_audio",
         "container": "fmp4",
         "elementaryStreams": ["es_audio"],
         "segmentSettings": { "segmentDuration": "2s" }
       }
     ],
     "manifests": [
       {
         "key": "manifest_dash",
         "fileName": "main.mpd",
         "type": "DASH",
         "muxStreams": [
           "mux_video",
           "mux_audio"
         ],
         "maxSegmentCount": 5,
         "segmentKeepDuration": "60s"
       }
     ],
     "streamingState": "STOPPED"
   }
   

   C#

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream C#.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   using Google.Cloud.Video.LiveStream.V1;
   
   public class GetChannelSample
   {
       public Channel GetChannel(
            string projectId, string locationId, string channelId)
       {
           // Create the client.
           LivestreamServiceClient client = LivestreamServiceClient.Create();
   
           GetChannelRequest request = new GetChannelRequest
           {
               ChannelName = ChannelName.FromProjectLocationChannel(projectId, locationId, channelId)
           };
   
           // Make the request.
           Channel response = client.GetChannel(request);
           return response;
       }
   }

   Go

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Go.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	livestream "cloud.google.com/go/video/livestream/apiv1"
   	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
   )
   
   // getChannel gets a previously-created channel.
   func getChannel(w io.Writer, projectID, location, channelID string) error {
   	// projectID := "my-project-id"
   	// location := "us-central1"
   	// channelID := "my-channel-id"
   	ctx := context.Background()
   	client, err := livestream.NewClient(ctx)
   	if err != nil {
   		return fmt.Errorf("NewClient: %w", err)
   	}
   	defer client.Close()
   
   	req := &livestreampb.GetChannelRequest{
   		Name: fmt.Sprintf("projects/%s/locations/%s/channels/%s", projectID, location, channelID),
   	}
   
   	response, err := client.GetChannel(ctx, req)
   	if err != nil {
   		return fmt.Errorf("GetChannel: %w", err)
   	}
   
   	fmt.Fprintf(w, "Channel: %v", response.Name)
   	return nil
   }
   

   Java

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Java.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import com.google.cloud.video.livestream.v1.Channel;
   import com.google.cloud.video.livestream.v1.ChannelName;
   import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
   import java.io.IOException;
   
   public class GetChannel {
   
     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 channelId = "my-channel-id";
   
       getChannel(projectId, location, channelId);
     }
   
     public static void getChannel(String projectId, String location, String channelId)
         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. In this example, try-with-resources is used
       // which automatically calls close() on the client to clean up resources.
       try (LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create()) {
         ChannelName name = ChannelName.of(projectId, location, channelId);
         Channel response = livestreamServiceClient.getChannel(name);
         System.out.println("Channel: " + response.getName());
       }
     }
   }

   Node.js

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Node.js.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // projectId = 'my-project-id';
   // location = 'us-central1';
   // channelId = 'my-channel';
   
   // Imports the Livestream library
   const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;
   
   // Instantiates a client
   const livestreamServiceClient = new LivestreamServiceClient();
   
   async function getChannel() {
     // Construct request
     const request = {
       name: livestreamServiceClient.channelPath(projectId, location, channelId),
     };
     const [channel] = await livestreamServiceClient.getChannel(request);
     console.log(`Channel: ${channel.name}`);
   }
   
   getChannel();

   PHP

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream PHP.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
   use Google\Cloud\Video\LiveStream\V1\GetChannelRequest;
   
   /**
    * Gets a channel.
    *
    * @param string  $callingProjectId   The project ID to run the API call under
    * @param string  $location           The location of the channel
    * @param string  $channelId          The ID of the channel
    */
   function get_channel(
       string $callingProjectId,
       string $location,
       string $channelId
   ): void {
       // Instantiate a client.
       $livestreamClient = new LivestreamServiceClient();
       $formattedName = $livestreamClient->channelName($callingProjectId, $location, $channelId);
   
       // Get the channel.
       $request = (new GetChannelRequest())
           ->setName($formattedName);
       $response = $livestreamClient->getChannel($request);
       // Print results
       printf('Channel: %s' . PHP_EOL, $response->getName());
   }

   Python

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Python.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import argparse
   
   from google.cloud.video import live_stream_v1
   from google.cloud.video.live_stream_v1.services.livestream_service import (
       LivestreamServiceClient,
   )
   
   
   def get_channel(
       project_id: str, location: str, channel_id: str
   ) -> live_stream_v1.types.Channel:
       """Gets a channel.
       Args:
           project_id: The GCP project ID.
           location: The location of the channel.
           channel_id: The user-defined channel ID."""
   
       client = LivestreamServiceClient()
   
       name = f"projects/{project_id}/locations/{location}/channels/{channel_id}"
       response = client.get_channel(name=name)
       print(f"Channel: {response.name}")
   
       return response
   
   

   Ruby

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Ruby.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   require "google/cloud/video/live_stream"
   
   ##
   # Get a channel
   #
   # @param project_id [String] Your Google Cloud project (e.g. "my-project")
   # @param location [String] The location (e.g. "us-central1")
   # @param channel_id [String] Your channel name (e.g. "my-channel")
   #
   def get_channel project_id:, location:, channel_id:
     # Create a Live Stream client.
     client = Google::Cloud::Video::LiveStream.livestream_service
   
     # Build the resource name of the channel.
     name = client.channel_path project: project_id, location: location, channel: channel_id
   
     # Get the channel.
     channel = client.get_channel name: name
   
     # Print the channel name.
     puts "Channel: #{channel.name}"
   end

   La respuesta completa contiene el siguiente campo. Algunos de los ejemplos de código anteriores solo devuelven determinados campos en la respuesta, pero se pueden modificar para devolver la respuesta completa.

   {
     ...
     "streamingState": "STOPPED"
     ...
   }
   

   Esta respuesta indica que ya puedes iniciar el canal.

   Nota: De forma predeterminada, los registros de la plataforma del canal de la API están desactivados. Puede que tengas que habilitar estos registros para depurar y solucionar problemas. Consulta más información sobre cómo activar el registro de la plataforma.

   Iniciar el canal

   Usa el método projects.locations.channels.start para iniciar el canal. Un canal debe iniciarse antes de poder aceptar flujos de entrada o generar un flujo de salida.

   Crear el primer canal en una región tarda unos 10 minutos.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación de tu canal. Elige una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • CHANNEL_ID: identificador definido por el usuario del canal

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   curl -X POST \
        -H "Authorization: Bearer $(gcloud auth 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"

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method POST `
       -Headers $headers `
       -Uri "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID:start" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
       "createTime": CREATE_TIME,
       "target": "projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID",
       "verb": "start",
       "requestedCancellation": false,
       "apiVersion": "v1"
     },
     "done": false
   }
   

   C#

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream C#.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   using Google.Cloud.Video.LiveStream.V1;
   using Google.LongRunning;
   using System.Threading.Tasks;
   
   public class StartChannelSample
   {
       public async Task StartChannelAsync(
            string projectId, string locationId, string channelId)
       {
           // Create the client.
           LivestreamServiceClient client = LivestreamServiceClient.Create();
   
           StartChannelRequest request = new StartChannelRequest
           {
               ChannelName = ChannelName.FromProjectLocationChannel(projectId, locationId, channelId)
           };
   
           // Make the request.
           Operation<ChannelOperationResponse, OperationMetadata> response = await client.StartChannelAsync(request);
   
           // Poll until the returned long-running operation is complete.
           await response.PollUntilCompletedAsync();
       }
   }

   Go

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Go.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	livestream "cloud.google.com/go/video/livestream/apiv1"
   	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
   )
   
   // startChannel starts a channel.
   func startChannel(w io.Writer, projectID, location, channelID string) error {
   	// projectID := "my-project-id"
   	// location := "us-central1"
   	// channelID := "my-channel-id"
   	ctx := context.Background()
   	client, err := livestream.NewClient(ctx)
   	if err != nil {
   		return fmt.Errorf("NewClient: %w", err)
   	}
   	defer client.Close()
   
   	req := &livestreampb.StartChannelRequest{
   		Name: fmt.Sprintf("projects/%s/locations/%s/channels/%s", projectID, location, channelID),
   	}
   
   	op, err := client.StartChannel(ctx, req)
   	if err != nil {
   		return fmt.Errorf("StartChannel: %w", err)
   	}
   	_, err = op.Wait(ctx)
   	if err != nil {
   		return fmt.Errorf("Wait: %w", err)
   	}
   
   	fmt.Fprintf(w, "Started channel")
   	return nil
   }
   

   Java

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Java.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import com.google.cloud.video.livestream.v1.ChannelName;
   import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class StartChannel {
   
     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 channelId = "my-channel-id";
   
       startChannel(projectId, location, channelId);
     }
   
     public static void startChannel(String projectId, String location, String channelId)
         throws InterruptedException, ExecutionException, TimeoutException, 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. After completing all of your requests, call
       // the "close" method on the client to safely clean up any remaining background resources.
       LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create();
       ChannelName name = ChannelName.of(projectId, location, channelId);
       // First API call in a project can take up to 15 minutes.
       livestreamServiceClient.startChannelAsync(name).get(15, TimeUnit.MINUTES);
       System.out.println("Started channel");
       livestreamServiceClient.close();
     }
   }

   Node.js

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Node.js.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // projectId = 'my-project-id';
   // location = 'us-central1';
   // channelId = 'my-channel';
   
   // Imports the Livestream library
   const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;
   
   // Instantiates a client
   const livestreamServiceClient = new LivestreamServiceClient();
   
   async function startChannel() {
     // Construct request
     const request = {
       name: livestreamServiceClient.channelPath(projectId, location, channelId),
     };
     const [operation] = await livestreamServiceClient.startChannel(request);
     await operation.promise();
     console.log('Started channel');
   }
   
   startChannel();

   PHP

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream PHP.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
   use Google\Cloud\Video\LiveStream\V1\StartChannelRequest;
   
   /**
    * Starts a channel.
    *
    * @param string  $callingProjectId   The project ID to run the API call under
    * @param string  $location           The location of the channel
    * @param string  $channelId          The ID of the channel
    */
   function start_channel(
       string $callingProjectId,
       string $location,
       string $channelId
   ): void {
       // Instantiate a client.
       $livestreamClient = new LivestreamServiceClient();
       $formattedName = $livestreamClient->channelName($callingProjectId, $location, $channelId);
   
       // Run the channel start request. The response is a long-running operation ID.
       $request = (new StartChannelRequest())
           ->setName($formattedName);
       $operationResponse = $livestreamClient->startChannel($request);
       $operationResponse->pollUntilComplete();
       if ($operationResponse->operationSucceeded()) {
           // Print results
           printf('Started channel' . PHP_EOL);
       } else {
           $error = $operationResponse->getError();
           // handleError($error)
       }
   }

   Python

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Python.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import argparse
   
   from google.cloud.video import live_stream_v1
   from google.cloud.video.live_stream_v1.services.livestream_service import (
       LivestreamServiceClient,
   )
   
   
   def start_channel(
       project_id: str, location: str, channel_id: str
   ) -> live_stream_v1.types.ChannelOperationResponse:
       """Starts a channel.
       Args:
           project_id: The GCP project ID.
           location: The location of the channel.
           channel_id: The user-defined channel ID."""
   
       client = LivestreamServiceClient()
   
       name = f"projects/{project_id}/locations/{location}/channels/{channel_id}"
       operation = client.start_channel(name=name)
       response = operation.result(900)
       print("Started channel")
   
       return response
   
   

   Ruby

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Ruby.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   require "google/cloud/video/live_stream"
   
   ##
   # Starts a channel
   #
   # @param project_id [String] Your Google Cloud project (e.g. "my-project")
   # @param location [String] The location (e.g. "us-central1")
   # @param channel_id [String] Your channel name (e.g. "my-channel")
   #
   def start_channel project_id:, location:, channel_id:
     # Create a Live Stream client.
     client = Google::Cloud::Video::LiveStream.livestream_service
   
     # Build the resource name of the channel.
     name = client.channel_path project: project_id, location: location, channel: channel_id
   
     # Start the channel.
     operation = client.start_channel name: name
   
     # The returned object is of type Gapic::Operation. You can use this
     # object to check the status of an operation, cancel it, or wait
     # for results. Here is how to block until completion:
     operation.wait_until_done!
   
     # Print a success message.
     puts "Started channel"
   end

   Enviar el flujo de entrada

   Para determinar si el canal se ha iniciado, obtén la información del canal como se ha hecho anteriormente. La respuesta debe contener lo siguiente:

   {
     ...
     "streamingState": "AWAITING_INPUT"
     ...
   }
   

   Ahora que el canal está listo, envía una emisión de entrada de prueba al punto final de entrada para generar la emisión en directo.

   Abre una nueva ventana de terminal. Ejecuta el siguiente comando con el INPUT_STREAM_URI de la sección Comprobar el resultado:

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

   Comprueba que el canal está emitiendo

   Para comprobar el estado de la operación de emisión en directo, obtén la información del canal como se ha hecho anteriormente. La respuesta debe incluir lo siguiente:

   {
     ...
     "streamingState": "STREAMING"
     ...
   }
   

   Verificar el contenido del segmento de Cloud Storage

   Abre el segmento de Cloud Storage. Verifica que contenga los siguientes archivos y directorios:

   • main.mpd
   • mux_audio/
     • Varios archivos segment-segment-number.m4s
     • Un solo archivo segment-initialization_segment_0000000000.m4s
   • mux_video/
     • Varios archivos segment-segment-number.m4s
     • Un solo archivo segment-initialization_segment_0000000000.m4s

   Reproducir la emisión en directo generada

   Nota: Si quiere crear una CDN para las salidas multimedia, consulte la guía de inicio rápido de Media CDN.

   Para reproducir el archivo multimedia generado en Shaka Player, sigue estos pasos:

   1. Haz que el segmento de Cloud Storage que has creado se pueda leer públicamente.
   2. Para habilitar el uso compartido de recursos entre dominios (CORS) en un segmento de Cloud Storage, sigue estos pasos:
      1. Crea un archivo JSON que contenga lo siguiente:

         [
           {
             "origin": ["https://shaka-player-demo.appspot.com/"],
             "responseHeader": ["Content-Type", "Range"],
             "method": ["GET", "HEAD"],
             "maxAgeSeconds": 3600
           }
         ]

      2. Ejecuta el siguiente comando después de sustituir JSON_FILE_NAME por el nombre del archivo JSON que has creado en el paso anterior:

         gcloud storage buckets update gs://BUCKET_NAME --cors-file=JSON_FILE_NAME.json

   3. En el segmento de Cloud Storage, busca el archivo generado.main.mpd En la columna Acceso público del archivo, haz clic en Copiar URL.
   4. Ve a Shaka Player, un reproductor de emisiones en directo online.
   5. En la barra de navegación superior, haga clic en Contenido personalizado.
   6. Haz clic en el botón +.

   7. Pega la URL pública del archivo en el cuadro URL del manifiesto.

      

   8. Escribe un nombre en el cuadro Nombre.

   9. Haz clic en Guardar.

   10. Haz clic en Reproducir.

   Deberías ver una carta de ajuste como emisión en directo.

   

   Añadir un marcador de pausa publicitaria a la emisión en directo

   Usa el método projects.locations.channels.events.create para añadir un marcador de pausa publicitaria a la emisión en directo.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación de tu canal. Elige una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • CHANNEL_ID: identificador definido por el usuario del canal
   • EVENT_ID: identificador definido por el usuario del evento

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual:

   cat > request.json << 'EOF'
   {
     "adBreak": {
       "duration": "100s"
     },
     "executeNow": true
   }
   EOF

   A continuación, ejecuta el siguiente comando para enviar tu solicitud REST:

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

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual:

   @'
   {
     "adBreak": {
       "duration": "100s"
     },
     "executeNow": true
   }
   '@  | Out-File -FilePath request.json -Encoding utf8

   A continuación, ejecuta el siguiente comando para enviar tu solicitud 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://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID/events?eventId=EVENT_ID" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID/events/EVENT_ID",
     "createTime": CREATE_TIME,
     "updateTime": UPDATE_TIME,
     "adBreak": {
       "duration": "100s"
     },
     "executeNow": true,
     "state": "PENDING"
   }
   

   C#

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream C#.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   using Google.Cloud.Video.LiveStream.V1;
   
   public class CreateChannelEventSample
   {
       public Event CreateChannelEvent(
            string projectId, string locationId, string channelId, string eventId)
       {
           // Create the client.
           LivestreamServiceClient client = LivestreamServiceClient.Create();
   
           CreateEventRequest request = new CreateEventRequest
           {
               ParentAsChannelName = ChannelName.FromProjectLocationChannel(projectId, locationId, channelId),
               EventId = eventId,
               Event = new Event
               {
                   AdBreak = new Event.Types.AdBreakTask
                   {
                       Duration = new Google.Protobuf.WellKnownTypes.Duration
                       {
                           Seconds = 30
                       }
                   },
                   ExecuteNow = true
               }
           };
   
           // Make the request.
           Event response = client.CreateEvent(request);
           return response;
       }
   }

   Go

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Go.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	"github.com/golang/protobuf/ptypes/duration"
   
   	livestream "cloud.google.com/go/video/livestream/apiv1"
   	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
   )
   
   // createChannelEvent creates a channel event. An event is a sub-resource of a
   // channel, which can be scheduled by the user to execute operations on a
   // channel resource without having to stop the channel. This sample creates an
   // ad break event.
   func createChannelEvent(w io.Writer, projectID, location, channelID, eventID string) error {
   	// projectID := "my-project-id"
   	// location := "us-central1"
   	// channelID := "my-channel"
   	// eventID := "my-channel-event"
   	ctx := context.Background()
   	client, err := livestream.NewClient(ctx)
   	if err != nil {
   		return fmt.Errorf("NewClient: %w", err)
   	}
   	defer client.Close()
   
   	req := &livestreampb.CreateEventRequest{
   		Parent:  fmt.Sprintf("projects/%s/locations/%s/channels/%s", projectID, location, channelID),
   		EventId: eventID,
   		Event: &livestreampb.Event{
   			Task: &livestreampb.Event_AdBreak{
   				AdBreak: &livestreampb.Event_AdBreakTask{
   					Duration: &duration.Duration{
   						Seconds: 30,
   					},
   				},
   			},
   			ExecuteNow: true,
   		},
   	}
   	// Creates the channel event.
   	response, err := client.CreateEvent(ctx, req)
   	if err != nil {
   		return fmt.Errorf("CreateEvent: %w", err)
   	}
   
   	fmt.Fprintf(w, "Channel event: %v", response.Name)
   	return nil
   }
   

   Java

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Java.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import com.google.cloud.video.livestream.v1.ChannelName;
   import com.google.cloud.video.livestream.v1.CreateEventRequest;
   import com.google.cloud.video.livestream.v1.Event;
   import com.google.cloud.video.livestream.v1.Event.AdBreakTask;
   import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
   import com.google.protobuf.Duration;
   import java.io.IOException;
   
   public class CreateChannelEvent {
   
     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 channelId = "my-channel-id";
       String eventId = "my-channel-event-id";
   
       createChannelEvent(projectId, location, channelId, eventId);
     }
   
     public static void createChannelEvent(
         String projectId, String location, String channelId, String eventId) 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. In this example, try-with-resources is used
       // which automatically calls close() on the client to clean up resources.
       try (LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create()) {
         var createEventRequest =
             CreateEventRequest.newBuilder()
                 .setParent(ChannelName.of(projectId, location, channelId).toString())
                 .setEventId(eventId)
                 .setEvent(
                     Event.newBuilder()
                         .setAdBreak(
                             AdBreakTask.newBuilder()
                                 .setDuration(Duration.newBuilder().setSeconds(30).build())
                                 .build())
                         .setExecuteNow(true)
                         .build())
                 .build();
   
         Event response = livestreamServiceClient.createEvent(createEventRequest);
         System.out.println("Channel event: " + response.getName());
       }
     }
   }

   Node.js

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Node.js.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // projectId = 'my-project-id';
   // location = 'us-central1';
   // channelId = 'my-channel';
   // eventId = 'my-channel-event';
   
   // Imports the Livestream library
   const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;
   
   // Instantiates a client
   const livestreamServiceClient = new LivestreamServiceClient();
   
   async function createChannelEvent() {
     // Construct request
     const request = {
       parent: livestreamServiceClient.channelPath(
         projectId,
         location,
         channelId
       ),
       eventId: eventId,
       event: {
         adBreak: {
           duration: {
             seconds: 30,
           },
         },
         executeNow: true,
       },
     };
   
     // Run request
     const [event] = await livestreamServiceClient.createEvent(request);
     console.log(`Channel event: ${event.name}`);
   }
   
   createChannelEvent();

   PHP

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream PHP.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   use Google\Cloud\Video\LiveStream\V1\Event;
   use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
   use Google\Cloud\Video\LiveStream\V1\CreateEventRequest;
   use Google\Protobuf\Duration;
   
   /**
    * Creates a channel event. This particular sample inserts an ad break marker.
    * Other event types are supported.
    *
    * @param string  $callingProjectId   The project ID to run the API call under
    * @param string  $location           The location of the channel
    * @param string  $channelId          The ID of the channel
    * @param string  $eventId            The ID of the channel event
    */
   function create_channel_event(
       string $callingProjectId,
       string $location,
       string $channelId,
       string $eventId
   ): void {
       // Instantiate a client.
       $livestreamClient = new LivestreamServiceClient();
   
       $parent = $livestreamClient->channelName($callingProjectId, $location, $channelId);
   
       $eventAdBreak = (new Event\AdBreakTask())
           ->setDuration(new Duration(['seconds' => 30]));
       $event = (new Event())
           ->setAdBreak($eventAdBreak)
           ->setExecuteNow(true);
   
       // Run the channel event creation request.
       $request = (new CreateEventRequest())
           ->setParent($parent)
           ->setEvent($event)
           ->setEventId($eventId);
       $response = $livestreamClient->createEvent($request);
       // Print results.
       printf('Channel event: %s' . PHP_EOL, $response->getName());
   }

   Python

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Python.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import argparse
   
   from google.cloud.video import live_stream_v1
   from google.cloud.video.live_stream_v1.services.livestream_service import (
       LivestreamServiceClient,
   )
   from google.protobuf import duration_pb2 as duration
   
   
   def create_channel_event(
       project_id: str, location: str, channel_id: str, event_id: str
   ) -> live_stream_v1.types.Event:
       """Creates a channel event.
       Args:
           project_id: The GCP project ID.
           location: The location of the channel.
           channel_id: The user-defined channel ID.
           event_id: The user-defined event ID."""
   
       client = LivestreamServiceClient()
       parent = f"projects/{project_id}/locations/{location}/channels/{channel_id}"
       name = f"projects/{project_id}/locations/{location}/channels/{channel_id}/events/{event_id}"
   
       event = live_stream_v1.types.Event(
           name=name,
           ad_break=live_stream_v1.types.Event.AdBreakTask(
               duration=duration.Duration(
                   seconds=30,
               ),
           ),
           execute_now=True,
       )
   
       response = client.create_event(parent=parent, event=event, event_id=event_id)
       print(f"Channel event: {response.name}")
   
       return response
   
   

   Ruby

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Ruby.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   require "google/cloud/video/live_stream"
   
   ##
   # Create a channel event
   #
   # @param project_id [String] Your Google Cloud project (e.g. "my-project")
   # @param location [String] The location (e.g. "us-central1")
   # @param channel_id [String] Your channel name (e.g. "my-channel")
   # @param event_id [String] Your event name (e.g. "my-event")
   #
   def create_channel_event project_id:, location:, channel_id:, event_id:
     # Create a Live Stream client.
     client = Google::Cloud::Video::LiveStream.livestream_service
   
     # Build the resource name of the parent.
     parent = client.channel_path project: project_id, location: location, channel: channel_id
   
     # Set the event fields.
     new_event = {
       ad_break: {
         duration: {
           seconds: 100
         }
       },
       execute_now: true
     }
   
     response = client.create_event parent: parent, event: new_event, event_id: event_id
   
     # Print the channel event name.
     puts "Channel event: #{response.name}"
   end

   Verificar que existe el marcador de pausa publicitaria

   Cuando se inserta el marcador de anuncio en la emisión en directo, aparece un evento etiquetado como <SpliceInfoSection> en el manifiesto DASH con la duración del anuncio especificada (100 s).

   Ejecuta el siguiente comando para ver el contenido del manifiesto DASH generado:

   gcloud storage cat gs://BUCKET_NAME/main.mpd

   Es posible que tengas que ejecutar el comando gcloud storage cat varias veces hasta que aparezca la sección <SpliceInfoSection>:

   <EventStream timescale="10000000" schemeIdUri="urn:scte:scte35:2013:xml">
     <Event duration="100000000" id="809">
       <SpliceInfoSection xmlns="urn:scte:scte35:2013:xml">
         <SpliceInsert outOfNetworkIndicator="true" spliceImmediateFlag="true">
           <BreakDuration autoReturn="true" duration="100000000"/>
         </SpliceInsert>
       </SpliceInfoSection>
     </Event>
   </EventStream>
   

   Limpieza

   Para evitar que se apliquen cargos en tu Google Cloud cuenta por los recursos utilizados en esta página, elimina el Google Cloud proyecto con los recursos.

   Detener el canal

   Usa el método projects.locations.channels.stop para detener el canal. Debes detener el canal para poder eliminarlo.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación de tu canal. Elige una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • CHANNEL_ID: identificador definido por el usuario del canal

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   curl -X POST \
        -H "Authorization: Bearer $(gcloud auth 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"

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method POST `
       -Headers $headers `
       -Uri "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID:stop" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
       "createTime": CREATE_TIME,
       "target": "projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID",
       "verb": "stop",
       "requestedCancellation": false,
       "apiVersion": "v1"
     },
     "done": false
   }
   

   C#

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream C#.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   using Google.Cloud.Video.LiveStream.V1;
   using Google.LongRunning;
   using System.Threading.Tasks;
   
   public class StopChannelSample
   {
       public async Task StopChannelAsync(
            string projectId, string locationId, string channelId)
       {
           // Create the client.
           LivestreamServiceClient client = LivestreamServiceClient.Create();
   
           StopChannelRequest request = new StopChannelRequest
           {
               ChannelName = ChannelName.FromProjectLocationChannel(projectId, locationId, channelId)
           };
   
           // Make the request.
           Operation<ChannelOperationResponse, OperationMetadata> response = await client.StopChannelAsync(request);
   
           // Poll until the returned long-running operation is complete.
           await response.PollUntilCompletedAsync();
       }
   }

   Go

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Go.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	livestream "cloud.google.com/go/video/livestream/apiv1"
   	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
   )
   
   // stopChannel stops a channel.
   func stopChannel(w io.Writer, projectID, location, channelID string) error {
   	// projectID := "my-project-id"
   	// location := "us-central1"
   	// channelID := "my-channel-id"
   	ctx := context.Background()
   	client, err := livestream.NewClient(ctx)
   	if err != nil {
   		return fmt.Errorf("NewClient: %w", err)
   	}
   	defer client.Close()
   
   	req := &livestreampb.StopChannelRequest{
   		Name: fmt.Sprintf("projects/%s/locations/%s/channels/%s", projectID, location, channelID),
   	}
   
   	op, err := client.StopChannel(ctx, req)
   	if err != nil {
   		return fmt.Errorf("StopChannel: %w", err)
   	}
   	_, err = op.Wait(ctx)
   	if err != nil {
   		return fmt.Errorf("Wait: %w", err)
   	}
   
   	fmt.Fprintf(w, "Stopped channel")
   	return nil
   }
   

   Java

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Java.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import com.google.cloud.video.livestream.v1.ChannelName;
   import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class StopChannel {
   
     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 channelId = "my-channel-id";
   
       stopChannel(projectId, location, channelId);
     }
   
     public static void stopChannel(String projectId, String location, String channelId)
         throws InterruptedException, ExecutionException, TimeoutException, 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. After completing all of your requests, call
       // the "close" method on the client to safely clean up any remaining background resources.
       LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create();
       ChannelName name = ChannelName.of(projectId, location, channelId);
       // First API call in a project can take up to 10 minutes.
       livestreamServiceClient.stopChannelAsync(name).get(10, TimeUnit.MINUTES);
       System.out.println("Stopped channel");
       livestreamServiceClient.close();
     }
   }

   Node.js

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Node.js.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // projectId = 'my-project-id';
   // location = 'us-central1';
   // channelId = 'my-channel';
   
   // Imports the Livestream library
   const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;
   
   // Instantiates a client
   const livestreamServiceClient = new LivestreamServiceClient();
   
   async function stopChannel() {
     // Construct request
     const request = {
       name: livestreamServiceClient.channelPath(projectId, location, channelId),
     };
     const [operation] = await livestreamServiceClient.stopChannel(request);
     await operation.promise();
     console.log('Stopped channel');
   }
   
   stopChannel();

   PHP

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream PHP.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
   use Google\Cloud\Video\LiveStream\V1\StopChannelRequest;
   
   /**
    * Stops a channel.
    *
    * @param string  $callingProjectId   The project ID to run the API call under
    * @param string  $location           The location of the channel
    * @param string  $channelId          The ID of the channel
    */
   function stop_channel(
       string $callingProjectId,
       string $location,
       string $channelId
   ): void {
       // Instantiate a client.
       $livestreamClient = new LivestreamServiceClient();
       $formattedName = $livestreamClient->channelName($callingProjectId, $location, $channelId);
   
       // Run the channel stop request. The response is a long-running operation ID.
       $request = (new StopChannelRequest())
           ->setName($formattedName);
       $operationResponse = $livestreamClient->stopChannel($request);
       $operationResponse->pollUntilComplete();
       if ($operationResponse->operationSucceeded()) {
           // Print results
           printf('Stopped channel' . PHP_EOL);
       } else {
           $error = $operationResponse->getError();
           // handleError($error)
       }
   }

   Python

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Python.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import argparse
   
   from google.cloud.video import live_stream_v1
   from google.cloud.video.live_stream_v1.services.livestream_service import (
       LivestreamServiceClient,
   )
   
   
   def stop_channel(
       project_id: str, location: str, channel_id: str
   ) -> live_stream_v1.types.ChannelOperationResponse:
       """Stops a channel.
       Args:
           project_id: The GCP project ID.
           location: The location of the channel.
           channel_id: The user-defined channel ID."""
   
       client = LivestreamServiceClient()
   
       name = f"projects/{project_id}/locations/{location}/channels/{channel_id}"
       operation = client.stop_channel(name=name)
       response = operation.result(600)
       print("Stopped channel")
   
       return response
   
   

   Ruby

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Ruby.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   require "google/cloud/video/live_stream"
   
   ##
   # Stops a channel
   #
   # @param project_id [String] Your Google Cloud project (e.g. "my-project")
   # @param location [String] The location (e.g. "us-central1")
   # @param channel_id [String] Your channel name (e.g. "my-channel")
   #
   def stop_channel project_id:, location:, channel_id:
     # Create a Live Stream client.
     client = Google::Cloud::Video::LiveStream.livestream_service
   
     # Build the resource name of the channel.
     name = client.channel_path project: project_id, location: location, channel: channel_id
   
     # Stop the channel.
     operation = client.stop_channel name: name
   
     # The returned object is of type Gapic::Operation. You can use this
     # object to check the status of an operation, cancel it, or wait
     # for results. Here is how to block until completion:
     operation.wait_until_done!
   
     # Print a success message.
     puts "Stopped channel"
   end

   Usa OPERATION_ID para comprobar el estado de la operación hasta que obtengas "done":true en el resultado.

   Detener el flujo de entrada

   Si has usado ffmpeg para enviar el flujo de entrada, la conexión se romperá automáticamente cuando detengas el canal.

   Si has usado otros codificadores con mecanismos de reintento, puede que tengas que detener manualmente el flujo de entrada.

   Eliminar el evento

   Usa el método projects.locations.channels.events.delete para eliminar el evento de pausa publicitaria. Debes eliminar los eventos del canal para poder eliminarlo.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación de tu canal. Elige una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • CHANNEL_ID: identificador definido por el usuario del canal
   • EVENT_ID: identificador definido por el usuario del evento

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   curl -X DELETE \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID/events/EVENT_ID"

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method DELETE `
       -Headers $headers `
       -Uri "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID/events/EVENT_ID" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {}
   

   C#

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream C#.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   using Google.Cloud.Video.LiveStream.V1;
   
   public class DeleteChannelEventSample
   {
       public void DeleteChannelEvent(
            string projectId, string locationId, string channelId, string eventId)
       {
           // Create the client.
           LivestreamServiceClient client = LivestreamServiceClient.Create();
   
           DeleteEventRequest request = new DeleteEventRequest
           {
               EventName = EventName.FromProjectLocationChannelEvent(projectId, locationId, channelId, eventId),
           };
   
           // Make the request.
           client.DeleteEvent(request);
       }
   }

   Go

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Go.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	livestream "cloud.google.com/go/video/livestream/apiv1"
   	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
   )
   
   // deleteChannelEvent deletes a previously-created channel event.
   func deleteChannelEvent(w io.Writer, projectID, location, channelID, eventID string) error {
   	// projectID := "my-project-id"
   	// location := "us-central1"
   	// channelID := "my-channel"
   	// eventID := "my-channel-event"
   	ctx := context.Background()
   	client, err := livestream.NewClient(ctx)
   	if err != nil {
   		return fmt.Errorf("NewClient: %w", err)
   	}
   	defer client.Close()
   
   	req := &livestreampb.DeleteEventRequest{
   		Name: fmt.Sprintf("projects/%s/locations/%s/channels/%s/events/%s", projectID, location, channelID, eventID),
   	}
   
   	err = client.DeleteEvent(ctx, req)
   	if err != nil {
   		return fmt.Errorf("DeleteEvent: %w", err)
   	}
   
   	fmt.Fprintf(w, "Deleted channel event")
   	return nil
   }
   

   Java

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Java.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import com.google.cloud.video.livestream.v1.DeleteEventRequest;
   import com.google.cloud.video.livestream.v1.EventName;
   import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
   import java.io.IOException;
   
   public class DeleteChannelEvent {
   
     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 channelId = "my-channel-id";
       String eventId = "my-channel-event-id";
   
       deleteChannelEvent(projectId, location, channelId, eventId);
     }
   
     public static void deleteChannelEvent(
         String projectId, String location, String channelId, String eventId) 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. In this example, try-with-resources is used
       // which automatically calls close() on the client to clean up resources.
       try (LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create()) {
         var deleteEventRequest =
             DeleteEventRequest.newBuilder()
                 .setName(EventName.of(projectId, location, channelId, eventId).toString())
                 .build();
   
         livestreamServiceClient.deleteEvent(deleteEventRequest);
         System.out.println("Deleted channel event");
       }
     }
   }

   Node.js

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Node.js.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // projectId = 'my-project-id';
   // location = 'us-central1';
   // channelId = 'my-channel';
   // eventId = 'my-channel-event';
   
   // Imports the Livestream library
   const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;
   
   // Instantiates a client
   const livestreamServiceClient = new LivestreamServiceClient();
   
   async function deleteChannelEvent() {
     // Construct request
     const request = {
       name: livestreamServiceClient.eventPath(
         projectId,
         location,
         channelId,
         eventId
       ),
     };
   
     // Run request
     await livestreamServiceClient.deleteEvent(request);
     console.log('Deleted channel event');
   }
   
   deleteChannelEvent();

   PHP

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream PHP.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
   use Google\Cloud\Video\LiveStream\V1\DeleteEventRequest;
   
   /**
    * Deletes a channel event.
    *
    * @param string  $callingProjectId   The project ID to run the API call under
    * @param string  $location           The location of the channel
    * @param string  $channelId          The ID of the channel
    * @param string  $eventId            The ID of the channel event to be deleted
    */
   function delete_channel_event(
       string $callingProjectId,
       string $location,
       string $channelId,
       string $eventId
   ): void {
       // Instantiate a client.
       $livestreamClient = new LivestreamServiceClient();
       $formattedName = $livestreamClient->eventName($callingProjectId, $location, $channelId, $eventId);
   
       // Run the channel event deletion request.
       $request = (new DeleteEventRequest())
           ->setName($formattedName);
       $livestreamClient->deleteEvent($request);
       printf('Deleted channel event %s' . PHP_EOL, $eventId);
   }

   Python

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Python.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import argparse
   
   from google.cloud.video.live_stream_v1.services.livestream_service import (
       LivestreamServiceClient,
   )
   
   
   def delete_channel_event(
       project_id: str, location: str, channel_id: str, event_id: str
   ) -> None:
       """Deletes a channel event.
       Args:
           project_id: The GCP project ID.
           location: The location of the channel.
           channel_id: The user-defined channel ID.
           event_id: The user-defined event ID."""
   
       client = LivestreamServiceClient()
   
       name = f"projects/{project_id}/locations/{location}/channels/{channel_id}/events/{event_id}"
       response = client.delete_event(name=name)
       print("Deleted channel event")
   
       return response
   
   

   Ruby

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Ruby.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   require "google/cloud/video/live_stream"
   
   ##
   # Delete a channel event
   #
   # @param project_id [String] Your Google Cloud project (e.g. "my-project")
   # @param location [String] The location (e.g. "us-central1")
   # @param channel_id [String] Your channel name (e.g. "my-channel")
   # @param event_id [String] Your event name (e.g. "my-event")
   #
   def delete_channel_event project_id:, location:, channel_id:, event_id:
     # Create a Live Stream client.
     client = Google::Cloud::Video::LiveStream.livestream_service
   
     # Build the resource name of the channel event.
     name = client.event_path project: project_id, location: location, channel: channel_id, event: event_id
   
     # Delete the channel event.
     client.delete_event name: name
   
     # Print a success message.
     puts "Deleted channel event"
   end

   Eliminar el canal

   Usa el método projects.locations.channels.delete para eliminar el canal. Debes eliminar el canal antes de poder eliminar el endpoint de entrada que usa el canal.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación de tu canal. Elige una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • CHANNEL_ID: identificador definido por el usuario del canal

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   curl -X DELETE \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID"

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method DELETE `
       -Headers $headers `
       -Uri "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
       "createTime": CREATE_TIME,
       "target": "projects/PROJECT_NUMBER/locations/LOCATION/channels/CHANNEL_ID",
       "verb": "delete",
       "requestedCancellation": false,
       "apiVersion": "v1"
     },
     "done": false
   }
   

   C#

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream C#.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   using Google.Cloud.Video.LiveStream.V1;
   using Google.LongRunning;
   using Google.Protobuf.WellKnownTypes;
   using System.Threading.Tasks;
   
   public class DeleteChannelSample
   {
       public async Task DeleteChannelAsync(
            string projectId, string locationId, string channelId)
       {
           // Create the client.
           LivestreamServiceClient client = LivestreamServiceClient.Create();
   
           DeleteChannelRequest request = new DeleteChannelRequest
           {
               ChannelName = ChannelName.FromProjectLocationChannel(projectId, locationId, channelId)
           };
   
           // Make the request.
           Operation<Empty, OperationMetadata> response = await client.DeleteChannelAsync(request);
   
           // Poll until the returned long-running operation is complete.
           await response.PollUntilCompletedAsync();
       }
   }

   Go

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Go.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	livestream "cloud.google.com/go/video/livestream/apiv1"
   	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
   )
   
   // deleteChannel deletes a previously-created channel.
   func deleteChannel(w io.Writer, projectID, location, channelID string) error {
   	// projectID := "my-project-id"
   	// location := "us-central1"
   	// channelID := "my-channel"
   	ctx := context.Background()
   	client, err := livestream.NewClient(ctx)
   	if err != nil {
   		return fmt.Errorf("NewClient: %w", err)
   	}
   	defer client.Close()
   
   	req := &livestreampb.DeleteChannelRequest{
   		Name: fmt.Sprintf("projects/%s/locations/%s/channels/%s", projectID, location, channelID),
   	}
   
   	op, err := client.DeleteChannel(ctx, req)
   	if err != nil {
   		return fmt.Errorf("DeleteChannel: %w", err)
   	}
   	err = op.Wait(ctx)
   	if err != nil {
   		return fmt.Errorf("Wait: %w", err)
   	}
   
   	fmt.Fprintf(w, "Deleted channel")
   	return nil
   }
   

   Java

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Java.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import com.google.cloud.video.livestream.v1.ChannelName;
   import com.google.cloud.video.livestream.v1.DeleteChannelRequest;
   import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class DeleteChannel {
   
     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 channelId = "my-channel-id";
   
       deleteChannel(projectId, location, channelId);
     }
   
     public static void deleteChannel(String projectId, String location, String channelId)
         throws InterruptedException, ExecutionException, TimeoutException, 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. After completing all of your requests, call
       // the "close" method on the client to safely clean up any remaining background resources.
       LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create();
       var deleteChannelRequest =
           DeleteChannelRequest.newBuilder()
               .setName(ChannelName.of(projectId, location, channelId).toString())
               .build();
       // First API call in a project can take up to 10 minutes.
       livestreamServiceClient.deleteChannelAsync(deleteChannelRequest).get(10, TimeUnit.MINUTES);
       System.out.println("Deleted channel");
       livestreamServiceClient.close();
     }
   }

   Node.js

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Node.js.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // projectId = 'my-project-id';
   // location = 'us-central1';
   // channelId = 'my-channel';
   
   // Imports the Livestream library
   const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;
   
   // Instantiates a client
   const livestreamServiceClient = new LivestreamServiceClient();
   
   async function deleteChannel() {
     // Construct request
     const request = {
       name: livestreamServiceClient.channelPath(projectId, location, channelId),
     };
   
     // Run request
     const [operation] = await livestreamServiceClient.deleteChannel(request);
     await operation.promise();
     console.log('Deleted channel');
   }
   
   deleteChannel();

   PHP

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream PHP.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
   use Google\Cloud\Video\LiveStream\V1\DeleteChannelRequest;
   
   /**
    * Deletes a channel.
    *
    * @param string  $callingProjectId   The project ID to run the API call under
    * @param string  $location           The location of the channel
    * @param string  $channelId          The ID of the channel to be deleted
    */
   function delete_channel(
       string $callingProjectId,
       string $location,
       string $channelId
   ): void {
       // Instantiate a client.
       $livestreamClient = new LivestreamServiceClient();
       $formattedName = $livestreamClient->channelName($callingProjectId, $location, $channelId);
   
       // Run the channel deletion request. The response is a long-running operation ID.
       $request = (new DeleteChannelRequest())
           ->setName($formattedName);
       $operationResponse = $livestreamClient->deleteChannel($request);
       $operationResponse->pollUntilComplete();
       if ($operationResponse->operationSucceeded()) {
           // Print status
           printf('Deleted channel %s' . PHP_EOL, $channelId);
       } else {
           $error = $operationResponse->getError();
           // handleError($error)
       }
   }

   Python

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Python.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import argparse
   
   from google.cloud.video.live_stream_v1.services.livestream_service import (
       LivestreamServiceClient,
   )
   from google.protobuf import empty_pb2 as empty
   
   
   def delete_channel(project_id: str, location: str, channel_id: str) -> empty.Empty:
       """Deletes a channel.
       Args:
           project_id: The GCP project ID.
           location: The location of the channel.
           channel_id: The user-defined channel ID."""
   
       client = LivestreamServiceClient()
   
       name = f"projects/{project_id}/locations/{location}/channels/{channel_id}"
       operation = client.delete_channel(name=name)
       response = operation.result(600)
       print("Deleted channel")
   
       return response
   
   

   Ruby

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Ruby.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   require "google/cloud/video/live_stream"
   
   ##
   # Delete a channel
   #
   # @param project_id [String] Your Google Cloud project (e.g. "my-project")
   # @param location [String] The location (e.g. "us-central1")
   # @param channel_id [String] Your channel name (e.g. "my-channel")
   #
   def delete_channel project_id:, location:, channel_id:
     # Create a Live Stream client.
     client = Google::Cloud::Video::LiveStream.livestream_service
   
     # Build the resource name of the channel.
     name = client.channel_path project: project_id, location: location, channel: channel_id
   
     # Delete the channel.
     operation = client.delete_channel name: name
   
     # The returned object is of type Gapic::Operation. You can use this
     # object to check the status of an operation, cancel it, or wait
     # for results. Here is how to block until completion:
     operation.wait_until_done!
   
     # Print a success message.
     puts "Deleted channel"
   end

   Usa OPERATION_ID para comprobar el estado de la operación hasta que obtengas "done":true en el resultado.

   Eliminar el endpoint de entrada

   Usa el método projects.locations.inputs.delete para eliminar el endpoint de entrada.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • PROJECT_NUMBER: número de tu proyecto. Google Cloud Se encuentra en el campo Número de proyecto de la página Configuración de gestión de identidades y accesos.
   • LOCATION: la ubicación de tu endpoint de entrada. Usa una de las regiones admitidas.
     Mostrar ubicaciones
     • us-central1
     • us-east1
     • us-east4
     • us-west1
     • us-west2
     • northamerica-northeast1
     • southamerica-east1
     • asia-east1
     • asia-east2
     • asia-south1
     • asia-northeast1
     • asia-southeast1
     • australia-southeast1
     • europe-north1
     • europe-west1
     • europe-west2
     • europe-west3
     • europe-west4
   • INPUT_ID: identificador definido por el usuario del endpoint de entrada

   Para enviar tu solicitud, despliega una de estas opciones:

   curl (Linux, macOS o Cloud Shell)

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   curl -X DELETE \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID"

   PowerShell (Windows)

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

   Ejecuta el comando siguiente:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method DELETE `
       -Headers $headers `
       -Uri "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID" | Select-Object -Expand Content

   Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.video.livestream.v1.OperationMetadata",
       "createTime": CREATE_TIME,
       "target": "projects/PROJECT_NUMBER/locations/LOCATION/inputs/INPUT_ID",
       "verb": "delete",
       "requestedCancellation": false,
       "apiVersion": "v1"
     },
     "done": false
   }
   

   C#

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream C#.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   using Google.Cloud.Video.LiveStream.V1;
   using Google.LongRunning;
   using Google.Protobuf.WellKnownTypes;
   using System.Threading.Tasks;
   
   public class DeleteInputSample
   {
       public async Task DeleteInputAsync(
            string projectId, string locationId, string inputId)
       {
           // Create the client.
           LivestreamServiceClient client = LivestreamServiceClient.Create();
   
           DeleteInputRequest request = new DeleteInputRequest
           {
               InputName = InputName.FromProjectLocationInput(projectId, locationId, inputId)
           };
   
           // Make the request.
           Operation<Empty, OperationMetadata> response = await client.DeleteInputAsync(request);
   
           // Poll until the returned long-running operation is complete.
           await response.PollUntilCompletedAsync();
       }
   }

   Go

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Go.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	livestream "cloud.google.com/go/video/livestream/apiv1"
   	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
   )
   
   // deleteInput deletes a previously-created input endpoint.
   func deleteInput(w io.Writer, projectID, location, inputID string) error {
   	// projectID := "my-project-id"
   	// location := "us-central1"
   	// inputID := "my-input"
   	ctx := context.Background()
   	client, err := livestream.NewClient(ctx)
   	if err != nil {
   		return fmt.Errorf("NewClient: %w", err)
   	}
   	defer client.Close()
   
   	req := &livestreampb.DeleteInputRequest{
   		Name: fmt.Sprintf("projects/%s/locations/%s/inputs/%s", projectID, location, inputID),
   	}
   
   	op, err := client.DeleteInput(ctx, req)
   	if err != nil {
   		return fmt.Errorf("DeleteInput: %w", err)
   	}
   	err = op.Wait(ctx)
   	if err != nil {
   		return fmt.Errorf("Wait: %w", err)
   	}
   
   	fmt.Fprintf(w, "Deleted input")
   	return nil
   }
   

   Java

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Java.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import com.google.cloud.video.livestream.v1.DeleteInputRequest;
   import com.google.cloud.video.livestream.v1.InputName;
   import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class DeleteInput {
   
     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 inputId = "my-input-id";
   
       deleteInput(projectId, location, inputId);
     }
   
     public static void deleteInput(String projectId, String location, String inputId)
         throws InterruptedException, ExecutionException, TimeoutException, 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. After completing all of your requests, call
       // the "close" method on the client to safely clean up any remaining background resources.
       LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create();
       var deleteInputRequest =
           DeleteInputRequest.newBuilder()
               .setName(InputName.of(projectId, location, inputId).toString())
               .build();
       // First API call in a project can take up to 10 minutes.
       livestreamServiceClient.deleteInputAsync(deleteInputRequest).get(10, TimeUnit.MINUTES);
       System.out.println("Deleted input");
       livestreamServiceClient.close();
     }
   }

   Node.js

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Node.js.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // projectId = 'my-project-id';
   // location = 'us-central1';
   // inputId = 'my-input';
   
   // Imports the Livestream library
   const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;
   
   // Instantiates a client
   const livestreamServiceClient = new LivestreamServiceClient();
   
   async function deleteInput() {
     // Construct request
     const request = {
       name: livestreamServiceClient.inputPath(projectId, location, inputId),
     };
   
     // Run request
     const [operation] = await livestreamServiceClient.deleteInput(request);
     await operation.promise();
     console.log('Deleted input');
   }
   
   deleteInput();

   PHP

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream PHP.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
   use Google\Cloud\Video\LiveStream\V1\DeleteInputRequest;
   
   /**
    * Deletes an input.
    *
    * @param string  $callingProjectId   The project ID to run the API call under
    * @param string  $location           The location of the input
    * @param string  $inputId            The ID of the input to be deleted
    */
   function delete_input(
       string $callingProjectId,
       string $location,
       string $inputId
   ): void {
       // Instantiate a client.
       $livestreamClient = new LivestreamServiceClient();
       $formattedName = $livestreamClient->inputName($callingProjectId, $location, $inputId);
   
       // Run the input deletion request. The response is a long-running operation ID.
       $request = (new DeleteInputRequest())
           ->setName($formattedName);
       $operationResponse = $livestreamClient->deleteInput($request);
       $operationResponse->pollUntilComplete();
       if ($operationResponse->operationSucceeded()) {
           // Print status
           printf('Deleted input %s' . PHP_EOL, $inputId);
       } else {
           $error = $operationResponse->getError();
           // handleError($error)
       }
   }

   Python

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Python.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   import argparse
   
   from google.cloud.video.live_stream_v1.services.livestream_service import (
       LivestreamServiceClient,
   )
   from google.protobuf import empty_pb2 as empty
   
   
   def delete_input(project_id: str, location: str, input_id: str) -> empty.Empty:
       """Deletes an input.
       Args:
           project_id: The GCP project ID.
           location: The location of the input.
           input_id: The user-defined input ID."""
   
       client = LivestreamServiceClient()
   
       name = f"projects/{project_id}/locations/{location}/inputs/{input_id}"
       operation = client.delete_input(name=name)
       response = operation.result(600)
       print("Deleted input")
   
       return response
   
   

   Ruby

   Para saber cómo instalar y usar la biblioteca de cliente de la API Live Stream, consulta Bibliotecas de cliente de la API Live Stream. Para obtener más información, consulta la documentación de referencia de la API Live Stream Ruby.

   Para autenticarte en la API Live Stream, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   require "google/cloud/video/live_stream"
   
   ##
   # Delete an input endpoint
   #
   # @param project_id [String] Your Google Cloud project (e.g. "my-project")
   # @param location [String] The location (e.g. "us-central1")
   # @param input_id [String] Your input name (e.g. "my-input")
   #
   def delete_input project_id:, location:, input_id:
     # Create a Live Stream client.
     client = Google::Cloud::Video::LiveStream.livestream_service
   
     # Build the resource name of the input.
     name = client.input_path project: project_id, location: location, input: input_id
   
     # Delete the input.
     operation = client.delete_input name: name
   
     # The returned object is of type Gapic::Operation. You can use this
     # object to check the status of an operation, cancel it, or wait
     # for results. Here is how to block until completion:
     operation.wait_until_done!
   
     # Print a success message.
     puts "Deleted input"
   end

   Eliminar el segmento de Cloud Storage

   Ten en cuenta que todos los archivos y carpetas del contenedor generado por la API Live Stream se eliminan cuando detienes el canal.

   1. En la Google Cloud consola, ve a la página Navegador de Cloud Storage.

      Ir a la página Navegador de Cloud Storage

   2. Selecciona la casilla situada junto al segmento que has creado.

   3. Haz clic en Eliminar.

   4. En la ventana emergente que aparece, haga clic en Eliminar para eliminar de forma permanente el contenedor y su contenido.

   Revocar tus credenciales

   1. Optional: Revoke the authentication credentials that you created, and delete the local credential file.

      gcloud auth application-default revoke

   2. Optional: Revoke credentials from the gcloud CLI.

      gcloud auth revoke

   Siguientes pasos

   • Consulta las instrucciones de la guía de inicio rápido para emitir en directo con HLS.
   • Consulte cómo configurar un flujo de entrada de copia de seguridad.