Les outils d'observabilité des microservices vous permettent d'instrumenter vos applications pour collecter et présenter des données de télémétrie dans Cloud Monitoring, Cloud Logging et Cloud Trace à partir de charges de travail gRPC déployées sur Google Cloud et ailleurs. L'observabilité des microservices fonctionne avec tout déploiement autorisé à accéder à Monitoring, Logging et Trace en activant l'API Microservices.
Dans ce tutoriel, vous allez apprendre à utiliser les fonctionnalités d'observabilité des microservices en créant une application gRPC simple sur Google Cloud à l'aide de Compute Engine. Vous apprendrez également à instrumenter votre application avec l'observabilité des microservices et à les afficher en direct sur Monitoring et Logging.
Objectifs
De manière générale, vous procédez comme suit :
En tant que développeur de service, vous pouvez :
- Créer une application gRPC avec le langage de votre choix (C++, Go ou Java).
- Activer votre application et contrôler le plug-in d'observabilité des microservices.
- Déployer l'application sur une VM Compute Engine.
En tant qu'opérateur de service, vous utilisez les données collectées de différentes manières :
- Afficher les traces sur Trace.
- Afficher les métriques dans le tableau de bord de surveillance appelé Microservices (gRPC) Monitoring.
- Afficher les métriques dans l'Explorateur de métriques.
- Inspecter les entrées de journal dans l'explorateur de journaux.
Coûts
Dans ce document, vous utilisez les composants facturables de Google Cloudsuivants :
Vous pouvez obtenir une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.
Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.
Avant de commencer
Console
- 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 sans frais pour exécuter, tester et déployer des charges de travail.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator role
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
Activez les API Compute Engine et Microservices.
Rôles requis pour activer les API
Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (
roles/serviceusage.serviceUsageAdmin), qui contient l'autorisationserviceusage.services.enable. Découvrez comment attribuer des rôles. -
Assurez-vous de disposer des rôles IAM "Créateur de compte de service" (
roles/iam.serviceAccountCreator) et "Administrateur IAM du projet" (roles/resourcemanager.projectIamAdmin). Découvrez comment attribuer des rôles. -
Dans la console Google Cloud , accédez à la page Créer un compte de service.
Accéder à la page "Créer un compte de service" - Sélectionnez votre projet.
-
Dans le champ Nom du compte de service, saisissez un nom. La console Google Cloud remplit le champ ID du compte de service en fonction de ce nom.
Dans le champ Description du compte de service, saisissez une description. Exemple :
Service account for quickstart. - Cliquez sur Créer et continuer.
-
Attribuez les rôles suivants au compte de service : Logging > Lecteur de journaux > Rédacteur de journaux, Monitoring > Éditeur Monitoring > Rédacteur de métriques, Trace > Administrateur Trace > Agent Trace.
Pour attribuer un rôle, trouvez la liste Sélectionner un rôle, puis sélectionnez le rôle.
Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
- Cliquez sur Continuer.
-
Dans le champ Rôle d'utilisateur du compte de service, saisissez l'identifiant du compte principal qui associera le compte de service à d'autres ressources, telles que des instances Compute Engine.
Il s'agit généralement de l'adresse e-mail d'un compte Google.
-
Cliquez sur OK pour terminer la création du compte de service.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator role
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
Activez les API Compute Engine et Microservices.
Rôles requis pour activer les API
Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (
roles/serviceusage.serviceUsageAdmin), qui contient l'autorisationserviceusage.services.enable. Découvrez comment attribuer des rôles. -
Assurez-vous de disposer des rôles IAM "Créateur de compte de service" (
roles/iam.serviceAccountCreator) et "Administrateur IAM du projet" (roles/resourcemanager.projectIamAdmin). Découvrez comment attribuer des rôles. -
Dans la console Google Cloud , accédez à la page Créer un compte de service.
Accéder à la page "Créer un compte de service" - Sélectionnez votre projet.
-
Dans le champ Nom du compte de service, saisissez un nom. La console Google Cloud remplit le champ ID du compte de service en fonction de ce nom.
Dans le champ Description du compte de service, saisissez une description. Exemple :
Service account for quickstart. - Cliquez sur Créer et continuer.
-
Attribuez les rôles suivants au compte de service : Logging > Lecteur de journaux > Rédacteur de journaux, Monitoring > Éditeur Monitoring > Rédacteur de métriques, Trace > Administrateur Trace > Agent Trace.
Pour attribuer un rôle, trouvez la liste Sélectionner un rôle, puis sélectionnez le rôle.
Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
- Cliquez sur Continuer.
-
Dans le champ Rôle d'utilisateur du compte de service, saisissez l'identifiant du compte principal qui associera le compte de service à d'autres ressources, telles que des instances Compute Engine.
Il s'agit généralement de l'adresse e-mail d'un compte Google.
-
Cliquez sur OK pour terminer la création du compte de service.
- Consultez la présentation de l'observabilité des microservices.
- Découvrez les deux variables d'environnement compatibles, décidez lesquelles utiliser et déterminez les valeurs requises par la variable d'environnement.
cli
- 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 sans frais pour exécuter, tester et déployer des charges de travail.
-
Installez la Google Cloud CLI.
-
Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.
-
Pour initialiser la gcloud CLI, exécutez la commande suivante :
gcloud init -
Créez ou sélectionnez un projet Google Cloud .
Rôles requis pour sélectionner ou créer un projet
- Sélectionnez un projet : la sélection d'un projet ne nécessite pas de rôle IAM spécifique. Vous pouvez sélectionner n'importe quel projet pour lequel un rôle vous a été attribué.
-
Créer un projet : pour créer un projet, vous devez disposer du rôle Créateur de projet (
roles/resourcemanager.projectCreator), qui contient l'autorisationresourcemanager.projects.create. Découvrez comment attribuer des rôles.
-
Créez un projet Google Cloud :
gcloud projects create PROJECT_ID
Remplacez
PROJECT_IDpar le nom du projet Google Cloud que vous créez. -
Sélectionnez le projet Google Cloud que vous avez créé :
gcloud config set project PROJECT_ID
Remplacez
PROJECT_IDpar le nom de votre projet Google Cloud .
-
Vérifiez que la facturation est activée pour votre projet Google Cloud .
Activez les API Compute Engine et Microservices :
Rôles requis pour activer les API
Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (
roles/serviceusage.serviceUsageAdmin), qui contient l'autorisationserviceusage.services.enable. Découvrez comment attribuer des rôles.gcloud services enable compute.googleapis.com
microservices.googleapis.com -
Configurez l'authentification :
-
Assurez-vous de disposer des rôles IAM "Créateur de compte de service" (
roles/iam.serviceAccountCreator) et "Administrateur IAM du projet" (roles/resourcemanager.projectIamAdmin). Découvrez comment attribuer des rôles. -
Créez le compte de service :
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
Remplacez
SERVICE_ACCOUNT_NAMEpar le nom que vous souhaitez donner au compte de service. -
Attribuez des rôles au compte de service. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants :
roles/logging.logWriter, roles/monitoring.metricWriter, roles/cloudtrace.agent:gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=ROLE
Remplacez les éléments suivants :
SERVICE_ACCOUNT_NAME: nom du compte de service.PROJECT_ID: ID du projet dans lequel vous avez créé le compte de service.ROLE: rôle à accorder
-
Attribuez le rôle requis au compte principal qui associera le compte de service à d'autres ressources.
gcloud iam service-accounts add-iam-policy-binding SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com --member="user:USER_EMAIL" --role=roles/iam.serviceAccountUser
Remplacez les éléments suivants :
SERVICE_ACCOUNT_NAME: nom du compte de service.PROJECT_ID: ID du projet dans lequel vous avez créé le compte de service.USER_EMAIL: adresse e-mail d'un compte Google
-
Assurez-vous de disposer des rôles IAM "Créateur de compte de service" (
-
Installez la Google Cloud CLI.
-
Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.
-
Pour initialiser la gcloud CLI, exécutez la commande suivante :
gcloud init -
Créez ou sélectionnez un projet Google Cloud .
Rôles requis pour sélectionner ou créer un projet
- Sélectionnez un projet : la sélection d'un projet ne nécessite pas de rôle IAM spécifique. Vous pouvez sélectionner n'importe quel projet pour lequel un rôle vous a été attribué.
-
Créer un projet : pour créer un projet, vous devez disposer du rôle Créateur de projet (
roles/resourcemanager.projectCreator), qui contient l'autorisationresourcemanager.projects.create. Découvrez comment attribuer des rôles.
-
Créez un projet Google Cloud :
gcloud projects create PROJECT_ID
Remplacez
PROJECT_IDpar le nom du projet Google Cloud que vous créez. -
Sélectionnez le projet Google Cloud que vous avez créé :
gcloud config set project PROJECT_ID
Remplacez
PROJECT_IDpar le nom de votre projet Google Cloud .
-
Vérifiez que la facturation est activée pour votre projet Google Cloud .
Activez les API Compute Engine et Microservices :
Rôles requis pour activer les API
Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (
roles/serviceusage.serviceUsageAdmin), qui contient l'autorisationserviceusage.services.enable. Découvrez comment attribuer des rôles.gcloud services enable compute.googleapis.com
microservices.googleapis.com -
Configurez l'authentification :
-
Assurez-vous de disposer des rôles IAM "Créateur de compte de service" (
roles/iam.serviceAccountCreator) et "Administrateur IAM du projet" (roles/resourcemanager.projectIamAdmin). Découvrez comment attribuer des rôles. -
Créez le compte de service :
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
Remplacez
SERVICE_ACCOUNT_NAMEpar le nom que vous souhaitez donner au compte de service. -
Attribuez des rôles au compte de service. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants :
roles/logging.logWriter, roles/monitoring.metricWriter, roles/cloudtrace.agent:gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=ROLE
Remplacez les éléments suivants :
SERVICE_ACCOUNT_NAME: nom du compte de service.PROJECT_ID: ID du projet dans lequel vous avez créé le compte de service.ROLE: rôle à accorder
-
Attribuez le rôle requis au compte principal qui associera le compte de service à d'autres ressources.
gcloud iam service-accounts add-iam-policy-binding SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com --member="user:USER_EMAIL" --role=roles/iam.serviceAccountUser
Remplacez les éléments suivants :
SERVICE_ACCOUNT_NAME: nom du compte de service.PROJECT_ID: ID du projet dans lequel vous avez créé le compte de service.USER_EMAIL: adresse e-mail d'un compte Google
-
Assurez-vous de disposer des rôles IAM "Créateur de compte de service" (
- Consultez la présentation de l'observabilité des microservices.
- Découvrez les deux variables d'environnement compatibles, décidez lesquelles utiliser et déterminez les valeurs requises par la variable d'environnement.
Créer une VM Compute Engine et s'y connecter
Suivez ces instructions pour créer une instance de VM Compute Engine et vous y connecter. Sur la VM, vous déployez votre application, puis vous l'instrumentez avec l'observabilité des microservices.
Créez une instance de VM :
gcloud compute instances create grpc-observability-vm \ --image-family=debian-11 \ --image-project=debian-cloud \ --service-account=SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com
Connectez-vous à l'instance de VM :
gcloud compute ssh --project=$PROJECT_ID grpc-observability-vm
Déployer votre application sur la VM Compute Engine
Vous pouvez choisir de déployer l'application de votre choix sur la VM Compute Engine que vous avez créée à l'étape précédente, puis ignorer cette étape, ou vous pouvez utiliser un exemple pour continuer à suivre les instructions dans le langage de votre choix.
C++
Une fois connecté à l'instance de VM, exécutez la commande suivante.
sudo apt-get update -y sudo apt-get install -y git build-essential clang git clone -b v1.54.0 https://github.com/grpc/grpc.git --depth=1
Go
Assurez-vous que Go est installé.
sudo apt-get install -y git sudo apt install wget wget https://go.dev/dl/go1.20.2.linux-amd64.tar.gz sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf \ go1.20.2.linux-amd64.tar.gz export PATH=$PATH:/usr/local/go/bin
Clonez les exemples
gRPC-Go.git clone https://github.com/grpc/grpc-go.git cd grpc-go/ git checkout -b run-observability-example 875c97a94dca8093bf01ff2fef490fbdd576373d
Java
Une fois que vous êtes connecté à l'instance de VM, assurez-vous que Java 8 ou une version ultérieure est installée.
sudo apt update sudo apt upgrade sudo apt install git sudo apt-get install -y openjdk-11-jdk-headless
Clonez le dépôt
grpc-java.export EXAMPLES_VERSION=v1.54.1 git clone -b $EXAMPLES_VERSION --single-branch --depth=1 \ https://github.com/grpc/grpc-java.git
Créer le fichier de configuration gRPC Google Cloud Observability
Vous avez besoin d'un fichier de configuration gRPC Google Cloud Observability distinct pour activer l'observabilité des microservices pour le serveur et le client. L'emplacement de ce fichier sera exporté en tant que GRPC_GCP_OBSERVABILITY_CONFIG_FILE lors des prochaines étapes. Utilisez les instructions suivantes pour configurer les différents paramètres dans le fichier de configuration.
Exemple de fichier GRPC_GCP_OBSERVABILITY_CONFIG_FILE
{
"project_id": "your-project-here",
"cloud_logging": {
"client_rpc_events": [
{
"methods": ["google.pubsub.v1.Subscriber/Acknowledge", "google.pubsub.v1.Publisher/CreateTopic"],
"exclude": true,
},
{
"methods": ["google.pubsub.v1.Subscriber/*", "google.pubsub.v1.Publisher/*"],
"max_metadata_bytes": 4096,
"max_message_bytes": 4096,
}],
"server_rpc_events": [{
"methods": ["*"],
"max_metadata_bytes": 4096,
"max_message_bytes": 4096
}],
},
"cloud_monitoring": {},
"cloud_trace": {
"sampling_rate": 0.5,
}
"labels": {
"SOURCE_VERSION": "J2e1Cf",
"SERVICE_NAME": "payment-service-1Cf",
"DATA_CENTER": "us-west1-a"
}
}
Les sections suivantes contiennent des instructions concernant l'activation de la collecte des données dans votre configuration pour les composants individuels. Si vous avez utilisé l'exemple gRPC dans ce tutoriel, vous pouvez utiliser cette configuration telle quelle (après avoir mis à jour your-project-here) ou l'utiliser comme modèle pour votre application ainsi qu'un exemple montrant les informations de configuration dans une variable d'environnement.
Activer les métriques
Pour activer les métriques, ajoutez l'objet cloud_monitoring à la configuration et définissez sa valeur sur {}.
Pour en savoir plus sur les métriques, consultez la page Définitions des métriques.
Activer le traçage
Pour activer le traçage, procédez comme suit :
- Ajoutez l'objet
cloud_traceà la configuration. - Définissez
cloud_trace.sampling_ratesur0.5pour tracer de manière aléatoire 50 % des RPC.
Si vous envisagez d'activer le traçage sur plusieurs services, assurez-vous que les services sont compatibles avec la propagation du contexte de trace reçu de l'amont (ou démarré par lui-même) vers l'aval.
Pour en savoir plus sur le traçage, consultez la page Définitions de trace.
Activer la journalisation
Pour activer la journalisation, procédez comme suit :
- Ajoutez l'objet
cloud_loggingà la configuration. - Ajoutez un modèle à
client_rpc_eventsou àserver_rpc_events, ou aux deux, en spécifiant l'ensemble de services ou de méthodes pour lesquels vous souhaitez générer une journalisation des événements au niveau du transport, ainsi que le nombre d'octets à consigner pour les en-têtes et les messages.
Pour en savoir plus sur la journalisation, consultez la section Définitions des enregistrements de journal.
Instrumenter vos applications pour le plug-in d'observabilité
Pour instrumenter vos applications afin qu'elles puissent utiliser le plug-in d'observabilité des microservices, suivez les instructions correspondant au langage de votre choix.
C++
Vous pouvez utiliser C++ avec l'observabilité des microservices à partir de la version gRPC de C++ v1.54. L'exemple de dépôt se trouve dans GitHub.
La compatibilité de l'observabilité n'est assurée que via le système de compilation Bazel. Ajoutez la cible
grpcpp_gcp_observabilityen tant que dépendance.L'activation de l'observabilité des microservices nécessite une dépendance supplémentaire (un module d'observabilité) et les modifications de code suivantes sur les clients et serveurs gRPC existants, ou les deux :
#include <grpcpp/ext/gcp_observability.h> int main(int argc, char** argv) { auto observability = grpc::GcpObservability::Init(); assert(observability.ok()); … // Observability data flushed when object goes out of scope }Avant toute opération gRPC, y compris pour créer un canal, un serveur ou des identifiants, appelez la commande suivante :
grpc::GcpObservability::Init();Cette commande renvoie
absl::StatusOr<GcpObservability>, qui doit être enregistré. L'état permet de déterminer si l'observabilité a bien été initialisée. L'objetGcpObservabilityassocié contrôle la durée de vie de l'observabilité, en plus de fermer et de vider automatiquement les données d'observabilité lorsqu'elles sont hors du champ d'application.
Go
- Les plug-ins d'observabilité des microservices sont compatibles avec les versions de Go gRPC
v1.54.0et ultérieures. L'exemple de dépôt se trouve dans GitHub.
Avec le module Go, l'activation de l'observabilité des microservices nécessite un module d'observabilité et le code suivant :
import "google.golang.org/grpc/gcp/observability"
func main() {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
if err := observability.Start(ctx); err != nil {
log.Warning("Unable to start gRPC observability:", err)
}
defer observability.End()
…
}
L'appel observability.Start analyse la configuration à partir de variables d'environnement, crée des exportateurs en conséquence et injecte une logique de collecte dans les connexions client et les serveurs créés après l'appel. L'appel observability.End différé nettoie les ressources et garantit que les données mises en mémoire tampon sont vidées avant la fermeture de l'application.
Une fois le code de l'application mis à jour, exécutez la commande suivante pour mettre à jour le fichier go.mod.
go mod tidy
Java
Pour utiliser l'observabilité des microservices avec des applications Java, modifiez votre compilation afin d'inclure l'artefact grpc-gcp-observability. Utilisez gRPC version 1.54.1 ou ultérieure.
Dans les extraits de code des sections de Gradle et de l'outil de compilation Maven, grpcVersion est défini sur la valeur 1.54.1.
L'exemple de dépôt se trouve dans GitHub.
- Pour réussir l'observabilité de vos applications Java pour l'observabilité des microservices, ajoutez le code suivant à
main().
...
import io.grpc.gcp.observability.GcpObservability;
...
// Main application class
...
public static void main(String[] args) {
...
// call GcpObservability.grpcInit() to initialize & get observability
GcpObservability observability = GcpObservability.grpcInit();
...
// call close() on the observability instance to shutdown observability
observability.close();
...
}
Notez que vous devez appeler GcpObservability.grpcInit() avant la création des canaux ou serveurs gRPC. La fonction GcpObservability.grpcInit() lit la configuration d'observabilité des microservices et l'utilise pour configurer les intercepteurs et les traceurs globaux requis pour la journalisation, les métriques et les fonctionnalités de traces dans chaque canal et serveur créés. GcpObservability.grpcInit() est sécurisé et doit être appelé exactement une fois. Cela renvoie une instance de GcpObservability que vous devez enregistrer pour appeler close() ultérieurement.
GcpObservability.close() libère des ressources. Les canaux ou serveurs créés par la suite n'effectuent aucune journalisation.
GcpObservability met en œuvre java.lang.AutoCloseable, qui est fermé automatiquement si vous utilisez try-with-resource comme suit :
...
import io.grpc.gcp.observability.GcpObservability;
...
// Main application class
...
public static void main(String[] args) {
...
// call GcpObservability.grpcInit() to initialize & get observability
try (GcpObservability observability = GcpObservability.grpcInit()) {
...
} // observability.close() called implicitly
...
}
Utiliser l'outil de création Gradle
Si vous utilisez l'outil de création Gradle, incluez les éléments suivants :
def grpcVersion = '1.54.1'
...
dependencies {
...
implementation "io.grpc:grpc-gcp-observability:${grpcVersion}"
...
}
Utiliser l'outil de création Maven (pom.xml
Si vous utilisez l'outil de création Maven, incluez les éléments suivants :
<properties>
...
<grpc.version>1.54.1</grpc.version>
...
</properties>
...
<dependencies>
...
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-gcp-observability</artifactId>
<version>${grpc.version}</version>
</dependency>
...
</dependencies>
Exécuter votre application
Suivez les instructions de cette section uniquement si vous avez utilisé l'exemple gRPC pour le tutoriel. Vous pouvez modifier la commande run pour cibler le binaire de votre application.
Exécuter le serveur
C++
- Créez une session SSH dans la VM.
Exportez les variables d'environnement. Suivez les étapes définies ci-dessus pour créer le fichier
server_config.json.export GOOGLE_CLOUD_PROJECT=$PROJECT_ID export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/server_config.json"Exécutez l'application de serveur
shell cd grpc tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_server.
Go
- Créez une session SSH dans la VM.
Exportez les variables d'environnement. Suivez les étapes définies ci-dessus pour créer le fichier
server_config.json.export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./server/serverConfig.jsonExécutez l'application de serveur
shell go run ./server/main.go.
Java
- Dans le répertoire d'exemples, ouvrez le fichier README et suivez les instructions qu'il contient.
- Lorsque les instructions vous indiquent d'ouvrir une autre fenêtre de terminal, exécutez la commande suivante :
shell gcloud compute ssh --project=$PROJECT_ID grpc-observability-vm
Exécuter le client
C++
- Créez une autre session SSH dans la VM.
Exportez les variables d'environnement. Suivez les étapes définies ci-dessus pour créer le fichier
client_config.json.export GOOGLE_CLOUD_PROJECT=$PROJECT_ID export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/client_config.json"Exécutez l'application cliente.
cd grpc tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_client
Go
- Créez une autre session SSH dans la VM.
- Exportez les variables d'environnement. Suivez les étapes définies ci-dessus pour créer le fichier
client_config.json.shell export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./client/clientConfig.json Exécutez l'application cliente.
cd grpc-go/examples/features/observability go run ./client/main.go
Java
- Dans le répertoire d'exemples, ouvrez le fichier README et suivez les instructions qu'il contient.
- Lorsque les instructions vous indiquent d'ouvrir une autre fenêtre de terminal, exécutez la commande suivante :
shell gcloud compute ssh --project=$PROJECT_ID grpc-observability-vm
Effectuer un nettoyage
Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.
Supprimer le projet
Supprimer un projet Google Cloud :
gcloud projects delete PROJECT_ID
Supprimer des ressources individuelles
-
Supprimez l'instance :
gcloud compute instances delete INSTANCE_NAME
Étapes suivantes
- Pour en savoir plus sur les données de configuration, les définitions de traces, les définitions de métriques et les définitions de journaux, consultez la documentation de référence sur l'observabilité des microservices.
- Pour en savoir plus sur l'affichage des journaux, des traces et des métriques, consultez la section Afficher les traces, les métriques et les entrées de journal.