Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Répertorier les adresses IP des serveurs de test de disponibilité

Ce document explique comment obtenir la liste des adresses IP utilisées par les serveurs de tests de disponibilité et comment identifier le trafic provenant de ces serveurs dans vos journaux.

Lister les adresses IP

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 ces adresses IP, suivez les instructions ci-dessous :

Console

Dans la Google Cloud console, accédez à la page Tests de disponibilité :
Accéder à 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.
Dans la barre d'outils de la Google Cloud console, sélectionnez votre Google Cloud projet. Pour les configurations App Hub, sélectionnez le projet hôte App Hub ou le projet de gestion.
Dans le menu Tests de disponibilité, cliquez sur Télécharger. Un fichier uptime-source-ips.txt est téléchargé et contient les adresses IP.

gcloud

Exécutez la gcloud monitoring uptime list-ips commande :

gcloud monitoring uptime list-ips

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

L'adresse IP (et non une plage d'adresses) au format IPv4 ou IPv6
La région : USA, EUROPE, SOUTH_AMERICA, ou ASIA_PACIFIC.
L'emplacement dans la région

API

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

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#

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 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: %w", 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: %w", 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\Client\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\ListUptimeCheckIpsRequest;

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

    $pages = $uptimeCheckClient->listUptimeCheckIps($listUptimeCheckIpsRequest);

    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() -> pagers.ListUptimeCheckIpsPager:
    """Gets all locations and IP addresses used by uptime check servers

    Returns:
        A list of locations and IP addresses of uptime check servers.
        Iterating over this object will yield results and resolve additional pages automatically.
    """
    client = monitoring_v3.UptimeCheckServiceClient()
    ips = client.list_uptime_check_ips(request={})
    print(
        tabulate.tabulate(
            [(ip.region, ip.location, ip.ip_address) for ip in ips],
            ("region", "location", "ip_address"),
        )
    )
    return ips

Ruby

gem "google-cloud-monitoring"
require "google/cloud/monitoring"

def list_ips
  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 sans frais.

Identifier le trafic des tests de disponibilité dans les journaux

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 ip champ contient l'une des adresses utilisées par les serveurs de tests de disponibilité. Pour savoir comment lister toutes les adresses IP, consultez la section Lister les adresses IP.
User-Agent : la valeur de l'en-tête User-Agent est toujours la suivante :
```
GoogleStackdriverMonitoring-UptimeChecks(https://cloud.google.com/monitoring)
```
La spécification d'un en-tête personnalisé User-Agent entraîne une erreur de validation du formulaire et empêche l'enregistrement de la configuration de test.

Répertorier les adresses IP des serveurs de test de disponibilité Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.