Configura el Directorio de servicios

En esta página, se muestra cómo configurar un espacio de nombres del directorio de servicios, agregar un servicio al espacio de nombres y agregar extremos a un servicio. Antes de ejecutar los comandos en esta página, familiarízate con los conceptos en la descripción general del Directorio de servicios y los términos clave relacionados con el Directorio de servicios.

Configure su proyecto

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  4. Habilita la API de Service Directory.

    Habilita la API

  5. Instala Google Cloud CLI.
  6. Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

    gcloud init
  7. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  8. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  9. Habilita la API de Service Directory.

    Habilita la API

  10. Instala Google Cloud CLI.
  11. Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

    gcloud init

Configurar los recursos del Directorio de servicios

Configura un espacio de nombres

Crea un espacio de nombres para tu proyecto para la región seleccionada. No es necesario que esta región esté donde se ejecutan todos tus servicios y extremos, pero debería cerrarse si es posible. Puedes registrar tus servicios en cualquier región del Directorio de servicios. todavía se pueden resolver. Los proyectos pueden tener varios espacios de nombres dentro de una región, y varias regiones pueden tener espacios de nombres. Un solo espacio de nombres no puede abarcar regiones.

Console

  1. Ve a la página Espacios de nombres del directorio de servicios en Google Cloud Console.
    Ir a la página Espacios de nombres del directorio de servicios
  2. Haz clic en Crear espacio de nombres.
  3. En el menú desplegable Región, selecciona una región para tu espacio de nombres.
  4. En el campo Nombre del espacio de nombres, asigna un nombre al espacio de nombres.
  5. Haga clic en Crear.

gcloud

Para usar el Directorio de servicios en la línea de comandos, primero debes instalar o actualizar a la versión más reciente del SDK de Cloud.

  1. Crear un espacio de nombres

    gcloud service-directory namespaces create NAMESPACE \
       --location REGION
    

    Reemplaza lo siguiente:

    • NAMESPACE: es el nombre del espacio de nombres que crearás.
    • REGION: la región de Google Cloud que contiene el espacio de nombres.
  2. Opcional: Configura una política de IAM en tu espacio de nombres. Esto le da al usuario o grupo especificado la función especificada para este espacio de nombres y todos los servicios que pertenecen al espacio de nombres.

    gcloud service-directory namespaces add-iam-policy-binding NAMESPACE \
    --member user:someone@example.com \
    --role ROLE \
    --location REGION
    

    Reemplaza lo siguiente:

    • NAMESPACE es el nombre del espacio de nombres que creaste.
    • ROLE: La función que otorgas.
    • REGION: la región de Google Cloud que contiene el espacio de nombres.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# del directorio de servicios.


using Google.Api.Gax.ResourceNames;
using Google.Cloud.ServiceDirectory.V1;

public class CreateNamespaceSample
{
    public Namespace CreateNamespace(
        string projectId = "my-project",
        string locationId = "us-east1",
        string namespaceId = "test-namespace")
    {
        // Create client
        RegistrationServiceClient registrationServiceClient = RegistrationServiceClient.Create();
        // Initialize request argument(s)
        var locationName = LocationName.FromProjectLocation(projectId, locationId);
        return registrationServiceClient.CreateNamespace(locationName, new Namespace(), namespaceId);
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go del Directorio de servicios.

import (
	"context"
	"fmt"
	"io"

	servicedirectory "cloud.google.com/go/servicedirectory/apiv1"
	sdpb "google.golang.org/genproto/googleapis/cloud/servicedirectory/v1"
)

func createNamespace(w io.Writer, projectID string) error {
	// projectID := "my-project"
	location := "us-east4"
	namespaceID := "golang-test-namespace"

	ctx := context.Background()
	// Create a registration client.
	client, err := servicedirectory.NewRegistrationClient(ctx)
	if err != nil {
		return fmt.Errorf("ServiceDirectory.NewRegistrationClient: %v", err)
	}

	defer client.Close()
	// Create a Namespace.
	req := &sdpb.CreateNamespaceRequest{
		Parent:      fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		NamespaceId: namespaceID,
	}
	resp, err := client.CreateNamespace(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateNamespace: %v", err)
	}
	fmt.Fprintf(w, "servicedirectory.CreateNamespace result: %s\n", resp.Name)
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java del Directorio de servicios.


import com.google.cloud.servicedirectory.v1.LocationName;
import com.google.cloud.servicedirectory.v1.Namespace;
import com.google.cloud.servicedirectory.v1.RegistrationServiceClient;
import java.io.IOException;

public class NamespacesCreate {

  public static void createNamespace() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "your-region";
    // This is user-created; must be unique within the project/region above.
    String namespaceId = "your-namespace";
    createNamespace(projectId, locationId, namespaceId);
  }

  // Create a new namespace.
  public static void createNamespace(String projectId, String locationId, String namespaceId)
      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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RegistrationServiceClient client = RegistrationServiceClient.create()) {

      // The project and location to create the namespace in.
      LocationName parent = LocationName.of(projectId, locationId);

      // The namespace object to create. Here, we use the default instance.
      Namespace namespace = Namespace.newBuilder().build();

      // Send the request to create the namespace.
      Namespace createdNamespace = client.createNamespace(parent, namespace, namespaceId);

      // Process the response.
      System.out.println("Created Namespace: " + createdNamespace.getName());
    }
  }
}

Node.js

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js del Directorio de servicios.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const namespaceId = 'my-namespace';

// Imports the Google Cloud client library
const {
  RegistrationServiceClient,
} = require('@google-cloud/service-directory');

// Creates a client
const registrationServiceClient = new RegistrationServiceClient();

// Build the location name
const locationName = registrationServiceClient.locationPath(
  projectId,
  locationId
);

async function createNamespace() {
  const [namespace] = await registrationServiceClient.createNamespace({
    parent: locationName,
    namespaceId: namespaceId,
  });

  console.log(`Created namespace: ${namespace.name}`);
  return namespace;
}

return createNamespace();

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP del directorio de servicios.

use Google\Cloud\ServiceDirectory\V1beta1\RegistrationServiceClient;
use Google\Cloud\ServiceDirectory\V1beta1\PBNamespace;

/** Uncomment and populate these variables in your code */
// $projectId = '[YOUR_PROJECT_ID]';
// $locationId = '[YOUR_GCP_REGION]';
// $namespaceId = '[YOUR_NAMESPACE_NAME]';

// Instantiate a client.
$client = new RegistrationServiceClient();

// Run request.
$locationName = RegistrationServiceClient::locationName($projectId, $locationId);
$namespace = $client->createNamespace($locationName, $namespaceId, new PBNamespace());

// Print results.
printf('Created Namespace: %s' . PHP_EOL, $namespace->getName());

Python

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python del Directorio de servicios.

def create_namespace(project_id, location_id, namespace_id):
    """Creates a namespace in the given location."""

    client = servicedirectory_v1.RegistrationServiceClient()

    namespace = servicedirectory_v1.Namespace(
        name=client.namespace_path(project_id, location_id, namespace_id))

    response = client.create_namespace(
        parent=f'projects/{project_id}/locations/{location_id}',
        namespace=namespace,
        namespace_id=namespace_id,
    )

    print(f'Created namespace {response.name}.')

    return response

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby del Directorio de servicios.

# project   = "Your Google Cloud project ID"
# location  = "The Google Cloud region containing the new namespace"
# namespace = "The name of the namespace you are creating"

require "google/cloud/service_directory"

# Initialize the client
registration_service = Google::Cloud::ServiceDirectory.registration_service

# The parent path of the namespace
parent = registration_service.location_path(
  project: project, location: location
)

# Use the Service Directory API to create the namespace
response = registration_service.create_namespace(
  parent: parent, namespace_id: namespace
)
puts "Created namespace: #{response.name}"

Configura un servicio

Crea un servicio en el espacio de nombres. Un servicio consiste en un nombre y metadatos opcionales relacionados con el servicio. Existen algunas restricciones en el formato de los nombres de servicio:

  • Los nombres de servicio deben ser únicos dentro de un espacio de nombres.
  • Los nombres de los servicios deben seguir las convenciones de nombres de las etiquetas DNS.

Console

  1. Ve a la página Espacios de nombres del directorio de servicios en Google Cloud Console.
    Ir a la página Espacios de nombres del directorio de servicios
  2. Haz clic en un espacio de nombres.
  3. Haz clic en Agregar servicio.
  4. Ingresa un nombre de servicio.
  5. Opcional Si deseas agregar metadatos al servicio, haz lo siguiente:
    1. Haz clic en Metadatos del servicio.
    2. Haz clic en Agregar metadatos.
    3. Agregue una Clave y un Valor.
    4. Para agregar más pares de metadatos, vuelve a hacer clic en Agregar metadatos.
  6. Haga clic en Crear.

gcloud

Para usar el Directorio de servicios en la línea de comandos, primero debes instalar o actualizar a la versión más reciente del SDK de Cloud.

  1. Crea un servicio en un espacio de nombres.

    gcloud service-directory services create SERVICE \
       --metadata KEY_1=VALUE_1,KEY_2=VALUE_2 \
       --namespace NAMESPACE \
       --location REGION
    

    Reemplaza lo siguiente:

    • SERVICE es el nombre del servicio que estás creando.
    • NAMESPACE: El nombre que le asignaste al espacio de nombres que contiene tu servicio.
    • REGION: la región de Google Cloud que contiene el espacio de nombres.
    • KEY_1,VALUE_1,KEY_2, VALUE_2: la string de clave y valor establecida en pares.
  2. (Opcional) Configura una política de IAM en tu servicio. Esto le otorga al usuario o grupo especificado la función especificada para este servicio y todos los extremos que pertenecen al servicio.

    gcloud service-directory services add-iam-policy-binding SERVICE \
    --member user:someone@example.com \
    --role ROLE \
    --namespace NAMESPACE \
    --location REGION
    

    Reemplaza lo siguiente:

    • SERVICE: es el nombre que le dio a tu servicio.
    • NAMESPACE es el nombre del espacio de nombres que creaste.
    • ROLE: La función que otorgarás.
    • REGION: la región de Google Cloud que contiene el espacio de nombres.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# del directorio de servicios.


using Google.Cloud.ServiceDirectory.V1;

public class CreateServiceSample
{
    public Service CreateService(
        string projectId = "my-project",
        string locationId = "us-east1",
        string namespaceId = "test-namespace",
        string serviceId = "test-service")
    {
        // Create client
        RegistrationServiceClient registrationServiceClient = RegistrationServiceClient.Create();
        // Initialize request argument(s)
        var namespaceName = NamespaceName.FromProjectLocationNamespace(projectId, locationId, namespaceId);
        return registrationServiceClient.CreateService(namespaceName, new Service(), serviceId);
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go del Directorio de servicios.

import (
	"context"
	"fmt"
	"io"

	servicedirectory "cloud.google.com/go/servicedirectory/apiv1"
	sdpb "google.golang.org/genproto/googleapis/cloud/servicedirectory/v1"
)

func createService(w io.Writer, projectID string) error {
	// projectID := "my-project"
	location := "us-east4"
	namespaceID := "golang-test-namespace"
	serviceID := "golang-test-service"

	ctx := context.Background()
	// Create a registration client.
	client, err := servicedirectory.NewRegistrationClient(ctx)
	if err != nil {
		return fmt.Errorf("ServiceDirectory.NewRegistrationClient: %v", err)
	}

	defer client.Close()
	// Create a Service.
	req := &sdpb.CreateServiceRequest{
		Parent:    fmt.Sprintf("projects/%s/locations/%s/namespaces/%s", projectID, location, namespaceID),
		ServiceId: serviceID,
		Service: &sdpb.Service{
			Annotations: map[string]string{
				"key1": "value1",
				"key2": "value2",
			},
		},
	}
	service, err := client.CreateService(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateSerice: %v", err)
	}
	fmt.Fprintf(w, "servicedirectory.Createservice result %s\n", service.Name)
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java del Directorio de servicios.


import com.google.cloud.servicedirectory.v1.NamespaceName;
import com.google.cloud.servicedirectory.v1.RegistrationServiceClient;
import com.google.cloud.servicedirectory.v1.Service;
import java.io.IOException;

public class ServicesCreate {

  public static void createService() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // These variables should refer to an existing Service Directory namespace.
    String projectId = "your-project-id";
    String locationId = "your-region";
    String namespaceId = "your-namespace";
    // This is user-created; must be unique within the namespace above.
    String serviceId = "your-service";
    createService(projectId, locationId, namespaceId, serviceId);
  }

  // Create a new service.
  public static void createService(
      String projectId, String locationId, String namespaceId, String serviceId)
      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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RegistrationServiceClient client = RegistrationServiceClient.create()) {

      // The namespace to create the service in.
      NamespaceName parent = NamespaceName.of(projectId, locationId, namespaceId);

      // The service object to create.
      // Optionally add some annotations for the service.
      Service service = Service.newBuilder().putAnnotations("protocol", "tcp").build();

      // Send the request to create the namespace.
      Service createdService = client.createService(parent, service, serviceId);

      // Process the response.
      System.out.println("Created Service: " + createdService.getName());
      System.out.println("Annotations: " + createdService.getAnnotations());
    }
  }
}

Node.js

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js del Directorio de servicios.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const namespaceId = 'my-namespace';
// const serviceId = 'my-service';

// Imports the Google Cloud client library
const {
  RegistrationServiceClient,
} = require('@google-cloud/service-directory');

// Creates a client
const registrationServiceClient = new RegistrationServiceClient();

// Build the namespace name
const namespaceName = registrationServiceClient.namespacePath(
  projectId,
  locationId,
  namespaceId
);

async function createService() {
  const [service] = await registrationServiceClient.createService({
    parent: namespaceName,
    serviceId: serviceId,
  });

  console.log(`Created service: ${service.name}`);
  return service;
}

return createService();

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP del directorio de servicios.

use Google\Cloud\ServiceDirectory\V1beta1\RegistrationServiceClient;
use Google\Cloud\ServiceDirectory\V1beta1\Service;

/** Uncomment and populate these variables in your code */
// $projectId = '[YOUR_PROJECT_ID]';
// $locationId = '[YOUR_GCP_REGION]';
// $namespaceId = '[YOUR_NAMESPACE_NAME]';
// $serviceId = '[YOUR_SERVICE_NAME]';

// Instantiate a client.
$client = new RegistrationServiceClient();

// Run request.
$namespaceName = RegistrationServiceClient::namespaceName($projectId, $locationId, $namespaceId);
$service = $client->createService($namespaceName, $serviceId, new Service());

// Print results.
printf('Created Service: %s' . PHP_EOL, $service->getName());

Python

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python del Directorio de servicios.

def create_service(project_id, location_id, namespace_id, service_id):
    """Creates a service in the given namespace."""

    client = servicedirectory_v1.RegistrationServiceClient()

    service = servicedirectory_v1.Service(
        name=client.service_path(project_id, location_id, namespace_id,
                                 service_id))

    response = client.create_service(
        parent=client.namespace_path(project_id, location_id, namespace_id),
        service=service,
        service_id=service_id,
    )

    print(f'Created service {response.name}.')

    return response

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby del Directorio de servicios.

# project   = "Your Google Cloud project ID"
# location  = "The Google Cloud region containing the namespace"
# namespace = "The name of the parent namespace"
# service   = "The name of the service you are creating"

require "google/cloud/service_directory"

# Initialize the client
registration_service = Google::Cloud::ServiceDirectory.registration_service

# The parent path of the service
parent = registration_service.namespace_path(
  project: project, location: location, namespace: namespace
)

# Use the Service Directory API to create the service
response = registration_service.create_service parent: parent, service_id: service
puts "Created service: #{response.name}"

Configura un extremo

Una vez que se registra el servicio, agrega algunos extremos. Un extremo consiste en un nombre único y los campos opcionales de metadatos, dirección y puertos/valor. Si se especifica, la dirección debe ser una dirección IPv4 o IPv6 válida.

Console

  1. Ve a la página Espacios de nombres del directorio de servicios en Google Cloud Console.
    Ir a la página Espacios de nombres del directorio de servicios
  2. Haz clic en un espacio de nombres.
  3. Haz clic en un servicio.
  4. Haz clic en Agregar extremo.
  5. Proporciona un Nombre de extremo.
  6. Ingresa una dirección IP IPv4 o IPv6.
  7. Ingresa un número de puerto.
  8. Opcional Si deseas agregar metadatos al extremo, haz lo siguiente:
    1. Haz clic en Metadatos del extremo.
    2. Haz clic en Agregar metadatos.
    3. Agregue una Clave y un Valor.
    4. Para agregar más pares de metadatos, vuelve a hacer clic en Agregar metadatos.
  9. Haga clic en Crear.

gcloud

Para usar el Directorio de servicios en la línea de comandos, primero debes instalar o actualizar a la versión más reciente del SDK de Cloud.

Una vez que se registra el servicio, agrega algunos extremos.

gcloud service-directory endpoints create ENDPOINT \
   --address IP_ADDRESS \
   --port PORT_NUMBER \
   --metadata KEY_1=VALUE_1,KEY_2=VALUE_2 \
   --service SERVICE \
   --namespace NAMESPACE \
   --location REGION
gcloud service-directory endpoints create ENDPOINT2 \
   --address IP_ADDRESS2 \
   --port PORT_NUMBER2 \
   --service SERVICE \
   --namespace NAMESPACE \
   --location REGION

Reemplaza los siguientes valores:

  • ENDPOINT y ENDPOINT2: los nombres de los extremos que creas en tu servicio.
  • IP_ADDRESS y IP_ADDRESS2: las direcciones IPv6 y IPv4 de los extremos, respectivamente.
  • PORT_NUMBER y PORT_NUMBER2: los puertos en los que se ejecutan los extremos.
  • SERVICE es el nombre del servicio que estás creando.
  • NAMESPACE: El nombre que le asignaste al espacio de nombres que contiene tu servicio.
  • REGION: la región de Google Cloud que contiene el espacio de nombres.
  • KEY_1,VALUE_1,KEY_2, VALUE_2: string de valor y clave establecida en pares.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# del directorio de servicios.


using Google.Cloud.ServiceDirectory.V1;

public class CreateEndpointSample
{
	public Endpoint CreateEndpoint(
        string projectId = "my-project",
        string locationId = "us-east1",
        string namespaceId = "test-namespace",
        string serviceId = "test-service",
        string endpointId = "test-endpoint")
    {
        RegistrationServiceClient registrationServiceClient = RegistrationServiceClient.Create();
        var serviceName = ServiceName.FromProjectLocationNamespaceService(projectId, locationId, namespaceId, serviceId);
        return registrationServiceClient.CreateEndpoint(serviceName, new Endpoint(), endpointId);
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go del Directorio de servicios.

import (
	"context"
	"fmt"
	"io"

	servicedirectory "cloud.google.com/go/servicedirectory/apiv1"
	sdpb "google.golang.org/genproto/googleapis/cloud/servicedirectory/v1"
)

func createEndpoint(w io.Writer, projectID string) error {
	// projectID := "my-project"
	location := "us-east4"
	namespaceID := "golang-test-namespace"
	serviceID := "golang-test-service"
	endpointID := "golang-test-endpoint"

	ctx := context.Background()
	// Create a registration client.
	client, err := servicedirectory.NewRegistrationClient(ctx)
	if err != nil {
		return fmt.Errorf("ServiceDirectory.NewRegistrationClient: %v", err)
	}

	defer client.Close()
	// Create an Endpoint.
	req := &sdpb.CreateEndpointRequest{
		Parent:     fmt.Sprintf("projects/%s/locations/%s/namespaces/%s/services/%s", projectID, location, namespaceID, serviceID),
		EndpointId: endpointID,
		Endpoint: &sdpb.Endpoint{
			Address: "8.8.8.8",
			Port:    8080,
			Annotations: map[string]string{
				"key1": "value1",
				"key2": "value2",
			},
		},
	}
	endpoint, err := client.CreateEndpoint(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateEndpoint: %v", err)
	}
	fmt.Fprintf(w, "servicedirectory.CreateEndpoint result: %s", endpoint.Name)
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java del Directorio de servicios.


import com.google.cloud.servicedirectory.v1.Endpoint;
import com.google.cloud.servicedirectory.v1.RegistrationServiceClient;
import com.google.cloud.servicedirectory.v1.ServiceName;
import java.io.IOException;

public class EndpointsCreate {

  public static void createEndpoint() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // These variables should refer to an existing Service Directory service.
    String projectId = "your-project-id";
    String locationId = "your-region";
    String namespaceId = "your-namespace";
    String serviceId = "your-service";
    // This is user-created; must be unique within the service above.
    String endpointId = "your-endpoint";
    createEndpoint(projectId, locationId, namespaceId, serviceId, endpointId);
  }

  // Create a new endpoint.
  public static void createEndpoint(
      String projectId, String locationId, String namespaceId, String serviceId, String endpointId)
      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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RegistrationServiceClient client = RegistrationServiceClient.create()) {

      // The service to create the endpoint in.
      ServiceName parent = ServiceName.of(projectId, locationId, namespaceId, serviceId);

      // The endpoint to create, with fields filled in.
      // Optionally set an IP address and port for the endpoint.
      Endpoint endpoint = Endpoint.newBuilder().setAddress("10.0.0.1").setPort(443).build();

      // Send the request to create the endpoint.
      Endpoint createdEndpoint = client.createEndpoint(parent, endpoint, endpointId);

      // Process the response.
      System.out.println("Created Endpoint: " + createdEndpoint.getName());
      System.out.println("IP Address: " + createdEndpoint.getAddress());
      System.out.println("Port: " + createdEndpoint.getPort());
    }
  }
}

Node.js

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js del Directorio de servicios.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const namespaceId = 'my-namespace';
// const serviceId = 'my-service';
// const endpointId = 'my-endpoint';

// Imports the Google Cloud client library
const {
  RegistrationServiceClient,
} = require('@google-cloud/service-directory');

// Creates a client
const registrationServiceClient = new RegistrationServiceClient();

// Build the service name
const serviceName = registrationServiceClient.servicePath(
  projectId,
  locationId,
  namespaceId,
  serviceId
);

async function createEndpoint() {
  const [endpoint] = await registrationServiceClient.createEndpoint({
    parent: serviceName,
    endpointId: endpointId,
    endpoint: {address: '10.0.0.1', port: 8080},
  });

  console.log(`Created endpoint: ${endpoint.name}`);
  return endpoint;
}

return createEndpoint();

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP del directorio de servicios.

use Google\Cloud\ServiceDirectory\V1beta1\RegistrationServiceClient;
use Google\Cloud\ServiceDirectory\V1beta1\Endpoint;

/** Uncomment and populate these variables in your code */
// $projectId = '[YOUR_PROJECT_ID]';
// $locationId = '[YOUR_GCP_REGION]';
// $namespaceId = '[YOUR_NAMESPACE_NAME]';
// $serviceId = '[YOUR_SERVICE_NAME]';
// $endpointId = '[YOUR_ENDPOINT_NAME]';
// $ip = '[IP_ADDRESS]';  // (Optional) Defaults to ''
// $port = [PORT];  // (Optional) Defaults to 0

// Instantiate a client.
$client = new RegistrationServiceClient();

// Construct Endpoint object.
$endpointObject = (new Endpoint())
    ->setAddress($ip)
    ->setPort($port);

// Run request.
$serviceName = RegistrationServiceClient::serviceName($projectId, $locationId, $namespaceId, $serviceId);
$endpoint = $client->createEndpoint($serviceName, $endpointId, $endpointObject);

// Print results.
printf('Created Endpoint: %s' . PHP_EOL, $endpoint->getName());
printf('  IP: %s' . PHP_EOL, $endpoint->getAddress());
printf('  Port: %d' . PHP_EOL, $endpoint->getPort());

Python

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python del Directorio de servicios.

def create_endpoint(project_id, location_id, namespace_id, service_id,
                    endpoint_id, address, port):
    """Creates a endpoint in the given service."""

    client = servicedirectory_v1.RegistrationServiceClient()

    endpoint = servicedirectory_v1.Endpoint(
        name=client.endpoint_path(project_id, location_id, namespace_id,
                                  service_id, endpoint_id),
        address=address,
        port=port)

    response = client.create_endpoint(
        parent=client.service_path(project_id, location_id, namespace_id,
                                   service_id),
        endpoint=endpoint,
        endpoint_id=endpoint_id,
    )

    print(f'Created endpoint {response.name}.')

    return response

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby del Directorio de servicios.

# project   = "Your Google Cloud project ID"
# location  = "The Google Cloud region containing the namespace"
# namespace = "The name of the parent namespace"
# service   = "The name of the parent service"
# endpoint  = "The name of the endpoint you are creating"

require "google/cloud/service_directory"

# Initialize the client
registration_service = Google::Cloud::ServiceDirectory.registration_service

# The parent path of the endpoint
parent = registration_service.service_path(
  project:   project,
  location:  location,
  namespace: namespace,
  service:   service
)

# Set the IP Address and Port on the Endpoint
endpoint_data = Google::Cloud::ServiceDirectory::V1::Endpoint.new(
  address: "10.0.0.1",
  port:    443
)

# Use the Service Directory API to create the endpoint
response = registration_service.create_endpoint(
  parent: parent, endpoint_id: endpoint, endpoint: endpoint_data
)
puts "Created endpoint: #{response.name}"

Resolver un servicio

El Directorio de servicios permite que los clientes resuelvan los servicios con DNS, HTTP y gRPC. Resolver el servicio muestra todas las propiedades del servicio, así como todos los extremos y metadatos.

gcloud

Para usar el Directorio de servicios en la línea de comandos, primero debes instalar o actualizar a la versión más reciente del SDK de Cloud.

gcloud service-directory services resolve SERVICE \
   --namespace NAMESPACE \
   --location REGION

Reemplaza lo siguiente:

  • SERVICE es el nombre del servicio que estás creando.
  • NAMESPACE: El nombre que le asignaste al espacio de nombres que contiene tu servicio.
  • REGION: la región de Google Cloud que contiene el espacio de nombres.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# del directorio de servicios.


using Google.Cloud.ServiceDirectory.V1;

public class ResolveServiceSample
{
    public Service ResolveService(
        string projectId = "my-project",
        string locationId = "us-east1",
        string namespaceId = "test-namespace",
        string serviceId = "test-service")
    {
        // Create client
        LookupServiceClient lookupServiceClient = LookupServiceClient.Create();
        // Initialize request argument(s)
        ResolveServiceRequest request = new ResolveServiceRequest
        {
            ServiceName = ServiceName.FromProjectLocationNamespaceService(projectId, locationId, namespaceId, serviceId),
        };
        // Make the request
        ResolveServiceResponse response = lookupServiceClient.ResolveService(request);
        return response.Service;
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go del Directorio de servicios.

import (
	"context"
	"fmt"
	"io"

	servicedirectory "cloud.google.com/go/servicedirectory/apiv1"
	sdpb "google.golang.org/genproto/googleapis/cloud/servicedirectory/v1"
)

func resolveService(w io.Writer, projectID string) error {
	// projectID := "my-project"
	location := "us-east4"
	namespaceID := "golang-test-namespace"
	serviceID := "golang-test-service"

	ctx := context.Background()
	// Create a lookup client.
	resolver, err := servicedirectory.NewLookupClient(ctx)
	if err != nil {
		return fmt.Errorf("ServiceDirectory.NewLookupClient: %v", err)
	}

	defer resolver.Close()
	// Now Resolve the service.
	req := &sdpb.ResolveServiceRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/namespaces/%s/services/%s", projectID, location, namespaceID, serviceID),
	}
	result, err := resolver.ResolveService(ctx, req)
	if err != nil {
		return fmt.Errorf("ResolveService: %v", err)
	}

	fmt.Fprintf(w, "Successfully Resolved Service %v\n", result)
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java del Directorio de servicios.


import com.google.cloud.servicedirectory.v1.Endpoint;
import com.google.cloud.servicedirectory.v1.LookupServiceClient;
import com.google.cloud.servicedirectory.v1.ResolveServiceRequest;
import com.google.cloud.servicedirectory.v1.ResolveServiceResponse;
import com.google.cloud.servicedirectory.v1.ServiceName;
import java.io.IOException;

public class ServicesResolve {

  public static void resolveService() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // These variables should refer to an existing Service Directory service.
    String projectId = "your-project-id";
    String locationId = "your-region";
    String namespaceId = "your-namespace";
    String serviceId = "your-service";
    resolveService(projectId, locationId, namespaceId, serviceId);
  }

  // Resolve a service.
  public static void resolveService(
      String projectId, String locationId, String namespaceId, String serviceId)
      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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (LookupServiceClient client = LookupServiceClient.create()) {
      // The service to resolve.
      ServiceName name = ServiceName.of(projectId, locationId, namespaceId, serviceId);

      // Construct the resolve request to be sent to the client.
      ResolveServiceRequest request =
          ResolveServiceRequest.newBuilder().setName(name.toString()).build();

      // Send the request to resolve the service.
      ResolveServiceResponse resolveResponse = client.resolveService(request);

      // Process the response.
      System.out.println("Resolved Service: " + resolveResponse.getService().getName());

      System.out.println("Endpoints found:");
      for (Endpoint endpoint : resolveResponse.getService().getEndpointsList()) {
        System.out.println(
            endpoint.getName() + " -- " + endpoint.getAddress() + ":" + endpoint.getPort());
      }
    }
  }
}

Node.js

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js del Directorio de servicios.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const namespaceId = 'my-namespace';
// const serviceId = 'my-service';

// Imports the Google Cloud client library
const {LookupServiceClient} = require('@google-cloud/service-directory');

// Creates a client
const lookupServiceClient = new LookupServiceClient();

// Build the service name
const serviceName = lookupServiceClient.servicePath(
  projectId,
  locationId,
  namespaceId,
  serviceId
);

async function resolveService() {
  const [response] = await lookupServiceClient.resolveService({
    name: serviceName,
  });

  console.log(`Resolved service: ${response.service.name}`);
  for (const e of response.service.endpoints) {
    console.log(`\n${e.name}`);
    console.log(`Address: ${e.address}`);
    console.log(`Port: ${e.port}\n`);
  }
  return response.service;
}

return resolveService();

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP del directorio de servicios.

use Google\Cloud\ServiceDirectory\V1beta1\LookupServiceClient;
use Google\Cloud\ServiceDirectory\V1beta1\Service;

/** Uncomment and populate these variables in your code */
// $projectId = '[YOUR_PROJECT_ID]';
// $locationId = '[YOUR_GCP_REGION]';
// $namespaceId = '[YOUR_NAMESPACE_NAME]';
// $serviceId = '[YOUR_SERVICE_NAME]';

// Instantiate a client.
$client = new LookupServiceClient();

// Run request.
$serviceName = LookupServiceClient::serviceName($projectId, $locationId, $namespaceId, $serviceId);
$service = $client->resolveService($serviceName)->getService();

// Print results.
printf('Resolved Service: %s' . PHP_EOL, $service->getName());
print('Endpoints:' . PHP_EOL);
foreach ($service->getEndpoints() as $endpoint) {
    printf('  Name: %s' . PHP_EOL, $endpoint->getName());
    printf('    IP: %s' . PHP_EOL, $endpoint->getAddress());
    printf('    Port: %d' . PHP_EOL, $endpoint->getPort());
}

Python

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python del Directorio de servicios.

def resolve_service(project_id, location_id, namespace_id, service_id):
    """Resolves a service in the given namespace."""

    client = servicedirectory_v1.LookupServiceClient()

    request = servicedirectory_v1.ResolveServiceRequest(
        name=servicedirectory_v1.RegistrationServiceClient().service_path(
            project_id, location_id, namespace_id, service_id))

    response = client.resolve_service(request=request)

    print('Endpoints found:')
    for endpoint in response.service.endpoints:
        print(f'{endpoint.name} -- {endpoint.address}:{endpoint.port}')

    return response

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby del Directorio de servicios.

# project   = "Your Google Cloud project ID"
# location  = "The Google Cloud region containing the namespace"
# namespace = "The name of the parent namespace"
# service   = "The name of the service"

require "google/cloud/service_directory"

# Initialize the client
lookup_service = Google::Cloud::ServiceDirectory.lookup_service

# The name of the service
service_path = lookup_service.service_path(
  project:   project,
  location:  location,
  namespace: namespace,
  service:   service
)

# Use the Service Directory API to resolve the service
response = lookup_service.resolve_service name: service_path
puts "Resolved service: #{response.service.name}"
puts "Endpoints: "
response.service.endpoints.each do |endpoint|
  puts "#{endpoint.name} #{endpoint.address} #{endpoint.port}"
end

Borra recursos

Borra un extremo de un servicio

Console

  1. Ve a la página Espacios de nombres del directorio de servicios en Google Cloud Console.
    Ir a la página Espacios de nombres del directorio de servicios
  2. Haz clic en el espacio de nombres del que deseas borrar el extremo.
  3. Haz clic en el servicio del que deseas borrar el extremo.
  4. Haz clic en la casilla de verificación junto al extremo que deseas borrar.
  5. Haz clic en Borrar.
  6. En el cuadro de diálogo de confirmación, vuelve a hacer clic en Borrar .

gcloud

Para usar el Directorio de servicios en la línea de comandos, primero debes instalar o actualizar a la versión más reciente del SDK de Cloud.

gcloud service-directory endpoints delete ENDPOINT \
    --service=SERVICE \
    --namespace=NAMESPACE \
    --location=REGION

Reemplaza lo siguiente:

  • SERVICE es el nombre del servicio que estás creando.
  • NAMESPACE: El nombre que le asignaste al espacio de nombres que contiene tu servicio.
  • REGION: la región de Google Cloud que contiene el espacio de nombres.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# del directorio de servicios.


using Google.Cloud.ServiceDirectory.V1;

public class DeleteEndpointSample
{
    public void DeleteEndpoint(
        string projectId = "my-project",
        string locationId = "us-east1",
        string namespaceId = "test-namespace",
        string serviceId = "test-service",
        string endpointId = "test-endpoint")
    {
        // Create client
        RegistrationServiceClient registrationServiceClient = RegistrationServiceClient.Create();
        // Initialize request argument(s)
        var endpointName = EndpointName.FromProjectLocationNamespaceServiceEndpoint(projectId, locationId, namespaceId, serviceId, endpointId);
        registrationServiceClient.DeleteEndpoint(endpointName);
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go del Directorio de servicios.

import (
	"context"
	"fmt"

	servicedirectory "cloud.google.com/go/servicedirectory/apiv1"
	sdpb "google.golang.org/genproto/googleapis/cloud/servicedirectory/v1"
)

func deleteEndpoint(projectID string) error {
	// projectID := "my-project"
	location := "us-east4"
	namespaceID := "golang-test-namespace"
	serviceID := "golang-test-service"
	endpointID := "golang-test-endpoint"

	ctx := context.Background()
	// Create a registration client.
	client, err := servicedirectory.NewRegistrationClient(ctx)
	if err != nil {
		return fmt.Errorf("ServiceDirectory.NewRegistrationClient: %v", err)
	}

	defer client.Close()
	// Delete an Endpoint
	req := &sdpb.DeleteEndpointRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/namespaces/%s/services/%s/endpoints/%s", projectID, location, namespaceID, serviceID, endpointID),
	}
	if err := client.DeleteEndpoint(ctx, req); err != nil {
		return fmt.Errorf("DeleteEndpoint: %v", err)
	}
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java del Directorio de servicios.


import com.google.cloud.servicedirectory.v1.EndpointName;
import com.google.cloud.servicedirectory.v1.RegistrationServiceClient;
import java.io.IOException;

public class EndpointsDelete {

  public static void deleteEndpoint() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // These variables should refer to an existing Service Directory endpoint.
    String projectId = "your-project-id";
    String locationId = "your-region";
    String namespaceId = "your-namespace";
    String serviceId = "your-service";
    String endpointId = "your-endpoint";
    deleteEndpoint(projectId, locationId, namespaceId, serviceId, endpointId);
  }

  // Delete an endpoint.
  public static void deleteEndpoint(
      String projectId, String locationId, String namespaceId, String serviceId, String endpointId)
      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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RegistrationServiceClient client = RegistrationServiceClient.create()) {

      // The endpoint to delete.
      EndpointName endpointName =
          EndpointName.of(projectId, locationId, namespaceId, serviceId, endpointId);

      // Send the request to delete the endpoint.
      client.deleteEndpoint(endpointName);

      // Log the action.
      System.out.println("Deleted Endpoint: " + endpointName.toString());
    }
  }
}

Node.js

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js del Directorio de servicios.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const namespaceId = 'my-namespace';
// const serviceId = 'my-service';
// const endpointId = 'my-endpoint';

// Imports the Google Cloud client library
const {
  RegistrationServiceClient,
} = require('@google-cloud/service-directory');

// Creates a client
const registrationServiceClient = new RegistrationServiceClient();

// Build the endpoint name
const endpointName = registrationServiceClient.endpointPath(
  projectId,
  locationId,
  namespaceId,
  serviceId,
  endpointId
);

async function deleteEndpoint() {
  await registrationServiceClient.deleteEndpoint({
    name: endpointName,
  });

  console.log(`Deleted endpoint: ${endpointName}`);
}

deleteEndpoint();

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP del directorio de servicios.

use Google\Cloud\ServiceDirectory\V1beta1\RegistrationServiceClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[YOUR_PROJECT_ID]';
// $locationId = '[YOUR_GCP_REGION]';
// $namespaceId = '[YOUR_NAMESPACE_NAME]';
// $serviceId = '[YOUR_SERVICE_NAME]';
// $endpointId = '[YOUR_ENDPOINT_NAME]';

// Instantiate a client.
$client = new RegistrationServiceClient();

// Run request.
$endpointName = RegistrationServiceClient::endpointName($projectId, $locationId, $namespaceId, $serviceId, $endpointId);
$endpoint = $client->deleteEndpoint($endpointName);

// Print results.
printf('Deleted Endpoint: %s' . PHP_EOL, $endpointName);

Python

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python del Directorio de servicios.

def delete_endpoint(project_id, location_id, namespace_id, service_id,
                    endpoint_id):
    """Deletes a endpoin in the given service."""

    client = servicedirectory_v1.RegistrationServiceClient()

    endpoint_name = client.endpoint_path(project_id, location_id, namespace_id,
                                         service_id, endpoint_id)

    client.delete_endpoint(name=endpoint_name)

    print(f'Deleted endpoint {endpoint_name}.')

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby del Directorio de servicios.

# project   = "Your Google Cloud project ID"
# location  = "The Google Cloud region containing the namespace"
# namespace = "The name of the parent namespace"
# service   = "The name of the parent service"
# endpoint  = "The name of the endpoint"

require "google/cloud/service_directory"

# Initialize the client
registration_service = Google::Cloud::ServiceDirectory.registration_service

# The path of the endpoint
endpoint_path = registration_service.endpoint_path(
  project:   project,
  location:  location,
  namespace: namespace,
  service:   service,
  endpoint:  endpoint
)

# Use the Service Directory API to delete the endpoint
registration_service.delete_endpoint name: endpoint_path
puts "Deleted endpoint: #{endpoint_path}"

Borra un servicio de un espacio de nombres

Puedes borrar un servicio que tiene extremos. Cuando se borra un servicio, también se borran todos sus extremos.

Puedes borrar un servicio que tenga una zona del Directorio de servicios que apunte a él. Todas las consultas de DNS para ese servicio muestran NXDOMAIN.

Console

  1. Ve a la página Espacios de nombres del directorio de servicios en Google Cloud Console.
    Ir a la página Espacios de nombres del directorio de servicios
  2. Haz clic en el espacio de nombres del que deseas borrar el servicio.
  3. Haz clic en la casilla de verificación junto al servicio que deseas borrar.
  4. Haz clic en Borrar.
  5. Haz clic en Borrar nuevamente en el cuadro de diálogo de confirmación.

gcloud

Para usar el Directorio de servicios en la línea de comandos, primero debes instalar o actualizar a la versión más reciente del SDK de Cloud.

gcloud service-directory services delete SERVICE \
    --namespace=NAMESPACE \
    --location=REGION

Reemplaza lo siguiente:

  • SERVICE es el nombre del servicio que estás creando.
  • NAMESPACE: El nombre que le asignaste al espacio de nombres que contiene tu servicio.
  • REGION: la región de Google Cloud que contiene el espacio de nombres.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# del directorio de servicios.


using Google.Cloud.ServiceDirectory.V1;

public class DeleteServiceSample
{
    public void DeleteService(
        string projectId = "my-project",
        string locationId = "us-east1",
        string namespaceId = "test-namespace",
        string serviceId = "test-service")
    {
        // Create client
        RegistrationServiceClient registrationServiceClient = RegistrationServiceClient.Create();
        // Initialize request argument(s)
        var serviceName = ServiceName.FromProjectLocationNamespaceService(projectId, locationId, namespaceId, serviceId);
        registrationServiceClient.DeleteService(serviceName);
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go del Directorio de servicios.

import (
	"context"
	"fmt"

	servicedirectory "cloud.google.com/go/servicedirectory/apiv1"
	sdpb "google.golang.org/genproto/googleapis/cloud/servicedirectory/v1"
)

func deleteService(projectID string) error {
	// projectID := "my-project"
	location := "us-east4"
	namespaceID := "golang-test-namespace"
	serviceID := "golang-test-service"

	ctx := context.Background()
	// Create a registration client.
	client, err := servicedirectory.NewRegistrationClient(ctx)
	if err != nil {
		return fmt.Errorf("ServiceDirectory.NewRegistrationClient: %v", err)
	}

	defer client.Close()
	// Delete a service
	req := &sdpb.DeleteServiceRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/namespaces/%s/services/%s", projectID, location, namespaceID, serviceID),
	}
	if err := client.DeleteService(ctx, req); err != nil {
		return fmt.Errorf("DeleteService: %v", err)
	}
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java del Directorio de servicios.


import com.google.cloud.servicedirectory.v1.RegistrationServiceClient;
import com.google.cloud.servicedirectory.v1.ServiceName;
import java.io.IOException;

public class ServicesDelete {

  public static void deleteService() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // These variables should refer to an existing Service Directory service.
    String projectId = "your-project-id";
    String locationId = "your-region";
    String namespaceId = "your-namespace";
    String serviceId = "your-service";
    deleteService(projectId, locationId, namespaceId, serviceId);
  }

  // Delete a service.
  public static void deleteService(
      String projectId, String locationId, String namespaceId, String serviceId)
      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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RegistrationServiceClient client = RegistrationServiceClient.create()) {

      // The service to delete.
      ServiceName serviceName = ServiceName.of(projectId, locationId, namespaceId, serviceId);

      // Send the request to delete the service.
      client.deleteService(serviceName);

      // Log the action.
      System.out.println("Deleted Service: " + serviceName.toString());
    }
  }
}

Node.js

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js del Directorio de servicios.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const namespaceId = 'my-namespace';
// const serviceId = 'my-service';

// Imports the Google Cloud client library
const {
  RegistrationServiceClient,
} = require('@google-cloud/service-directory');

// Creates a client
const registrationServiceClient = new RegistrationServiceClient();

// Build the service name
const serviceName = registrationServiceClient.servicePath(
  projectId,
  locationId,
  namespaceId,
  serviceId
);

async function deleteService() {
  await registrationServiceClient.deleteService({
    name: serviceName,
  });

  console.log(`Deleted service: ${serviceName}`);
}

deleteService();

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP del directorio de servicios.

use Google\Cloud\ServiceDirectory\V1beta1\RegistrationServiceClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[YOUR_PROJECT_ID]';
// $locationId = '[YOUR_GCP_REGION]';
// $namespaceId = '[YOUR_NAMESPACE_NAME]';
// $serviceId = '[YOUR_SERVICE_NAME]';

// Instantiate a client.
$client = new RegistrationServiceClient();

// Run request.
$serviceName = RegistrationServiceClient::serviceName($projectId, $locationId, $namespaceId, $serviceId);
$client->deleteService($serviceName);

// Print results.
printf('Deleted Service: %s' . PHP_EOL, $serviceName);

Python

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python del Directorio de servicios.

def delete_service(project_id, location_id, namespace_id, service_id):
    """Deletes a service in the given namespace."""

    client = servicedirectory_v1.RegistrationServiceClient()

    service_name = client.service_path(project_id, location_id, namespace_id,
                                       service_id)

    client.delete_service(name=service_name)

    print(f'Deleted service {service_name}.')

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby del Directorio de servicios.

# project   = "Your Google Cloud project ID"
# location  = "The Google Cloud region containing the namespace"
# namespace = "The name of the parent namespace"
# service   = "The name of the service"

require "google/cloud/service_directory"

# Initialize the client
registration_service = Google::Cloud::ServiceDirectory.registration_service

# The path of the service
service_path = registration_service.service_path(
  project:   project,
  location:  location,
  namespace: namespace,
  service:   service
)

# Use the Service Directory API to delete the service
registration_service.delete_service name: service_path
puts "Deleted service: #{service_path}"

Borra un espacio de nombres

Puedes borrar un espacio de nombres que tenga servicios y extremos. Cuando se borra un espacio de nombres, también se borran todos sus servicios y extremos.

Puedes borrar un espacio de nombres que tenga una zona del Directorio de servicios que apunte a él. Cualquier consulta adicional de DNS (sin incluir las solicitudes SOA/NS para el origen de la zona) muestra NXDOMAIN.

Console

  1. Ve a la página Espacios de nombres del directorio de servicios en Google Cloud Console.
    Ir a la página Espacios de nombres del directorio de servicios
  2. Haz clic en la casilla de verificación junto al espacio de nombres que deseas borrar.
  3. Haz clic en Borrar.
  4. En el cuadro de diálogo de confirmación, vuelve a hacer clic en Borrar.

gcloud

Para usar el Directorio de servicios en la línea de comandos, primero debes instalar o actualizar a la versión más reciente del SDK de Cloud.

gcloud service-directory namespaces delete NAMESPACE \
    --location=REGION

Reemplaza lo siguiente:

  • NAMESPACE: El nombre que le asignaste al espacio de nombres que contiene tu servicio.
  • REGION: la región de Google Cloud que contiene el espacio de nombres.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# y, luego, instala el SDK de C# del directorio de servicios.


using Google.Cloud.ServiceDirectory.V1;

public class DeleteNamespaceSample
{
    public void DeleteNamespace(
        string projectId = "projectId",
        string locationId = "us-east1",
        string namespaceId = "test-namespace")
    {
        // Create client
        RegistrationServiceClient registrationServiceClient = RegistrationServiceClient.Create();
        // Initialize request argument(s)
        var namespaceName = NamespaceName.FromProjectLocationNamespace(projectId, locationId, namespaceId);
        registrationServiceClient.DeleteNamespace(namespaceName);
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go del Directorio de servicios.

import (
	"context"
	"fmt"

	servicedirectory "cloud.google.com/go/servicedirectory/apiv1"
	sdpb "google.golang.org/genproto/googleapis/cloud/servicedirectory/v1"
)

func deleteNamespace(projectID string) error {
	// projectID := "my-project"
	location := "us-east4"
	namespaceID := "golang-test-namespace"

	ctx := context.Background()
	// Create a registration client.
	client, err := servicedirectory.NewRegistrationClient(ctx)
	if err != nil {
		return fmt.Errorf("ServiceDirectory.NewRegistrationClient: %v", err)
	}

	defer client.Close()
	// Delete a Namespace.
	req := &sdpb.DeleteNamespaceRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/namespaces/%s", projectID, location, namespaceID),
	}
	if err := client.DeleteNamespace(ctx, req); err != nil {
		return fmt.Errorf("DeleteNamespace: %v", err)
	}
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java del Directorio de servicios.


import com.google.cloud.servicedirectory.v1.NamespaceName;
import com.google.cloud.servicedirectory.v1.RegistrationServiceClient;
import java.io.IOException;

public class NamespacesDelete {

  public static void deleteNamespace() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // These variables should refer to an existing Service Directory namespace.
    String projectId = "your-project-id";
    String locationId = "your-region";
    String namespaceId = "your-namespace";
    deleteNamespace(projectId, locationId, namespaceId);
  }

  // Delete a namespace.
  public static void deleteNamespace(String projectId, String locationId, String namespaceId)
      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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RegistrationServiceClient client = RegistrationServiceClient.create()) {

      // The namespace to delete.
      NamespaceName namespaceName = NamespaceName.of(projectId, locationId, namespaceId);

      // Send the request to delete the namespace.
      client.deleteNamespace(namespaceName);

      // Log the action.
      System.out.println("Deleted Namespace: " + namespaceName.toString());
    }
  }
}

Node.js

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js del Directorio de servicios.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const namespaceId = 'my-namespace';

// Imports the Google Cloud client library
const {
  RegistrationServiceClient,
} = require('@google-cloud/service-directory');

// Creates a client
const registrationServiceClient = new RegistrationServiceClient();

// Build the namespace name
const namespaceName = registrationServiceClient.namespacePath(
  projectId,
  locationId,
  namespaceId
);

async function deleteNamespace() {
  await registrationServiceClient.deleteNamespace({
    name: namespaceName,
  });

  console.log(`Deleted namespace: ${namespaceName}`);
}

deleteNamespace();

PHP

Para ejecutar este código, primero configura un entorno de desarrollo de PHP y, luego, instala el SDK de PHP del directorio de servicios.

use Google\Cloud\ServiceDirectory\V1beta1\RegistrationServiceClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[YOUR_PROJECT_ID]';
// $locationId = '[YOUR_GCP_REGION]';
// $namespaceId = '[YOUR_NAMESPACE_NAME]';

// Instantiate a client.
$client = new RegistrationServiceClient();

// Run request.
$namespaceName = RegistrationServiceClient::namespaceName($projectId, $locationId, $namespaceId);
$client->deleteNamespace($namespaceName);

// Print results.
printf('Deleted Namespace: %s' . PHP_EOL, $namespaceName);

Python

Si deseas ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python del Directorio de servicios.

def delete_namespace(project_id, location_id, namespace_id):
    """Deletes a namespace in the given location."""

    client = servicedirectory_v1.RegistrationServiceClient()

    namespace_name = client.namespace_path(project_id, location_id, namespace_id)

    client.delete_namespace(name=namespace_name)

    print(f'Deleted namespace {namespace_name}.')

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby del Directorio de servicios.

# project   = "Your Google Cloud project ID"
# location  = "The Google Cloud region containing the namespace"
# namespace = "The name of the namespace"

require "google/cloud/service_directory"

# Initialize the client
registration_service = Google::Cloud::ServiceDirectory.registration_service

# The path of the namespace
namespace_name = registration_service.namespace_path(
  project: project, location: location, namespace: namespace
)

# Use the Service Directory API to delete the namespace
registration_service.delete_namespace name: namespace_name
puts "Deleted namespace: #{namespace_name}"

¿Qué sigue?