Examiner les tests de disponibilité

Cette page vous explique comment :

  • répertorier l'ensemble de vos tests de disponibilité ;
  • obtenir la liste des adresses IP utilisées par les tests de disponibilité.

Pour créer, mettre à jour et supprimer des tests de disponibilité, consultez la page Gérer les tests de disponibilité. Pour connaître les tarifs et les limites applicables aux tests de disponibilité, consultez la section Tarifs et limites.

Répertorier les tests de disponibilité

Console

Pour répertorier les tests de disponibilité actuels, procédez comme suit :

  1. Dans Cloud Console, sélectionnez Surveillance :

    Accéder à Monitoring

  2. Sélectionnez Uptime checks (Tests de disponibilité).

Pour afficher les détails d'un test de disponibilité, cliquez sur son nom.

Pour restreindre 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. Dans l'exemple suivant, le filtre OR est utilisé de sorte qu'un test de disponibilité soit répertorié si son nom correspond à default ou testing check :

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

API

Pour obtenir la liste de vos configurations de tests de disponibilité, 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 :

  • name : nom complet de la configuration du test de disponibilité.

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Vous pouvez obtenir la valeur [UPTIME_CHECK_ID] à partir de la réponse d'une méthode create ou list. L'ID n'apparaît pas dans Google Cloud Console.

C#

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

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


// 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: %v", 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: %v", err)
		}
		fmt.Fprintln(w, config)
	}
	fmt.Fprintln(w, "Done listing uptime checks")
	return nil
}

Node.js

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

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * list_uptime_checks($projectId);
 * ```
 */
function list_uptime_checks($projectId)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $pages = $uptimeCheckClient->listUptimeCheckConfigs(
        $uptimeCheckClient->projectName($projectId)
    );

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

Python

def list_uptime_check_configs(project_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    configs = client.list_uptime_check_configs(project_name)

    for config in configs:
        pprint.pprint(config)

Ruby

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

Obtenir des adresses IP de test de disponibilité

Si vous vérifiez un service situé derrière un pare-feu, vous pouvez configurer ce pare-feu pour accepter le trafic de l'ensemble d'adresses IP actuel utilisé pour le test de disponibilité. Pour obtenir les adresses IP, suivez les instructions suivantes :

Console

  1. Dans Cloud Console, sélectionnez Surveillance :

    Accéder à Monitoring

  2. Sélectionnez Uptime checks (Tests de disponibilité).

  3. Cliquez sur Download static checker IP addresses (Télécharger les adresses IP du vérificateur statique) .

API

  1. Appelez la méthode uptimeCheckIps.list de l'API Monitoring.

  2. La méthode renvoie les informations suivantes pour chaque adresse IP :

    • La région : USA, EUROPE, SOUTH_AMERICA ou ASIA_PACIFIC
    • Une zone plus spécifique dans la région
    • L'adresse IP (et non une plage d'adresses) au format IPv4 ou IPv6

C#

public static object ListUptimeCheckIps()
{
    var client = UptimeCheckServiceClient.Create();
    var ips = client.ListUptimeCheckIps(new ListUptimeCheckIpsRequest());
    foreach (UptimeCheckIp ip in ips)
    {
        Console.WriteLine("{0,20} {1}", ip.IpAddress, ip.Location);
    }
    return 0;
}

Java

private static void listUptimeCheckIPs() throws IOException {
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    ListUptimeCheckIpsPagedResponse response =
        client.listUptimeCheckIps(ListUptimeCheckIpsRequest.newBuilder().build());
    for (UptimeCheckIp config : response.iterateAll()) {
      System.out.println(config.getRegion() + " - " + config.getIpAddress());
    }
  } catch (Exception e) {
    usage("Exception listing uptime IPs: " + e.toString());
    throw e;
  }
}

Go


// listIPs is an example of listing uptime check IPs.
func listIPs(w io.Writer) error {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.ListUptimeCheckIpsRequest{}
	it := client.ListUptimeCheckIps(ctx, req)
	for {
		config, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListUptimeCheckIps: %v", err)
		}
		fmt.Fprintln(w, config)
	}
	fmt.Fprintln(w, "Done listing uptime check IPs")
	return nil
}

Node.js

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

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

// List uptime check IPs
const [uptimeCheckIps] = await client.listUptimeCheckIps();
uptimeCheckIps.forEach(uptimeCheckIp => {
  console.log(
    uptimeCheckIp.region,
    uptimeCheckIp.location,
    uptimeCheckIp.ipAddress
  );
});

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * list_uptime_check_ips($projectId);
 * ```
 */
function list_uptime_check_ips($projectId)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $pages = $uptimeCheckClient->listUptimeCheckIps();

    foreach ($pages->iteratePages() as $page) {
        $ips = $page->getResponseObject()->getUptimeCheckIps();
        foreach ($ips as $ip) {
            printf(
                'ip address: %s, region: %s, location: %s' . PHP_EOL,
                $ip->getIpAddress(),
                $ip->getRegion(),
                $ip->getLocation()
            );
        }
    }
}

Python

def list_uptime_check_ips():
    client = monitoring_v3.UptimeCheckServiceClient()
    ips = client.list_uptime_check_ips()
    print(
        tabulate.tabulate(
            [(ip.region, ip.location, ip.ip_address) for ip in ips],
            ("region", "location", "ip_address"),
        )
    )

Ruby

def list_ips
  require "google/cloud/monitoring"
  client = Google::Cloud::Monitoring.uptime_check_service

  # Iterate over all results.
  client.list_uptime_check_ips({}).each do |element|
    puts "#{element.location} #{element.ip_address}"
  end
end

Les tests de disponibilité peuvent provenir de n'importe quelle adresse IP, mais une seule adresse de chaque emplacement géographique est utilisée par intervalle de temps. Les emplacements géographiques sont répertoriés dans le tableau de bord des tests de disponibilité, comme indiqué dans la section précédente. Vous pouvez également identifier les emplacements enregistrés des adresses IP que vous avez téléchargées à l'aide de services Web gratuits.

Les adresses IP utilisées par les tests de disponibilité peuvent varier, mais généralement pas plus d'une fois par trimestre et après notification préalable.

Identifier le trafic des tests de disponibilité

Vous pouvez identifier les requêtes des serveurs de tests de disponibilité grâce aux informations ci-dessous qui sont consignées dans les journaux de requêtes du service :

  • ip : le champ ip contient l'une des adresses utilisées par les serveurs de tests de disponibilité. Consultez la section Obtenir des adresses IP.
  • User-Agent : l'en-tête User-Agent a toujours la valeur suivante :

    GoogleStackdriverMonitoring-UptimeChecks(https://cloud.google.com/monitoring)
    

    La spécification d'un en-tête User-Agent personnalisé entraîne une erreur de validation du formulaire et empêche l'enregistrement de la configuration de test.