Configurer l'annuaire des services

Cette page explique comment configurer un espace de noms de service, ajouter un service à l'espace de noms et ajouter des points de terminaison à un service. Avant d'exécuter les commandes sur cette page, familiarisez-vous avec les concepts de la présentation de Service Directory et des mots clés liés à l'annuaire des services.

Configurer votre projet

1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

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

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Service Directory API.

   Enable the API

5. Install the Google Cloud CLI.

6. To initialize the gcloud CLI, run the following command:

   gcloud init

7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

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

   Go to project selector

8. Make sure that billing is enabled for your Google Cloud project.

9. Enable the Service Directory API.

   Enable the API

10. Install the Google Cloud CLI.

11. To initialize the gcloud CLI, run the following command:

    gcloud init

Configurer les ressources de l'Annuaire des services

Configurer un objet Namespace

Créez un espace de noms pour la région de votre choix. Cette région n'a pas besoin d'être là où tous vos services et points de terminaison sont en cours d'exécution, mais doivent être proches, si possible. Vous pouvez enregistrer vos services dans n'importe quelle région de l'Annuaire des services. elles peuvent toujours être traitées dans le monde entier. Les projets peuvent comporter plusieurs espaces de noms au sein d'une même région, et ceux-ci peuvent comporter des espaces de noms. Un espace de noms unique ne peut pas s'étendre sur plusieurs régions.

Console

1. Accédez à la page "Espaces de noms de répertoires du service" dans Google Cloud Console.
   Accéder à la page "Espaces de noms de répertoire de service"
2. Cliquez sur Créer un espace de noms.
3. Dans le menu déroulant Région, sélectionnez une région pour votre espace de noms.
4. Dans le champ Nom de l'espace de noms, attribuez un nom à l'espace de noms.
5. Cliquez sur Create (Créer).

gcloud

Pour utiliser Service Directory sur la ligne de commande, commencez par installer la dernière version du SDK Cloud ou passer à la version la plus récente.

1. Créer un espace de nommage

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

   Remplacez l'élément suivant :

   • NAMESPACE: nom de l'espace de noms que vous créez.
   • REGION: région Google Cloud qui contient l'espace de noms.

2. (Facultatif): Définissez une stratégie IAM sur votre espace de noms. Le rôle spécifié est ainsi attribué à l'utilisateur ou au groupe spécifié pour cet espace de noms et tous les services appartenant à cet espace de noms.

   gcloud service-directory namespaces add-iam-policy-binding NAMESPACE \
   --member user:[e-mail] \
   --role ROLE \
   --location REGION
   

   Remplacez l'élément suivant :

   • NAMESPACE: nom de l'espace de noms que vous avez créé.
   • ROLE: le rôle que vous accordez.
   • REGION: région Google Cloud qui contient l'espace de noms.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK C# du répertoire de services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Go Directory Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Java de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js et installez le SDK Node.js Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, configurez un environnement de développement PHP et installez le SDK PHP de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Python du répertoire de service.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Ruby et installez le SDK Ruby de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Configurer un service

Créez un service dans l'espace de noms. Un service comprend un nom et des métadonnées facultatives associées au service. Il existe des restrictions concernant le format des noms de service:

• Les noms de service doivent être uniques dans un espace de noms.
• Les noms de service doivent respecter la convention d'attribution de noms pour les libellés DNS.

Console

1. Accédez à la page "Espaces de noms de répertoires du service" dans Google Cloud Console.
   Accéder à la page "Espaces de noms de répertoire de service"
2. Cliquez sur un espace de noms.
3. Cliquez sur Ajouter un service.
4. Saisissez un nom de service.
5. Facultatif Si vous souhaitez ajouter des métadonnées au service, procédez comme suit :
   1. Cliquez sur Métadonnées de service.
   2. Cliquez sur Ajouter des métadonnées.
   3. Ajoutez une clé et une valeur.
   4. Pour ajouter d'autres paires de métadonnées, cliquez de nouveau sur Ajouter des métadonnées.
6. Cliquez sur Create (Créer).

gcloud

Pour utiliser Service Directory sur la ligne de commande, commencez par installer la dernière version du SDK Cloud ou passer à la version la plus récente.

1. Créez un service dans un espace de noms.

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

   Remplacez l'élément suivant :

   • SERVICE: nom du service que vous créez.
   • NAMESPACE: nom que vous avez attribué à l'espace de noms contenant votre service.
   • REGION: région Google Cloud qui contient l'espace de noms.
   • KEY_1,VALUE_1,KEY_2, VALUE_2: chaîne et clé de valeur définies par paires.

2. (Facultatif): Définissez une stratégie IAM sur votre service. Cela attribue le rôle spécifié à l'utilisateur ou au groupe spécifié pour ce service et à tous les points de terminaison appartenant au service.

   gcloud service-directory services add-iam-policy-binding SERVICE \
   --member user:[e-mail] \
   --role ROLE \
   --namespace NAMESPACE \
   --location REGION
   

   Remplacez l'élément suivant :

   • SERVICE: par le nom que vous avez donné au service.
   • NAMESPACE: nom de l'espace de noms que vous avez créé.
   • ROLE: le rôle que vous accordez.
   • REGION: région Google Cloud qui contient l'espace de noms.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK C# Directory C#.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Go Directory Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Java de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js et installez le SDK Node.js Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, configurez un environnement de développement PHP et installez le SDK PHP de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Python du répertoire de service.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Ruby et installez le SDK Ruby de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Configurer un point de terminaison

Une fois le service enregistré, ajoutez des points de terminaison. Un point de terminaison est constitué d'un nom unique et des champs facultatifs de métadonnées d'adresse, de port et de clé/valeur. Si elle est spécifiée, elle doit être une adresse IPv4 ou IPv6 valide.

Console

1. Accédez à la page "Espaces de noms de répertoires du service" dans Google Cloud Console.
   Accéder à la page "Espaces de noms de répertoire de service"
2. Cliquez sur un espace de noms.
3. Cliquez sur un service.
4. Cliquez sur Ajouter un point de terminaison.
5. Indiquez un Nom de point de terminaison.
6. Saisissez une adresse IP IPv4 ou IPv6.
7. Saisissez un numéro de port.
8. Facultatif Si vous souhaitez ajouter des métadonnées au point de terminaison, procédez comme suit :
   1. Cliquez sur Métadonnées des points de terminaison.
   2. Cliquez sur Ajouter des métadonnées.
   3. Ajoutez une clé et une valeur.
   4. Pour ajouter d'autres paires de métadonnées, cliquez de nouveau sur Ajouter des métadonnées.
9. Cliquez sur Create (Créer).

gcloud

Pour utiliser Service Directory sur la ligne de commande, commencez par installer la dernière version du SDK Cloud ou effectuer une mise à niveau.

Une fois le service enregistré, ajoutez des points de terminaison.

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

Remplacez les valeurs suivantes :

• ENDPOINT et ENDPOINT2: noms des points de terminaison que vous créez dans votre service.
• IP_ADDRESS et IP_ADDRESS2: les adresses IPv6 et IPv4 des points de terminaison, respectivement.
• PORT_NUMBER et PORT_NUMBER2: ports sur lesquels les points de terminaison sont en cours d'exécution
• SERVICE: nom du service que vous créez.
• NAMESPACE: nom que vous avez attribué à l'espace de noms contenant votre service.
• REGION: région Google Cloud qui contient l'espace de noms.
• KEY_1,VALUE_1,KEY_2, VALUE_2: chaîne et clé de valeur définies par paires.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK C# du répertoire de services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Go Directory Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, configurez un environnement de développement Java et installez le SDK Java de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js et installez le SDK Node.js Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, configurez un environnement de développement PHP et installez le SDK PHP de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Python de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Ruby et installez le SDK Ruby de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Résoudre un service

L'Annuaire des services permet aux clients de résoudre les services à l'aide des protocoles DNS, HTTP et gRPC. La résolution du service renvoie toutes les propriétés du service, ainsi que tous les points de terminaison et toutes les métadonnées.

gcloud

Pour utiliser Service Directory sur la ligne de commande, commencez par installer la dernière version du SDK Cloud ou effectuer une mise à niveau.

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

Remplacez l'élément suivant :

• SERVICE: nom du service que vous créez.
• NAMESPACE: nom que vous avez attribué à l'espace de noms contenant votre service.
• REGION: région Google Cloud qui contient l'espace de noms.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK C# Directory C#.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Go Directory Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Java de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js et installez le SDK Node.js Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement PHP et installez le SDK PHP de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Python de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Ruby et installez le SDK Ruby de l'annuaire des services.

Afficher sur GitHub Commentaires

# 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

Supprimer des ressources

Supprimer un point de terminaison d'un service

Console

1. Accédez à la page "Espaces de noms de répertoires du service" dans Google Cloud Console.
   Accéder à la page "Espaces de noms de répertoire de service"
2. Cliquez sur l'espace de noms duquel vous souhaitez supprimer le point de terminaison.
3. Cliquez sur le service dont vous souhaitez supprimer le point de terminaison.
4. Cochez la case en regard du point de terminaison que vous souhaitez supprimer.
5. Cliquez sur Supprimer.
6. Dans la boîte de dialogue de confirmation, cliquez de nouveau sur Supprimer .

gcloud

Pour utiliser Service Directory sur la ligne de commande, commencez par installer la dernière version du SDK Cloud ou effectuer une mise à niveau.

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

Remplacez l'élément suivant :

• SERVICE: nom du service que vous créez.
• NAMESPACE: nom que vous avez attribué à l'espace de noms contenant votre service.
• REGION: région Google Cloud qui contient l'espace de noms.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK C# Directory C#.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Go Directory Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Java de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js et installez le SDK Node.js Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement PHP et installez le SDK PHP de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Python de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Ruby et installez le SDK Ruby de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Supprimer un service d'un espace de noms

Vous pouvez supprimer un service qui dispose de points de terminaison. Lorsqu'un service est supprimé, tous ses points de terminaison le sont également.

Vous pouvez supprimer un service dont la zone d'annuaire de services pointe vers celle-ci. Toute autre requête DNS pour ce service renvoie NXDOMAIN.

Console

1. Accédez à la page "Espaces de noms de répertoires du service" dans Google Cloud Console.
   Accéder à la page "Espaces de noms de répertoire de service"
2. Cliquez sur l'espace de noms duquel vous souhaitez supprimer le service.
3. Cochez la case à côté du service que vous souhaitez supprimer.
4. Cliquez sur Supprimer.
5. Cliquez à nouveau sur Supprimer dans la boîte de dialogue de confirmation.

gcloud

Pour utiliser Service Directory sur la ligne de commande, commencez par installer la dernière version du SDK Cloud ou effectuer une mise à niveau.

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

Remplacez l'élément suivant :

• SERVICE: nom du service que vous créez.
• NAMESPACE: nom que vous avez attribué à l'espace de noms contenant votre service.
• REGION: région Google Cloud qui contient l'espace de noms.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK C# Directory C#.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Go Directory Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Java de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js et installez le SDK Node.js Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement PHP et installez le SDK PHP de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Python de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, configurez un environnement de développement Ruby et installez le SDK Ruby de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Supprimer un espace de noms

Vous pouvez supprimer un espace de noms comportant des services et des points de terminaison. Lorsqu'un espace de noms est supprimé, tous ses services et points de terminaison le sont également.

Vous pouvez supprimer un espace de noms dont la zone d'annuaire de services pointe vers celle-ci. Toutes les autres requêtes DNS (à l'exception des requêtes SOA/NS pour l'origine de la zone) renvoient NXDOMAIN.

Console

1. Accédez à la page "Espaces de noms de répertoires du service" dans Google Cloud Console.
   Accéder à la page "Espaces de noms de répertoire de service"
2. Cochez la case en regard de l'espace de noms que vous souhaitez supprimer.
3. Cliquez sur Supprimer.
4. Dans la boîte de dialogue de confirmation, cliquez de nouveau sur Supprimer.

gcloud

Pour utiliser Service Directory sur la ligne de commande, commencez par installer la dernière version du SDK Cloud ou effectuer une mise à niveau.

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

Remplacez l'élément suivant :

• NAMESPACE: nom que vous avez attribué à l'espace de noms contenant votre service.
• REGION: région Google Cloud qui contient l'espace de noms.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C# et installez le SDK C# Directory C#.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Go et installez le SDK Go Directory Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Java de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js et installez le SDK Node.js Directory.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement PHP et installez le SDK PHP de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python et installez le SDK Python de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Pour exécuter ce code, commencez par configurer un environnement de développement Ruby et installez le SDK Ruby de l'annuaire des services.

Afficher sur GitHub Commentaires

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

Étape suivante

• Pour configurer une zone de répertoire de service afin de pouvoir interroger votre service à l'aide d'un DNS, consultez la section Zone de répertoire de service.
• Pour obtenir une présentation de l'annuaire des services, consultez la présentation de l'Annuaire des services.
• Pour trouver des solutions aux problèmes courants que vous pouvez rencontrer lors de l'utilisation de Service Directory, consultez la page Dépannage.