Ce document contient les informations dont vous avez besoin pour configurer le plug-in d'observabilité des microservices, instrumenter vos applications gRPC et obtenir des informations à partir de Cloud Monitoring, Cloud Logging et Cloud Trace.
Avant de commencer
L'observabilité des microservices fonctionne avec tout déploiement autorisé à accéder à Cloud Monitoring, Cloud Logging et Cloud Trace en activant l'API Microservices. Ce guide fournit un exemple de configuration de l'observabilité des microservices à l'aide d'un exemple Compute Engine.
En règle générale, vous procédez comme suit :
- En tant que développeur de services, vous activez et contrôlez le plug-in d'observabilité des microservices.
- En tant qu'opérateur de service, vous utilisez les données collectées de différentes manières.
Les dépôts gRPC (C++, Go et Java) incluent des exemples pour illustrer l'observabilité des microservices.
Avant de configurer l'observabilité, effectuez les tâches suivantes :
- Consultez la présentation de l'observabilité des microservices.
- Assurez-vous de disposer d'un projet ou créez-en un.
- Assurez-vous de disposer d'un compte de service ou créez-en un.
- Découvrez les deux variables d'environnement compatibles, décidez lesquelles utiliser et déterminez les valeurs requises par la variable d'environnement.
- Activez l'API Microservices.
Choisir une variable d'environnement de configuration
Lorsque vous activez le plug-in d'observabilité des microservices, décrit dans la section Instrumenter vos applications pour le plug-in d'observabilité, vous devez fournir des informations de configuration à l'aide d'une variable d'environnement. Par défaut, aucune fonctionnalité d'observabilité n'est activée. Vous définissez la variable d'environnement de la VM ou du conteneur dans lequel l'application ou la charge de travail gRPC est en cours d'exécution.
Voici les variables d'environnement :
GRPC_GCP_OBSERVABILITY_CONFIG_FILE: valeur correspondant à un chemin d'accès pointant vers un fichier de configuration encodé au format JSON.GRPC_GCP_OBSERVABILITY_CONFIG: valeur du corps de la configuration encodée au format JSON.
Si les deux variables d'environnement sont définies, GRPC_GCP_OBSERVABILITY_CONFIG_FILE est prioritaire sur GRPC_GCP_OBSERVABILITY_CONFIG.
Pour appliquer la configuration, vous devez redémarrer l'application gRPC. Vous ne pouvez pas définir ni afficher les valeurs des variables d'environnement dans la console Google Cloud.
Dans la configuration, vous pouvez définir un projet de destination dans lequel les données de journalisation, de traçage et de métriques sont importées. Vous définissez l'ID du projet dans le champ project_id.
Si ce champ est laissé vide, le plug-in d'observabilité remplit automatiquement la valeur de l'ID de projet en fonction des identifiants par défaut de l'application.
Si les identifiants par défaut de l'application ne peuvent pas être identifiés et que le champ
project_idest vide, la méthodeINIT/STARTgénère ou renvoie une erreur à votre application. L'application doit ensuite gérer l'erreur.
Utilisez les informations de la section Données de configuration pour définir les valeurs de la variable d'environnement que vous choisissez.
Activer l'API Microservices
Vous pouvez utiliser Google Cloud CLI ou la console Google Cloud pour activer l'API Microservices dans vos projets. L'activation de l'API Microservice active automatiquement l'API Cloud Logging, l'API Cloud Monitoring et l'API Cloud Trace.
Pour activer l'API, utilisez la commande suivante :
gcloud services enable microservices.googleapis.com
Définir les autorisations du compte de service
Si vous utilisez un compte de service autre que celui par défaut, accordez les autorisations requises pour ce compte. Définissez les valeurs suivantes :
- PROJECT_ID : remplacez par l'ID de votre projet.
- SERVICE_ACCOUNT_NAME : remplacez le nom du compte de service de votre projet.
gcloud projects add-iam-policy-binding PROJECT_ID \ --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \ --role=roles/logging.logWriter
gcloud projects add-iam-policy-binding PROJECT_ID> \ --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \ --role=roles/monitoring.metricWriter
gcloud projects add-iam-policy-binding PROJECT_ID \ --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \ --role=roles/cloudtrace.agent
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 suivantes pour C++, Java et Go.
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 sur GitHub.
Modifications de la compilation
La compatibilité de l'observabilité n'est assurée que via le système de compilation Bazel. Ajoutez la cible grpcpp_gcp_observability en tant que dépendance.
Modifications de code requises
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'objet GcpObservability associé 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 gRPC de Go v1.54.0 et 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.
Modifications de code Java requises
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 la fonctionnalité 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>
Activer la collecte des métriques, du traçage et des données de journalisation
Les sections suivantes contiennent des instructions concernant l'activation de la collecte des données dans votre configuration, 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
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 activer le traçage, procédez comme suit :
- Ajoutez l'objet
cloud_traceà la configuration. - Définissez la valeur
cloud_trace.sampling_ratesur une probabilité que vous souhaitez que votre application observe pour démarrer de nouvelles traces.- Par exemple,
1.0signifie tracer chaque RPC. 0.0signifie ne démarrer aucune nouvelle trace.0.5signifie que 50 % des RPC sont tracés de manière aléatoire.
- Par exemple,
Si une décision d'échantillonnage positive est prise en amont, vos services importent des délais, quel que soit le paramètre de taux d'échantillonnage.
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.
Exemple de variable d'environnement
L'exemple suivant définit les variables d'observabilité dans la variable d'environnement GRPC_GCP_OBSERVABILITY_CONFIG :
export GRPC_GCP_OBSERVABILITY_CONFIG='{
"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": 1.00
},
"labels": {
"SOURCE_VERSION": "J2e1Cf",
"SERVICE_NAME": "payment-service-1Cf",
"DATA_CENTER": "us-west1-a"
}
}'
Créer l'exemple d'observabilité
Suivez ces instructions pour créer une instance de VM Compute Engine et vous y connecter, puis configurer l'exemple d'observabilité.
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
Passez aux instructions pour Java, C++ ou Go, selon le langage de vos applications gRPC.
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
Accédez au répertoire des exemples.
cd grpc-java/examples/example-gcp-observability
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 :
gcloud compute ssh --project=PROJECT_ID grpc-observability-vm
C++
Une fois que vous êtes connecté à l'instance de VM, exécutez un binaire du serveur
hello-worlddans une fenêtre de terminal.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 cd grpc export GOOGLE_CLOUD_PROJECT=PROJECT_ID export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/server_config.json" tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_server
Dans une autre fenêtre de terminal, connectez-vous à nouveau à la VM via SSH, puis exécutez les commandes suivantes, qui exécutent le binaire du client
hello-world.cd grpc export GOOGLE_CLOUD_PROJECT=PROJECT_ID export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/client_config.json" tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_client
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
Accédez au clone du répertoire
gRPC-Go:cd examples/features/observability
Exécutez le serveur.
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./server/serverConfig.json go run ./server/main.go
Dans une fenêtre de terminal distincte, exécutez les commandes suivantes.
export PATH=$PATH:/usr/local/go/bin cd grpc-go/examples/features/observability export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./client/clientConfig.json go run ./client/main.go
Afficher les traces, les métriques et les entrées de journal
Suivez les instructions de cette section pour afficher les traces, les métriques et les entrées de journal.
Afficher les traces sur Cloud Trace
Une fois que vous avez configuré les exemples ou instrumenté vos charges de travail, vous devez voir que les traces générées par vos clients gRPC et les serveurs gRPC dans la console Google Cloud affichées en tant que traces récentes.
Afficher les journaux pour les traces
Si vous activez à la fois la journalisation et le traçage, vous pouvez afficher les entrées de journal pour les traces avec le graphique en cascade de Cloud Trace ou dans l'explorateur de journaux.
Afficher les métriques sur le tableau de bord
L'observabilité des microservices fournit un tableau de bord de surveillance appelé Microservices (gRPC) Monitoring pour les métriques définies dans les définitions des métriques. Le tableau de bord ne s'affiche dans la console Google Cloud que lorsque l'API Microservices est activée. La console Google Cloud appelle l'API Service Usage pour vérifier si l'API Microservices est activée dans un projet. L'utilisateur doit disposer de l'autorisation serviceusage.services.list pour afficher le tableau de bord.
Le tableau de bord Microservices (gRPC) Monitoring est un tableau de bord Google Cloud que vous ne pouvez pas modifier directement. Pour personnaliser le tableau de bord, vous devez le copier dans un tableau de bord personnalisé. Vous pouvez ensuite mettre à jour le tableau de bord personnalisé, par exemple en ajoutant, en supprimant ou en réorganisant les graphiques.
Afficher les métriques dans l'Explorateur de métriques
Une fois que vous avez configuré l'exemple gRPC ou instrumenté votre charge de travail, vous devez voir les métriques générées par vos clients gRPC et les serveurs gRPC dans la console Google Cloud.
Pour afficher et représenter les métriques sous forme de graphique, suivez les instructions de la section Sélectionner des métriques lors de l'utilisation de l'explorateur de métriques.
Inspecter les entrées de journal dans l'explorateur de journaux
La requête suggérée est une fonctionnalité Cloud Logging dans laquelle Google Cloud suggère un ensemble de requêtes en fonction des journaux ingérés. Vous pouvez cliquer sur les filtres préparés et les utiliser.
Une fois que les entrées de journal correspondant aux requêtes suggérées apparaissent dans Cloud Logging, vous pouvez voir les nouvelles requêtes suggérées dans environ six minutes. Dans la plupart des cas, vous voyez plus rapidement de nouvelles requêtes suggérées. Si des entrées de journal correspondent à une suggestion des 15 dernières minutes, toutes les requêtes suggérées continuent d'être affichées. Ils continuent d'apparaître en tant que suggestion tant qu'aucune entrée de journal correspondante n'a été trouvée au cours des 15 dernières minutes.
Vous pouvez créer des requêtes personnalisées. Consultez le guide sur le langage de requête Logging pour obtenir des instructions. Par exemple, dans le volet "Requête" de l'explorateur de journaux, vous pouvez essayer d'afficher tous les journaux de débogage gRPC avec le code suivant :
log_id("microservices.googleapis.com/observability/grpc")
Vous pouvez utiliser tous les champs de l'enregistrement de journal gRPC pour effectuer le filtrage. Voici un exemple d'entrée de journal :
{
"insertId": "17kh8vafzuruci",
"jsonPayload": {
"authority": "10.84.1.15:50051",
"sequenceId": "6",
"serviceName": "helloworld.Greeter",
"peer": {
"ipPort": 50051,
"address": "10.84.1.10",
"type": "IPV4"
},
"callId": "d9577780-c608-4bff-9e12-4d9cdea6b298",
"type": "SERVER_TRAILER",
"methodName": "SayHello",
"payload": {},
"logger": "CLIENT"
},
"resource": {
"type": "k8s_container",
"labels": {
"pod_name": "grpc-client-deployment-155-6967959544-x8ndr",
"container_name": "grpc-client-container-155",
"cluster_name": "o11y-cluster",
"namespace_name": "grpc-client-namespace-155",
"location": "us-west1-b",
"project_id": "grpc-greeter"
}
},
"timestamp": "2023-04-05T23:33:41.718523Z",
"severity": "DEBUG",
"labels": {
"environment": "example-client"
},
"logName": "projects/grpc-greeter/logs/microservices.googleapis.com%2Fobservability%2Fgrpc",
"receiveTimestamp": "2023-04-05T23:33:42.712682457Z"
}
Requêtes suggérées
L'observabilité des microservices fournit les suggestions de requêtes suivantes à Cloud Logging :
Enregistrements de journaux d'en-têtes ou de suivi pour gRPC
Cette requête fournit une vue de base des RPC, générant des informations de pairs et des résultats RPC.
log_id("microservices.googleapis.com/observability/grpc") AND
jsonPayload.type=("CLIENT_HEADER" OR "SERVER_TRAILER")
Appels gRPC ayant échoué
Cette requête recherche les RPC qui se terminent par un état non OK.
log_id("microservices.googleapis.com/observability/grpc") AND
jsonPayload.type="SERVER_TRAILER" AND
jsonPayload.payload.statusCode!="OK"
Enregistrements de journaux pour les appels gRPC annulés ou dont le délai est dépassé
Une annulation gRPC excessive ou un dépassement de délai peut fournir des informations utiles sur la perte de performances ou le comportement inattendu de l'application.
log_id("microservices.googleapis.com/observability/grpc") AND
((jsonPayload.type="SERVER_TRAILER" AND jsonPayload.payload.statusCode=("CANCELLED" OR "DEADLINE_EXCEEDED")) OR (jsonPayload.type="CANCEL"))
Utiliser les journaux et le traçage pour résoudre les problèmes
Si un événement RPC indique un comportement incorrect, vous pouvez trouver callid dans l'événement. Utilisez la requête suivante pour afficher tous les événements qui se sont produits dans un seul RPC, qu'il s'agisse d'un RPC unaire ou de streaming. L'entrée de journal précédente est utilisée comme exemple :
log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.callid="a358c7b80-3548-4bc8-a33f-b93ba1514904"
Pour déterminer l'étendue du problème, vous pouvez trouver tous les événements RPC pour la même méthode ou le même emplacement. La requête suivante affiche tous les journaux de débogage liés à une méthode RPC spécifique, en utilisant le service Greeter comme exemple :
log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.serviceName="helloworld.Greeter"
jsonPayload.methodName="SayHello"
Pour vérifier les RPC ayant échoué d'un code d'état spécifique, vous pouvez ajouter le code d'état en tant que l'une des conditions de filtrage. La requête suivante affiche les événements de suivi qui se terminent par un état non OK :
log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.payload.statusCode!="OK"
Options d'observabilité
L'observabilité des microservices inclut les fonctionnalités facultatives suivantes.
Définir des étiquettes personnalisées
Vous pouvez définir des étiquettes personnalisées, qui ajoutent des informations fournies par l'utilisateur aux données d'observabilité. Les étiquettes personnalisées sont constituées de paires clé/valeur. Chaque paire clé/valeur est associée au traçage de données en tant qu'étiquettes de délais, aux données de métriques en tant que tags de métriques et aux données de journalisation en tant qu'étiquettes d'entrées de journal.
Les étiquettes personnalisées sont définies dans la configuration avec une liste de paires clé/valeur dans le champ labels. Toutes les clés et valeurs des étiquettes personnalisées sont de type STRING. La mise en œuvre lit la configuration et crée une étiquette distincte pour chaque paire clé/valeur, puis associe les étiquettes aux données d'observabilité :
Par exemple, voici une définition d'étiquette :
"labels": {
"DATACENTER": "SAN_JOSE_DC",
"APP_ID": "24512"
}
Chaque entrée de journal possède les étiquettes supplémentaires suivantes :
{
"DATACENTER" : "SAN_JOSE_DC"
"APP_ID" : "24512"
}
Activer la journalisation de la charge utile
Vous activez la journalisation de la charge utile à l'aide des variables d'environnement que vous fournissez à la charge de travail. Pour activer la journalisation de la charge utile pour les messages et les en-têtes HelloWorld, mettez à jour la valeur des fichiers de configuration gcp_observability_server_config.json, gcp_observability_client_config.json ou les deux dans les exemples gRPC comme suit :
{
"cloud_monitoring":{
},
"cloud_trace":{
"sampling_rate":1.0
},
"cloud_logging":{
"client_rpc_events":[
{
"methods":[
"helloworld.Greeter/*"
],
"max_metadata_bytes":4096,
"max_message_bytes":4096
}
],
"server_rpc_events":[
{
"methods":[
"helloworld.Greeter/*"
],
"max_metadata_bytes":4096,
"max_message_bytes":4096
}
]
}
}
Configurer l'observabilité entre projets
Vous pouvez définir explicitement le projet de destination à l'aide de la configuration définie dans la variable d'environnement GRPC_GCP_OBSERVABILITY_CONFIG. Pour l'observabilité entre projets, vous devez également définir les autorisations de compte de service appropriées.
En supposant que l'ID du projet de destination est core-platform-stats, vous pouvez configurer l'observabilité entre projets à l'aide de l'exemple de configuration suivant :
{
"project_id":"core-platform-stats",
"cloud_monitoring":{
},
"cloud_trace":{
"sampling_rate":1.0
},
"cloud_logging":{
"client_rpc_events":[
{
"methods":[
"helloworld.Greeter/*"
]
}
],
"server_rpc_events":[
{
"methods":[
"helloworld.Greeter/*"
]
}
]
}
}
Estimer le volume des journaux
Cette section vous fournit des informations que vous pouvez utiliser pour estimer le volume d'ingestion de journaux. Vous pouvez obtenir une estimation avant de vous abonner aux événements RPC de vos services.
| Élément | Detail |
|---|---|
| Événements générés pour un appel unaire OK | 6 événements Un appel RPC unaire génère six événements pour le client ou le serveur :
|
| Taille moyenne de l'entrée de journal | 500 octets par défaut Une entrée de journal correspond à un événement RPC, qui inclut les informations de débogage détaillées de cet événement, les étiquettes de ressource et les étiquettes personnalisées. |
| Taille de la journalisation de la charge utile | 0 par défaut, peut être configuré La taille maximale de la charge utile est configurable dans la configuration d'observabilité. Par défaut, aucune charge utile n'est journalisée. |
| Taille des étiquettes personnalisées | 0 par défaut peut être configuré Les étiquettes personnalisées sont fournies à l'application à l'aide de variables d'environnement. Si vous ne spécifiez aucun tag, il n'y aura pas d'étiquettes personnalisées. |
Taille totale d'estimation de journal et de formule d'ingestion de journal :
Monthly Log Ingestion = QPS * 6 * (500B + Payload Logging Size + Custom Labels Size) * 2592000
Par exemple, si le nombre de RPS d'une méthode d'appel unaire est de 1 et qu'aucune fonctionnalité supplémentaire n'est activée, la taille estimée des journaux d'ingestion est d'environ 7,24 Gio.
É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.