Criar e gerenciar pools

Nesta página, mostramos como criar e gerenciar pools da API Live Stream. Um pool é uma unidade de processamento alocada para cada projeto do Google Cloud por região e é compartilhado entre todos os canais em uma determinada região. Os pools são usados para proteger endpoints de entrada em um perímetro do VPC Service Controls. Para mais informações, consulte Usar o VPC Service Controls para proteger seu pipeline.

Configurar o projeto Google Cloud e a autenticação

Se você ainda não criou um projetoGoogle Cloud e credenciais, consulte Antes de começar.

Criar um pool

Quando você cria um endpoint de entrada em um local pela primeira vez, o pool padrão desse local é criado automaticamente.

Conferir detalhes do pool

Para receber os detalhes do pool, use o método projects.locations.pools.get.

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_NUMBER: o número do seu projeto Google Cloud , que está localizado no campo Número do projeto na página Configurações do IAM
  • LOCATION: use uma das regiões compatíveis em que você já criou uma entrada
    Mostrar locais
    • 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

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/pools/default",
  "createTime": CREATE_TIME,
  "updateTime": UPDATE_TIME
}

C#

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em C#.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


using Google.Cloud.Video.LiveStream.V1;

public class GetPoolSample
{
    public Pool GetPool(
         string projectId, string locationId, string poolId)
    {
        // Create the client.
        LivestreamServiceClient client = LivestreamServiceClient.Create();

        GetPoolRequest request = new GetPoolRequest
        {
            PoolName = PoolName.FromProjectLocationPool(projectId, locationId, poolId)
        };

        // Make the request.
        Pool response = client.GetPool(request);
        return response;
    }
}

Go

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Go.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

import (
	"context"
	"fmt"
	"io"

	livestream "cloud.google.com/go/video/livestream/apiv1"
	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
)

// getPool gets a pool.
func getPool(w io.Writer, projectID, location, poolID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// poolID := "default"
	ctx := context.Background()
	client, err := livestream.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	req := &livestreampb.GetPoolRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/pools/%s", projectID, location, poolID),
	}

	response, err := client.GetPool(ctx, req)
	if err != nil {
		return fmt.Errorf("GetPool: %w", err)
	}

	fmt.Fprintf(w, "Pool: %v", response.Name)
	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Java.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
import com.google.cloud.video.livestream.v1.Pool;
import com.google.cloud.video.livestream.v1.PoolName;
import java.io.IOException;

public class GetPool {

  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 poolId = "default"; // only 1 pool supported per location

    getPool(projectId, location, poolId);
  }

  public static void getPool(String projectId, String location, String poolId)
      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()) {
      PoolName name = PoolName.of(projectId, location, poolId);
      Pool response = livestreamServiceClient.getPool(name);
      System.out.println("Pool: " + response.getName());
    }
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Node.js.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

// Imports the Livestream library
const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;

// Instantiates a client
const livestreamServiceClient = new LivestreamServiceClient();

async function getPool() {
  // Construct request
  const request = {
    name: livestreamServiceClient.poolPath(projectId, location, poolId),
  };
  const [pool] = await livestreamServiceClient.getPool(request);
  console.log(`Pool: ${pool.name}`);
}

getPool();

PHP

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em PHP.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
use Google\Cloud\Video\LiveStream\V1\GetPoolRequest;

/**
 * Gets a pool.
 *
 * @param string  $callingProjectId   The project ID to run the API call under
 * @param string  $location           The location of the pool
 * @param string  $poolId             The ID of the pool
 */
function get_pool(
    string $callingProjectId,
    string $location,
    string $poolId
): void {
    // Instantiate a client.
    $livestreamClient = new LivestreamServiceClient();
    $formattedName = $livestreamClient->poolName($callingProjectId, $location, $poolId);

    // Get the pool.
    $request = (new GetPoolRequest())
        ->setName($formattedName);
    $response = $livestreamClient->getPool($request);
    // Print results
    printf('Pool: %s' . PHP_EOL, $response->getName());
}

Python

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Python.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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_pool(project_id: str, location: str, pool_id: str) -> live_stream_v1.types.Pool:
    """Gets a pool.
    Args:
        project_id: The GCP project ID.
        location: The location of the pool.
        pool_id: The user-defined pool ID."""

    client = LivestreamServiceClient()

    name = f"projects/{project_id}/locations/{location}/pools/{pool_id}"
    response = client.get_pool(name=name)
    print(f"Pool: {response.name}")

    return response

Ruby

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Ruby.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

require "google/cloud/video/live_stream"

##
# Get the pool
#
# @param project_id [String] Your Google Cloud project (e.g. "my-project")
# @param location [String] The location (e.g. "us-central1")
# @param pool_id [String] Your pool name (e.g. "default")
#
def get_pool project_id:, location:, pool_id:
  # Create a Live Stream client.
  client = Google::Cloud::Video::LiveStream.livestream_service

  # Build the resource name of the pool.
  name = client.pool_path project: project_id, location: location, pool: pool_id

  # Get the pool.
  pool = client.get_pool name: name

  # Print the pool name.
  puts "Pool: #{pool.name}"
end

Atualizar um pool

Para atualizar um endpoint de entrada, use o método projects.locations.pools.patch.

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_NUMBER: o número do seu projeto Google Cloud , que está localizado no campo Número do projeto na página Configurações do IAM
  • LOCATION: o local do pool padrão. Use uma das regiões compatíveis
    Mostrar locais
    • 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
  • NETWORK: o identificador definido pelo usuário para a rede no projeto atual para fazer peering com o serviço

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "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/pools/default",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}
Esse comando cria uma operação de longa duração (LRO) que pode ser usada para acompanhar o progresso da sua solicitação. Consulte Gerenciar operações de longa duração para mais informações.

C#

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em C#.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


using Google.Cloud.Video.LiveStream.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;
using System.Threading.Tasks;

public class UpdatePoolSample
{
    public async Task UpdatePoolAsync(
         string projectId, string locationId, string poolId, string peeredNetwork)
    {
        // Create the client.
        LivestreamServiceClient client = LivestreamServiceClient.Create();

        UpdatePoolRequest request = new UpdatePoolRequest
        {
            Pool = new Pool
            {
                PoolName = PoolName.FromProjectLocationPool(projectId, locationId, poolId),
                NetworkConfig = new Pool.Types.NetworkConfig
                {
                    PeeredNetwork = peeredNetwork
                }
            },
            UpdateMask = new FieldMask { Paths = { "network_config" } }
        };

        // Make the request.
        Operation<Pool, OperationMetadata> response = await client.UpdatePoolAsync(request);
        // Get the name of the operation.
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name.
        Operation<Pool, OperationMetadata> retrievedResponse = await client.PollOnceUpdatePoolAsync(operationName);
        // Check if the retrieved long-running operation has completed.
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result.
            _ = retrievedResponse.Result;
        }
    }
}

Go

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Go.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

import (
	"context"
	"fmt"
	"io"

	livestream "cloud.google.com/go/video/livestream/apiv1"
	"cloud.google.com/go/video/livestream/apiv1/livestreampb"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

// updatePool updates the pool's peered network.
func updatePool(w io.Writer, projectID, location, poolID, peeredNetwork string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// poolID := "default"
	// peeredNetwork :=  "projects/my-network-project-number/global/networks/my-network-name"
	ctx := context.Background()
	client, err := livestream.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	req := &livestreampb.UpdatePoolRequest{
		Pool: &livestreampb.Pool{
			Name: fmt.Sprintf("projects/%s/locations/%s/pools/%s", projectID, location, poolID),
			NetworkConfig: &livestreampb.Pool_NetworkConfig{
				PeeredNetwork: peeredNetwork,
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"network_config",
			},
		},
	}
	// Updates the pool.
	op, err := client.UpdatePool(ctx, req)
	if err != nil {
		return fmt.Errorf("UpdatePool: %w", err)
	}
	response, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %w", err)
	}

	fmt.Fprintf(w, "Updated pool: %v", response.Name)
	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Java.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
import com.google.cloud.video.livestream.v1.Pool;
import com.google.cloud.video.livestream.v1.Pool.NetworkConfig;
import com.google.cloud.video.livestream.v1.PoolName;
import com.google.cloud.video.livestream.v1.UpdatePoolRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UpdatePool {

  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 poolId = "default";
    String peeredNetwork = "";

    updatePool(projectId, location, poolId, peeredNetwork);
  }

  public static void updatePool(String projectId, String location, String poolId,
      String peeredNetwork)
      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 updatePoolRequest =
        UpdatePoolRequest.newBuilder()
            .setPool(
                Pool.newBuilder()
                    .setName(PoolName.of(projectId, location, poolId).toString())
                    .setNetworkConfig(
                        NetworkConfig.newBuilder()
                            .setPeeredNetwork(peeredNetwork)
                            .build()

                    ))
            .setUpdateMask(FieldMask.newBuilder().addPaths("network_config").build())
            .build();
    // Update pool can take 20+ minutes.
    Pool result =
        livestreamServiceClient.updatePoolAsync(updatePoolRequest).get(20, TimeUnit.MINUTES);
    System.out.println("Updated pool: " + result.getName());
    livestreamServiceClient.close();
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Node.js.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// projectId = 'my-project-id';
// location = 'us-central1';
// poolId = 'my-pool';
// peeredNetwork = 'projects/my-network-project-number/global/networks/my-network-name';

// Imports the Livestream library
const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;

// Instantiates a client
const livestreamServiceClient = new LivestreamServiceClient();

async function updatePool() {
  // Construct request
  const request = {
    pool: {
      name: livestreamServiceClient.poolPath(projectId, location, poolId),
      networkConfig: {
        peeredNetwork: peeredNetwork,
      },
    },
    updateMask: {
      paths: ['network_config'],
    },
  };

  // Run request
  const [operation] = await livestreamServiceClient.updatePool(request);
  const response = await operation.promise();
  const [pool] = response;
  console.log(`Updated pool: ${pool.name}`);
}

updatePool();

PHP

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em PHP.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

use Google\Cloud\Video\LiveStream\V1\Pool;
use Google\Cloud\Video\LiveStream\V1\Client\LivestreamServiceClient;
use Google\Cloud\Video\LiveStream\V1\UpdatePoolRequest;
use Google\Protobuf\FieldMask;

/**
 * Updates a pool.
 *
 * @param string  $callingProjectId   The project ID to run the API call under
 * @param string  $location           The location of the pool
 * @param string  $poolId             The ID of the pool to be updated
 * @param string  $peeredNetwork      The updated peer network
 */
function update_pool(
    string $callingProjectId,
    string $location,
    string $poolId,
    string $peeredNetwork
): void {
    // Instantiate a client.
    $livestreamClient = new LivestreamServiceClient();

    $formattedName = $livestreamClient->poolName($callingProjectId, $location, $poolId);
    $pool = (new Pool())
        ->setName($formattedName)
        ->setNetworkConfig(
            (new Pool\NetworkConfig())
                ->setPeeredNetwork($peeredNetwork));

    $updateMask = new FieldMask([
        'paths' => ['network_config']
    ]);

    // Run the pool update request. The response is a long-running operation ID.
    $request = (new UpdatePoolRequest())
        ->setPool($pool)
        ->setUpdateMask($updateMask);
    $operationResponse = $livestreamClient->updatePool($request);

    $operationResponse->pollUntilComplete();
    if ($operationResponse->operationSucceeded()) {
        $result = $operationResponse->getResult();
        // Print results
        printf('Updated pool: %s' . PHP_EOL, $result->getName());
    } else {
        $error = $operationResponse->getError();
        // handleError($error)
    }
}

Python

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Python.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 field_mask_pb2 as field_mask


def update_pool(
    project_id: str, location: str, pool_id: str, peered_network: str
) -> live_stream_v1.types.Pool:
    """Updates an pool.
    Args:
        project_id: The GCP project ID.
        location: The location of the pool.
        pool_id: The user-defined pool ID.
        peered_network: The updated peer network (e.g.,
        'projects/my-network-project-number/global/networks/my-network-name')."""

    client = LivestreamServiceClient()

    name = f"projects/{project_id}/locations/{location}/pools/{pool_id}"

    pool = live_stream_v1.types.Pool(
        name=name,
        network_config=live_stream_v1.types.Pool.NetworkConfig(
            peered_network=peered_network,
        ),
    )
    update_mask = field_mask.FieldMask(paths=["network_config"])

    operation = client.update_pool(pool=pool, update_mask=update_mask)
    response = operation.result()
    print(f"Updated pool: {response.name}")

    return response

Ruby

Para saber como instalar e usar a biblioteca de cliente da API Live Stream, consulte Bibliotecas de cliente da API Live Stream. Para mais informações, consulte a documentação de referência da API Live Stream em Ruby.

Para autenticar na API Live Stream, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

require "google/cloud/video/live_stream"

##
# Update the pool's peered network
#
# @param project_id [String] Your Google Cloud project (e.g. "my-project")
# @param location [String] The location (e.g. "us-central1")
# @param pool_id [String] Your pool name (e.g. "my-pool")
# @param peered_network [String] The updated peer network
#   (e.g. "projects/my-network-project-number/global/networks/my-network-name")
#
def update_pool project_id:, location:, pool_id:, peered_network:
  # Create a Live Stream client.
  client = Google::Cloud::Video::LiveStream.livestream_service

  # Build the resource name of the pool.
  name = client.pool_path project: project_id, location: location, pool: pool_id

  # Set the update mask.
  update_mask = { paths: ["network_config"] }

  # Update the pool's peered network.
  update_pool = {
    name: name,
    network_config: {
      peered_network: peered_network
    }
  }

  operation = client.update_pool update_mask: update_mask, pool: update_pool

  # 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 pool name.
  puts "Updated pool: #{operation.response.name}"
end