Gérer les tests de disponibilité

Ce document explique comment gérer vos tests de disponibilité à l'aide du la console Google Cloud, la Google Cloud CLI, l'API Cloud Monitoring et le client bibliothèques.

Répertorier tous les tests de disponibilité

Console

  1. Dans la console Google Cloud, accédez à la page  Tests de disponibilité:

    Accéder à la page Tests de disponibilité

    Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.

    L'exemple suivant montre une page Tests de disponibilité :

    Exemple de vue d'ensemble des tests de disponibilité avec des filtres.

  2. (Facultatif) Pour limiter les tests de disponibilité répertoriés, ajoutez des filtres.

    Chaque filtre est composé d'un nom et d'une valeur. Vous pouvez définir la valeur comme étant une correspondance exacte ou une correspondance partielle d'un nom de tests de disponibilité. Les correspondances ne sont pas sensibles à la casse. Par exemple, pour répertorier tous les tests de disponibilité dont le nom contient default, procédez comme suit :

    • Cliquez sur Filter table (Filtrer le tableau), puis sélectionnez Display name (Nom à afficher).
    • Saisissez default, puis appuyez sur la touche retour.

    Si vous avez plusieurs filtres, ils sont automatiquement reliés par un opérateur logique AND, sauf si vous insérez un filtre OR. L'exemple précédent utilise le filtre OR de sorte qu'un test de disponibilité soit répertorié si son nom correspond à default ou Testing check.

gcloud

Pour répertorier vos tests de disponibilité et vos surveillances synthétiques, exécutez la commande suivante : le gcloud monitoring uptime list-configs commande:

gcloud monitoring uptime list-configs

Les données renvoyées incluent les éléments suivants:

  • Nom et nom à afficher.
  • Vérifier l'identifiant
  • Ressource surveillée.
  • Période entre les vérifications.

Vous pouvez configurer la commande Google Cloud CLI pour filtrer et trier les résultats.

API

Pour répertorier les tests de disponibilité et la surveillance synthétique, appelez la méthode projects.uptimeCheckConfigs.list . Spécifiez les paramètres suivants :

  • parent : projet dont vous souhaitez répertorier les tests de disponibilité. Il a le format suivant :

    projects/PROJECT_ID

Pour obtenir un test de disponibilité spécifique, appelez la méthode projects.uptimeCheckConfigs.get. Spécifiez le paramètre suivant :

C#

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

public static object ListUptimeCheckConfigs(string projectId)
{
    var client = UptimeCheckServiceClient.Create();
    var configs = client.ListUptimeCheckConfigs(new ProjectName(projectId));
    foreach (UptimeCheckConfig config in configs)
    {
        Console.WriteLine(config.Name);
    }
    return 0;
}

Java

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

private static void listUptimeChecks(String projectId) throws IOException {
  ListUptimeCheckConfigsRequest request =
      ListUptimeCheckConfigsRequest.newBuilder().setParent(ProjectName.format(projectId)).build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    ListUptimeCheckConfigsPagedResponse response = client.listUptimeCheckConfigs(request);
    for (UptimeCheckConfig config : response.iterateAll()) {
      System.out.println(config.getDisplayName());
    }
  } catch (Exception e) {
    usage("Exception listing uptime checks: " + e.toString());
    throw e;
  }
}

Go

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


// list is an example of listing the uptime checks in projectID.
func list(w io.Writer, projectID string) error {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return fmt.Errorf("NewUptimeCheckClient: %w", err)
	}
	defer client.Close()
	req := &monitoringpb.ListUptimeCheckConfigsRequest{
		Parent: "projects/" + projectID,
	}
	it := client.ListUptimeCheckConfigs(ctx, req)
	for {
		config, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListUptimeCheckConfigs: %w", err)
		}
		fmt.Fprintln(w, config)
	}
	fmt.Fprintln(w, "Done listing uptime checks")
	return nil
}

Node.js

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';

const request = {
  parent: client.projectPath(projectId),
};

// Retrieves an uptime check config
const [uptimeCheckConfigs] = await client.listUptimeCheckConfigs(request);

uptimeCheckConfigs.forEach(uptimeCheckConfig => {
  console.log(`ID: ${uptimeCheckConfig.name}`);
  console.log(`  Display Name: ${uptimeCheckConfig.displayName}`);
  console.log('  Resource: %j', uptimeCheckConfig.monitoredResource);
  console.log('  Period: %j', uptimeCheckConfig.period);
  console.log('  Timeout: %j', uptimeCheckConfig.timeout);
  console.log(`  Check type: ${uptimeCheckConfig.check_request_type}`);
  console.log(
    '  Check: %j',
    uptimeCheckConfig.httpCheck || uptimeCheckConfig.tcpCheck
  );
  console.log(
    `  Content matchers: ${uptimeCheckConfig.contentMatchers
      .map(matcher => matcher.content)
      .join(', ')}`
  );
  console.log(`  Regions: ${uptimeCheckConfig.selectedRegions.join(', ')}`);
});

PHP

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

use Google\Cloud\Monitoring\V3\Client\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\ListUptimeCheckConfigsRequest;

/**
 * Example:
 * ```
 * list_uptime_checks($projectId);
 * ```
 */
function list_uptime_checks(string $projectId): void
{
    $projectName = 'projects/' . $projectId;
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);
    $listUptimeCheckConfigsRequest = (new ListUptimeCheckConfigsRequest())
        ->setParent($projectName);

    $pages = $uptimeCheckClient->listUptimeCheckConfigs($listUptimeCheckConfigsRequest);

    foreach ($pages->iteratePages() as $page) {
        foreach ($page as $uptimeCheck) {
            print($uptimeCheck->getName() . PHP_EOL);
        }
    }
}

Python

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def list_uptime_check_configs(project_id: str) -> pagers.ListUptimeCheckConfigsPager:
    """Gets all uptime checks defined in the Google Cloud project

    Args:
        project_id: Google Cloud project id

    Returns:
        A list of configurations.
        Iterating over this object will yield results and resolve additional pages automatically.
    """
    client = monitoring_v3.UptimeCheckServiceClient()
    configs = client.list_uptime_check_configs(request={"parent": project_id})

    for config in configs:
        pprint.pprint(config)
    return configs

Ruby

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def list_uptime_check_configs project_id
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  project_name = client.project_path project: project_id
  configs = client.list_uptime_check_configs parent: project_name

  configs.each { |config| puts config.name }
end

Afficher les détails d'un test de disponibilité

Console

  1. Dans la console Google Cloud, accédez à la page  Tests de disponibilité:

    Accéder à la page Tests de disponibilité

    Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.

  2. Localisez le test de disponibilité que vous souhaitez afficher, puis cliquez sur son nom.

    La capture d'écran ci-dessous montre les détails du test de disponibilité "My Uptime Check" :

    Exemple de tableau de bord d'un test de disponibilité.

    La page Détails du test de disponibilité contient les informations suivantes:

    • Intervalle de temps sélectionné. Par défaut, l'intervalle est défini sur 1 hour (1 heure).
    • Nom du test de disponibilité. Dans cet exemple, le nom est My Uptime Check.
    • Étiquettes que vous avez ajoutées au test de disponibilité.

    • Pourcentage de disponibilité et latence moyenne. La valeur Percent uptime (Pourcentage de disponibilité) est un pourcentage calculé comme suit : (S/T)*100, où S représente le nombre de réponses de test ayant abouti et T le nombre total de réponses de test, pour tous les emplacements. Pour les tests de groupe, les valeurs de S et T sont additionnées pour tous les membres actuels du groupe.

      Par exemple, sur une période de 25 minutes, un test de disponibilité d'une période d'une minute dans toutes les régions reçoit 25 requêtes de chacune des six zones, pour un total de 150 requêtes. Si le tableau de bord indique une disponibilité de 83,3 %, cela signifie que 125 requêtes sur 150 ont abouti.

    • Les volets Passed checks (Tests réussis) et Uptime check latency (Latence du test de disponibilité) fournissent une représentation graphique du nombre de tests réussis et de la latence de chaque test en fonction du temps.

    • Le volet Current Status (État actuel) affiche l'état des tests les plus récents. Un cercle vert avec une coche à côté d'une région indique que la dernière exécution du test a réussi dans cette région. En revanche, un cercle rouge avec un "X" signifie qu'elle a échoué.

    • Le volet Configuration affiche la configuration du test de disponibilité. Ces données sont attribuées lors de la création du test de disponibilité. La valeur Check ID (ID du test de disponibilité) correspond à la valeur CHECK_ID dans les appels d'API.

    • Le volet Règles d'alerte répertorie les informations règles d'alerte. Dans l'exemple de tableau de bord, une règle d'alerte configuré.

gcloud

Pour afficher les détails d'un test de disponibilité ou d'un moniteur synthétique, exécutez la commande gcloud monitoring uptime describe :

gcloud monitoring uptime describe CHECK_ID

Avant d'exécuter la commande précédente, remplacez CHECK_ID par l'identifiant du test de disponibilité ou de la surveillance synthétique. Vous trouverez à l'aide de la commande gcloud monitoring uptime list-configs. en examinant le champ name (nom). Pour en savoir plus, consultez Recherchez l'identifiant unique d'un test de disponibilité.

Les données renvoyées pour le contrôle de l'état de fonctionnement incluent les éléments suivants :

  • Nom et nom à afficher.
  • Vérifier l'identifiant
  • Ressource surveillée.
  • Période entre les vérifications.

API

Pour répertorier les détails d'un test de disponibilité ou d'une surveillance synthétique, appelez la méthode projects.uptimeCheckConfigs.get . Spécifiez le paramètre suivant :

C#

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

public static object GetUptimeCheckConfig(string configName)
{
    var client = UptimeCheckServiceClient.Create();
    UptimeCheckConfig config = client.GetUptimeCheckConfig(configName);
    if (config == null)
    {
        Console.Error.WriteLine(
            "No configuration found with the name {0}", configName);
        return -1;
    }
    Console.WriteLine("Name: {0}", config.Name);
    Console.WriteLine("Display Name: {0}", config.DisplayName);
    Console.WriteLine("Http Path: {0}", config.HttpCheck.Path);
    return 0;
}

Java

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

private static void getUptimeCheckConfig(String checkName) throws IOException {
  // Create UptimeCheckServiceSettings instance for add retry mechanism
  UptimeCheckServiceSettings.Builder uptimeCheckServiceSettingsBuilder =
      UptimeCheckServiceSettings.newBuilder();
  uptimeCheckServiceSettingsBuilder
      .getUptimeCheckConfigSettings()
      .setRetrySettings(
          uptimeCheckServiceSettingsBuilder
              .getUptimeCheckConfigSettings()
              .getRetrySettings()
              .toBuilder()
              .setInitialRetryDelay(org.threeten.bp.Duration.ofMillis(100L))
              .setRetryDelayMultiplier(1.3)
              .setMaxRetryDelay(MAX_RECONNECT_BACKOFF_TIME)
              .setInitialRpcTimeout(MAX_RECONNECT_BACKOFF_TIME)
              .setRpcTimeoutMultiplier(1.0)
              .setMaxRpcTimeout(MAX_RECONNECT_BACKOFF_TIME)
              .setTotalTimeout(MAX_RECONNECT_BACKOFF_TIME)
              .setMaxAttempts(6)
              .build());
  UptimeCheckServiceSettings uptimeCheckServiceSettings =
      uptimeCheckServiceSettingsBuilder.build();

  // create UptimeCheckServiceClient with retry setting
  try (UptimeCheckServiceClient client =
      UptimeCheckServiceClient.create(uptimeCheckServiceSettings)) {
    UptimeCheckConfig config = client.getUptimeCheckConfig(checkName);
    if (config != null) {
      System.out.println(config.toString());
    } else {
      System.out.println("No uptime check config found with ID " + checkName);
    }
  } catch (Exception e) {
    usage("Exception getting uptime check: " + e.toString());
    throw e;
  }
}

Go

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


// get is an example of getting an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func get(w io.Writer, resourceName string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %w", err)
	}
	defer client.Close()
	req := &monitoringpb.GetUptimeCheckConfigRequest{
		Name: resourceName,
	}
	config, err := client.GetUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("GetUptimeCheckConfig: %w", err)
	}
	fmt.Fprintf(w, "Config: %v", config)
	return config, nil
}

Node.js

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const uptimeCheckConfigId = 'YOUR_UPTIME_CHECK_CONFIG_ID';

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.projectUptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Retrieving ${request.name}`);

// Retrieves an uptime check config
const [uptimeCheckConfig] = await client.getUptimeCheckConfig(request);
console.log(`ID: ${uptimeCheckConfig.name}`);
console.log(`Display Name: ${uptimeCheckConfig.displayName}`);
console.log('Resource: %j', uptimeCheckConfig.monitoredResource);
console.log('Period: %j', uptimeCheckConfig.period);
console.log('Timeout: %j', uptimeCheckConfig.timeout);
console.log(`Check type: ${uptimeCheckConfig.check_request_type}`);
console.log(
  'Check: %j',
  uptimeCheckConfig.httpCheck || uptimeCheckConfig.tcpCheck
);
console.log(
  `Content matchers: ${uptimeCheckConfig.contentMatchers
    .map(matcher => matcher.content)
    .join(', ')}`
);
console.log(`Regions: ${uptimeCheckConfig.selectedRegions.join(', ')}`);

PHP

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

use Google\Cloud\Monitoring\V3\Client\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\GetUptimeCheckConfigRequest;

/**
 * Example:
 * ```
 * get_uptime_check($projectId, $configName);
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $configName
 */
function get_uptime_check($projectId, $configName)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);
    $getUptimeCheckConfigRequest = (new GetUptimeCheckConfigRequest())
        ->setName($configName);

    $uptimeCheck = $uptimeCheckClient->getUptimeCheckConfig($getUptimeCheckConfigRequest);

    print('Retrieved an uptime check:' . PHP_EOL);
    print($uptimeCheck->serializeToJsonString() . PHP_EOL);
}

Python

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def get_uptime_check_config(config_name: str) -> uptime.UptimeCheckConfig:
    """Reads the uptime check configuration

    Args:
        config_name: Uptime check configuration identity

    Returns:
        A structure that describes the updated uptime check
    """
    client = monitoring_v3.UptimeCheckServiceClient()
    config = client.get_uptime_check_config(request={"name": config_name})
    pprint.pprint(config)
    return config

Ruby

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def get_uptime_check_config config_name
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  config = client.get_uptime_check_config name: config_name
  pp config.to_h
  config
end

Modifier un test de disponibilité

Vous pouvez modifier certains champs d'un test de disponibilité. Par exemple, vous pouvez souhaiter que la vérification se produise plus fréquemment ou augmenter le délai d'expiration associé à la validation de la réponse. Toutefois, si votre test de disponibilité n'est pas configuré avec le protocole, le type de ressource ou la ressource appropriés, supprimez le test de disponibilité actuel et créez-en un autre.

Pour savoir comment modifier une règle d'alerte qui surveille un test de disponibilité, consultez les documents suivants:

Pour modifier un test de disponibilité public, vous pouvez utiliser le processus dans l'un des onglets suivants. Pour modifier un test de disponibilité privé, utilisez l'onglet Console ou API:

Console

  1. Dans la console Google Cloud, accédez à la page Tests de disponibilité :

    Accéder à la page Tests de disponibilité

    Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.

  2. Localisez le test de disponibilité que vous souhaitez modifier, puis effectuez l'une des opérations suivantes :

    • Cliquez sur Plus et sélectionnez Modifier.
    • Affichez les détails du test de disponibilité, puis cliquez sur Modifier.

  3. Modifiez les valeurs des champs selon vos besoins. Vous ne pouvez pas modifier tous les champs. Si les valeurs d'en-têtes personnalisés d'un test sont masquées, vous ne pouvez pas les rendre visibles.

  4. Pour vérifier si le test fonctionne, cliquez sur Tester. Si le test échoue, consultez la section Échecs des vérifications pour identifier les causes possibles.

  5. Cliquez sur Enregistrer.

gcloud

Pour modifier un test de disponibilité ou la surveillance synthétique, exécutez la commande gcloud monitoring uptime update commande:

gcloud monitoring uptime update CHECK_ID OPTIONAL_FLAGS

Avant d'exécuter la commande précédente, procédez comme suit:

  • Remplacez CHECK_ID par l'identifiant de la vérification de l'état de fonctionnement ou du moniteur synthétique. Pour trouver cet identifiant, exécutez la commande Commande gcloud monitoring uptime list-configs et en examinant le champ name (nom). Pour en savoir plus, consultez Recherchez l'identifiant unique d'un test de disponibilité.

  • Définissez les champs que vous souhaitez modifier.

Par exemple, pour définir la période d'un test de disponibilité sur 10 minutes, exécutez la commande suivante:

gcloud monitoring uptime update CHECK_ID --period=10

API

Appelez la méthode projects.uptimeCheckConfigs.patch. Définissez les paramètres associés à la méthode comme suit :

  • uptimeCheckConfig.name : obligatoire. Ce paramètre fait partie de l'URL REST. Il s'agit du nom de ressource du test de disponibilité à modifier :

    projects/PROJECT_ID/uptimeCheckConfigs/CHECK_ID

    Pour en savoir plus sur l'identifiant de test de disponibilité, consultez Recherchez l'identifiant unique d'un test de disponibilité.

  • updateMask : facultatif. Il s'agit d'un paramètre de requête : ?updateMask=[FIELD_LIST]. [FIELD_LIST] est une liste de champs séparés par une virgule dans l'objet UptimeCheckConfig à modifier. Exemple :

    "resource.type,httpCheck.path"

  • Le corps de la requête doit contenir un objet UptimeCheckConfig avec les nouvelles valeurs de champ.

Si updateMask est défini, seuls les champs répertoriés dans updateMask remplacent les champs correspondants dans la configuration existante. Si un champ comporte des sous-champs et qu'il est répertorié dans le masque de champ, mais qu'aucun de ses sous-champs ne l'est, tous les sous-champs remplacent les champs correspondants.

Si updateMask n'est pas défini, la configuration figurant dans le corps de la requête remplace l'ensemble de la configuration existante.

La méthode patch renvoie l'objet UptimeCheckConfig pour la configuration modifiée.

C#

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

public static object UpdateUptimeCheck(string configName,
    string newHttpPath, string newDisplayName)
{
    var client = UptimeCheckServiceClient.Create();
    var config = client.GetUptimeCheckConfig(configName);
    var fieldMask = new FieldMask();
    if (newDisplayName != null)
    {
        config.DisplayName = newDisplayName;
        fieldMask.Paths.Add("display_name");
    }
    if (newHttpPath != null)
    {
        config.HttpCheck.Path = newHttpPath;
        fieldMask.Paths.Add("http_check.path");
    }
    client.UpdateUptimeCheckConfig(config);
    return 0;
}

Java

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

private static void updateUptimeCheck(String checkName, String hostName, String pathName)
    throws IOException {

  UpdateUptimeCheckConfigRequest request =
      UpdateUptimeCheckConfigRequest.newBuilder()
          .setUpdateMask(FieldMask.newBuilder().addPaths("http_check.path"))
          .setUptimeCheckConfig(
              UptimeCheckConfig.newBuilder()
                  .setName(checkName)
                  .setMonitoredResource(
                      MonitoredResource.newBuilder()
                          .setType("uptime_url")
                          .putLabels("host", hostName))
                  .setHttpCheck(HttpCheck.newBuilder().setPath(pathName).setPort(80))
                  .setTimeout(Duration.newBuilder().setSeconds(10))
                  .setPeriod(Duration.newBuilder().setSeconds(300)))
          .build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    UptimeCheckConfig config = client.updateUptimeCheckConfig(request);
    System.out.println("Uptime check updated: \n" + config.toString());
  } catch (Exception e) {
    usage("Exception updating uptime check: " + e.toString());
    throw e;
  }
}

Go

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


// update is an example of updating an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func update(w io.Writer, resourceName, displayName, httpCheckPath string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %w", err)
	}
	defer client.Close()
	getReq := &monitoringpb.GetUptimeCheckConfigRequest{
		Name: resourceName,
	}
	config, err := client.GetUptimeCheckConfig(ctx, getReq)
	if err != nil {
		return nil, fmt.Errorf("GetUptimeCheckConfig: %w", err)
	}
	config.DisplayName = displayName
	config.GetHttpCheck().Path = httpCheckPath
	req := &monitoringpb.UpdateUptimeCheckConfigRequest{
		UpdateMask: &field_mask.FieldMask{
			Paths: []string{"display_name", "http_check.path"},
		},
		UptimeCheckConfig: config,
	}
	config, err = client.UpdateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("UpdateUptimeCheckConfig: %w", err)
	}
	fmt.Fprintf(w, "Successfully updated %v", resourceName)
	return config, nil
}

Node.js

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const uptimeCheckConfigId = 'YOUR_UPTIME_CHECK_CONFIG_ID';
// const displayName = 'A New Display Name';
// const path = '/some/path';

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.projectUptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Updating ${request.name} to ${displayName}`);

// Updates the display name and path on an uptime check config
request.uptimeCheckConfig = {
  name: request.name,
  displayName: displayName,
  httpCheck: {
    path: path,
  },
};

request.updateMask = {
  paths: ['display_name', 'http_check.path'],
};

const [response] = await client.updateUptimeCheckConfig(request);
console.log(`${response.name} config updated.`);

PHP

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

use Google\Cloud\Monitoring\V3\Client\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\GetUptimeCheckConfigRequest;
use Google\Cloud\Monitoring\V3\UpdateUptimeCheckConfigRequest;
use Google\Protobuf\FieldMask;

/**
 * Example:
 * ```
 * update_uptime_checks($projectId);
 * ```
 */
function update_uptime_checks(
    string $projectId,
    string $configName,
    string $newDisplayName = null,
    string $newHttpCheckPath = null
): void {
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);
    $getUptimeCheckConfigRequest = (new GetUptimeCheckConfigRequest())
        ->setName($configName);

    $uptimeCheck = $uptimeCheckClient->getUptimeCheckConfig($getUptimeCheckConfigRequest);
    $fieldMask = new FieldMask();
    if ($newDisplayName) {
        $fieldMask->getPaths()[] = 'display_name';
        $uptimeCheck->setDisplayName($newDisplayName);
    }
    if ($newHttpCheckPath) {
        $paths = $fieldMask->getPaths()[] = 'http_check.path';
        $uptimeCheck->getHttpCheck()->setPath($newHttpCheckPath);
    }
    $updateUptimeCheckConfigRequest = (new UpdateUptimeCheckConfigRequest())
        ->setUptimeCheckConfig($uptimeCheck)
        ->setUpdateMask($fieldMask);

    $uptimeCheckClient->updateUptimeCheckConfig($updateUptimeCheckConfigRequest);

    print($uptimeCheck->serializeToString() . PHP_EOL);
}

Python

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def update_uptime_check_config(
    config_name: str, new_display_name: str = None, new_http_check_path: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        config_name: Uptime check configuration identity
        new_display_name: A new human friendly name of the configuration
        new_http_check_path: A new HTTP endpoint of the configuration

    Returns:
        A structure that describes the updated uptime check
    """
    client = monitoring_v3.UptimeCheckServiceClient()
    config = client.get_uptime_check_config(request={"name": config_name})
    field_mask = field_mask_pb2.FieldMask()
    if new_display_name:
        field_mask.paths.append("display_name")
        config.display_name = new_display_name
    if new_http_check_path:
        field_mask.paths.append("http_check.path")
        config.http_check.path = new_http_check_path
    changed_config = client.update_uptime_check_config(
        request={"uptime_check_config": config, "update_mask": field_mask}
    )
    pprint.pprint(changed_config)
    return changed_config

Ruby

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def update_uptime_check_config config_name:         nil,
                               new_display_name:    nil,
                               new_http_check_path: nil
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  config = { name: config_name }
  field_mask = { paths: [] }
  unless new_display_name.to_s.empty?
    field_mask[:paths].push "display_name"
    config[:display_name] = new_display_name
  end
  unless new_http_check_path.to_s.empty?
    field_mask[:paths].push "http_check.path"
    config[:http_check] = { path: new_http_check_path }
  end
  client.update_uptime_check_config uptime_check_config: config,
                                    update_mask:         field_mask
end

Il peut s'écouler jusqu'à 5 minutes avant que vous ne voyiez les résultats du nouveau test de disponibilité. Pendant ce temps, les résultats de l'ancien test de disponibilité sont affichés dans les tableaux de bord et utilisés dans les règles d'alerte.

Supprimer un test de disponibilité

Nous vous recommandons de supprimer un test de disponibilité lorsque vous désactivez le service ou la ressource qu'il surveille. Remarque: Avant de supprimer un test de disponibilité, assurez-vous qu'il n'y a pas d'alerte qui surveillent le test de disponibilité. Lorsqu'une règle d'alerte surveille un test de disponibilité, la console Google Cloud empêche la suppression vérifier. Toutefois, l'API Cloud Monitoring ne génère pas d'erreur ni n'empêche la suppression. Aucun incident n'est créé pour la vérification manquante.

Pour supprimer un test de disponibilité, procédez comme suit :

Console

  1. Dans la console Google Cloud, accédez à la page  Tests de disponibilité:

    Accéder à la page Tests de disponibilité

    Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.

  2. Localisez le test de disponibilité que vous souhaitez modifier, puis effectuez l'une des opérations suivantes :

    • Cliquez sur Plus et sélectionnez Supprimer.
    • Affichez les détails du test de disponibilité, puis cliquez sur Supprimer.

gcloud

Pour supprimer un test de disponibilité ou un moniteur synthétique, exécutez la commande gcloud monitoring uptime delete :

gcloud monitoring uptime delete CHECK_ID

Avant d'exécuter la commande précédente, remplacez CHECK_ID par l'identifiant du test de disponibilité ou du moniteur synthétique. Pour trouver l'identifiant, exécutez la commande gcloud monitoring uptime list-configs et examinez le champ name. Pour en savoir plus, consultez Recherchez l'identifiant unique d'un test de disponibilité.

API

Pour supprimer un test de disponibilité ou un moniteur synthétique, appelez la méthode projects.uptimeCheckConfigs.delete. Spécifiez le paramètre comme suit :

  • name : obligatoire. Il s'agit du nom de ressource de la configuration de test de disponibilité à supprimer :

    projects/PROJECT_ID/uptimeCheckConfigs/CHECK_ID

    Pour en savoir plus sur l'identifiant de test de disponibilité, consultez la section Trouver l'identifiant unique d'un test de disponibilité.

C#

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

public static object DeleteUptimeCheckConfig(string configName)
{
    var client = UptimeCheckServiceClient.Create();
    client.DeleteUptimeCheckConfig(configName);
    Console.WriteLine($"Deleted {configName}");
    return 0;
}

Java

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

private static void deleteUptimeCheckConfig(String checkName) throws IOException {
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    client.deleteUptimeCheckConfig(checkName);
  } catch (Exception e) {
    usage("Exception deleting uptime check: " + e.toString());
    throw e;
  }
}

Go

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


// delete is an example of deleting an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func delete(w io.Writer, resourceName string) error {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return fmt.Errorf("NewUptimeCheckClient: %w", err)
	}
	defer client.Close()
	req := &monitoringpb.DeleteUptimeCheckConfigRequest{
		Name: resourceName,
	}
	if err := client.DeleteUptimeCheckConfig(ctx, req); err != nil {
		return fmt.Errorf("DeleteUptimeCheckConfig: %w", err)
	}
	fmt.Fprintf(w, "Successfully deleted %q", resourceName)
	return nil
}

Node.js

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.UptimeCheckServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const uptimeCheckConfigId = 'YOUR_UPTIME_CHECK_CONFIG_ID';

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.projectUptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Deleting ${request.name}`);

// Delete an uptime check config
await client.deleteUptimeCheckConfig(request);
console.log(`${request.name} deleted.`);

PHP

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

use Google\Cloud\Monitoring\V3\Client\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\DeleteUptimeCheckConfigRequest;

/**
 * Example:
 * ```
 * delete_uptime_check($projectId, $configName);
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $configName
 */
function delete_uptime_check($projectId, $configName)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);
    $deleteUptimeCheckConfigRequest = (new DeleteUptimeCheckConfigRequest())
        ->setName($configName);

    $uptimeCheckClient->deleteUptimeCheckConfig($deleteUptimeCheckConfigRequest);

    printf('Deleted an uptime check: ' . $configName . PHP_EOL);
}

Python

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

# `config_name` is the `name` field of an UptimeCheckConfig.
# See https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.uptimeCheckConfigs#UptimeCheckConfig.
def delete_uptime_check_config(config_name: str) -> None:
    """Deletes the uptime check configuration

    Args:
        config_name: Uptime check configuration identity
    """
    client = monitoring_v3.UptimeCheckServiceClient()
    client.delete_uptime_check_config(request={"name": config_name})
    print("Deleted ", config_name)

Ruby

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def delete_uptime_check_config config_name
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  client.delete_uptime_check_config name: config_name
  puts "Deleted #{config_name}"
end

Surveiller un test de disponibilité

Nous vous recommandons de créer une règle d'alerte pour vous avertir en cas d'échec de votre test de disponibilité. Pour en savoir plus, consultez Créer des règles d'alerte pour les tests de disponibilité

Trouver l'identifiant unique d'un test de disponibilité

Lorsque votre test de disponibilité est créé, Monitoring lui attribue appelé ID de test de disponibilité. Cet identifiant est intégré Nom de ressource du test de disponibilité:

projects/PROJECT_ID/uptimeCheckConfigs/CHECK_ID

L'ID de test de disponibilité est inclus dans la réponse des méthodes de l'API Cloud Monitoring qui créent ou répertorient des tests de disponibilité. Vous pouvez également trouver l'ID de test de disponibilité dans le volet Configuration de la page Détails du test de disponibilité de la console Google Cloud. Pour savoir comment afficher la page Détails de la disponibilité, consultez la section Afficher les détails d'un test de disponibilité de ce document.

Étape suivante