Diese Seite wurde von der Cloud Translation API übersetzt.

Pools erstellen und verwalten

Auf dieser Seite erfährst du, wie du Live Stream API-Pools erstellst und verwaltest. Ein Pool ist eine Verarbeitungseinheit, die jedem Google Cloud-Projekt pro Region zugewiesen wird und von allen Kanälen in einer bestimmten Region gemeinsam genutzt wird. Pools werden verwendet, um Eingabeendpunkte innerhalb eines VPC Service Controls-Perimeters zu schützen. Weitere Informationen finden Sie unter VPC Service Controls zum Schützen Ihrer Pipeline verwenden.

Google Cloud-Projekt und Authentifizierung einrichten

Wenn Sie noch kein Google Cloud-Projekt und keine Anmeldedaten erstellt haben, lesen Sie den Abschnitt Vorbereitung.

Pool erstellen

Wenn Sie an einem Standort zum ersten Mal einen Eingabeendpunkt erstellen, wird automatisch der Standardpool für diesen Standort erstellt.

Pooldetails abrufen

Verwenden Sie die Methode projects.locations.pools.get, um die Details des Pools abzurufen.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

PROJECT_NUMBER: Die Projektnummer Ihres Google Cloud . Sie finden sie auf der Seite IAM-Einstellungen im Feld Projektnummer.
LOCATION: Verwenden Sie eine der unterstützten Regionen, in denen Sie bereits eine Eingabe erstellt haben.
Standorte anzeigen
- 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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

curl (Linux, macOS oder Cloud Shell)

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud-Befehlszeile angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch bei der gcloud-Befehlszeile anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Führen Sie folgenden Befehl aus:

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

PowerShell (Windows)

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud-Befehlszeile angemeldet haben. Dazu führen Sie gcloud init oder gcloud auth login aus. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Führen Sie folgenden Befehl aus:

$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/pools/default" | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für die Live Stream API finden Sie unter Live Stream API-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Live Stream API für C#.

Richten Sie zur Authentifizierung bei der Live Stream API Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.


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

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


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

/**
 * 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

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


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

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

Pool aktualisieren

Verwenden Sie die Methode projects.locations.pools.patch, um einen Eingabeendpunkt zu aktualisieren.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

PROJECT_NUMBER: Die Projektnummer Ihres Google Cloud . Sie finden sie auf der Seite IAM-Einstellungen im Feld Projektnummer.
LOCATION: Der Speicherort des Standard-Pools. Verwenden Sie eine der unterstützten Regionen.
Standorte anzeigen
- 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: die benutzerdefinierte Kennung für das Netzwerk im aktuellen Projekt, das mit dem Dienst gekoppelt werden soll

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

curl (Linux, macOS oder Cloud Shell)

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben:

cat > request.json << 'EOF'
{
  "networkConfig": {
    "peeredNetwork": "projects/PROJECT_NUMBER/global/networks/NETWORK"
  }
}
EOF

Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden:

curl -X PATCH \
     -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/pools/default?updateMask=networkConfig"

PowerShell (Windows)

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben:

@'
{
  "networkConfig": {
    "peeredNetwork": "projects/PROJECT_NUMBER/global/networks/NETWORK"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden:

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

Invoke-WebRequest `
    -Method PATCH `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://livestream.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/pools/default?updateMask=networkConfig" | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Mit diesem Befehl wird ein Vorgang mit langer Ausführungszeit erstellt, mit dem Sie den Fortschritt Ihrer Anfrage verfolgen können. Weitere Informationen finden Sie unter Vorgänge mit langer Ausführungszeit verwalten .

C#


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

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


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

/**
 * 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

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


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

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