Cette page a été traduite par l'API Cloud Translation.

Créer des tests de disponibilité publics

Ce document explique comment créer un test de disponibilité public. Un test de disponibilité public peut envoyer des requêtes depuis plusieurs emplacements vers des URL publiques ou des ressources Google Cloud pour déterminer la ressource répond. Pour savoir comment créer pour les tests de disponibilité des réseaux privés, consultez Créer des tests de disponibilité privés

Les tests de disponibilité publics peuvent déterminer la disponibilité des ressources suivantes :

Pour obtenir des liens vers des informations sur la gestion et la surveillance des tests de disponibilité, consultez la section Étapes suivantes de ce document.

À propos des tests de disponibilité

Pour HTTP et HTTPS, toutes les redirections d'URL sont suivies, et la réponse finale reçue par le test de disponibilité est utilisée pour évaluer les critères de réussite. Pour les tests HTTPS, le délai d'expiration du certificat SSL est calculé en fonction du certificat de serveur reçu dans la réponse finale.

Pour qu'un test de disponibilité réussisse, les conditions suivantes doivent être remplies :

L'état HTTP doit correspondre aux critères que vous spécifiez.
Les données de réponse n'ont pas de contenus obligatoires, ou les contenus obligatoires sont présents.

Les tests de disponibilité ne chargent pas d'éléments de page et n'exécutent pas JavaScript. la configuration d'un test de disponibilité n'inclut pas l'authentification.

Avant de commencer

Pour obtenir les autorisations nécessaires pour créer des vérifications de l'état de disponibilité, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :
- Éditeur Monitoring (roles/monitoring.editor) : utilisateurs de la console Google Cloud
- Éditeur des configurations de tests de disponibilité Monitoring (roles/monitoring.uptimeCheckConfigEditor) - Utilisateurs de l'API
- Éditeur Monitoring AlertPolicy (roles/monitoring.alertPolicyEditor) – Utilisateurs de l'API
- Éditeur Monitoring NotificationChannel (roles/monitoring.notificationChannelEditor) – Utilisateurs de l'API
Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.
Vérifiez que la ressource que vous souhaitez vérifier dispose d'un point de terminaison public ou se trouve derrière un pare-feu configurable.

Pour toutes les autres configurations, vous devez créer un test de disponibilité privé. Pour en savoir plus, consultez Créer des tests de disponibilité privés
Lorsque votre ressource est protégée par un pare-feu, configurez ce pare-feu pour autoriser le trafic entrant à partir des adresses IP des serveurs de tests de disponibilité. Pour en savoir plus, consultez la section Lister les adresses IP des serveurs de vérification de l'état.
Configurez les canaux de notification que vous souhaitez utiliser pour recevoir les notifications. Nous vous recommandons de créer plusieurs types de canaux de notification. Pour en savoir plus, consultez Créer et gérer des canaux de notification
Identifiez au moins trois vérificateurs pour votre test de disponibilité. La région USA du test de disponibilité inclut USA_OREGON, USA_IOWA et USA_VIRGINIA. Chacune des régions USA_* dispose d'un vérificateur, et USA les inclut toutes les trois. Les autres régions où les tests de disponibilité EUROPE, SOUTH_AMERICA et ASIA_PACIFIC, chacun en possède un vérificateur.

Si vous sélectionnez Global lors de l'utilisation de Google Cloud Console ou REGION_UNSPECIFIED lors de l'utilisation de l'API, les tests de disponibilité sont émis à partir de toutes les régions.

Créer un test de disponibilité

Cette section explique comment créer et configurer des tests de disponibilité.

Pour créer une vérification de l'état de disponibilité d'un équilibreur de charge externe qui comporte au moins un port TCP ou HTTP/S configuré, vous pouvez suivre ces instructions. Vous pouvez également accéder à la page Informations sur le service du service, puis cliquer sur Créer un test de disponibilité. Lorsque vous démarrez Détails du service, les champs spécifiques au service sont préremplis.

Console

Pour créer un test de disponibilité à l'aide de la console Google Cloud, procédez comme suit:

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.
Cliquez sur Create Uptime Check (Créer un test de disponibilité).
Spécifiez la cible du test de disponibilité :
1. Sélectionnez le protocole. Vous pouvez sélectionner HTTP, HTTPS ou TCP.
2. Choisissez l'un des types de ressources suivants :
  - URL : tout nom d'hôte ou toute adresse IPv4. Le chemin d'accès et le port sont saisis séparément.
  - Service Kubernetes LoadBalancer : service Kubernetes de type LoadBalancer.
  - Instance : instances Compute Engine ou AWS EC2.
  - App Engine : applications App Engine (modules).
  - Elastic Load Balancer : équilibreur de charge AWS.
  Remarque :Ne sélectionnez pas Adresse IP interne, car ce type de ressource ne peut pas être cible d'un test de disponibilité public.
3. Renseignez les champs spécifiques au protocole :
  - Pour les vérifications TCP, saisissez le port.
  - Pour les tests HTTP et HTTPS, vous pouvez saisir un chemin de votre hôte ou ressource. Tous les tests de disponibilité qui utilisent ces protocoles envoient une requête à http://target/path. Dans cette expression, target est une nom d'hôte ou une adresse IP pour une ressource d'URL. Pour une ressource App Engine, target est un nom d'hôte dérivé du nom du service. Pour les ressources d'instance et d'équilibreur de charge, target est une adresse IP dérivée du nom que vous avez fourni pour la ressource ou le groupe de ressources.
    
    Si vous laissez le champ path vide ou si vous définissez la valeur sur /, la requête est envoyée à http://target/.
    
    Par exemple, pour émettre un test de disponibilité sur la ressource d'URL example.com/tester, définissez le champ Nom d'hôte sur example.com et le champ Chemin d'accès sur /tester.
    
    Supposons que vous ayez déployé un serveur sur App Engine avec un coordinateur compatible avec / et /hello. Pour envoyer le test de disponibilité "/" laissez le champ Path (Chemin d'accès) vide. Pour émettre le test de disponibilité au gestionnaire /hello, définissez la valeur de Chemin d'accès vers /hello.
4. Renseignez les champs spécifiques à la ressource :
  - Pour les ressources d'URL, saisissez le nom d'hôte dans le champ Nom d'hôte. . Par exemple, saisissez example.com.
    
    Remarque : Lorsque cela est possible, créez des tests par rapport à des URL directes.
  - Pour les ressources App Engine, saisissez le nom du service dans le champ Service.
  - Pour les ressources Elastic Load Balancer et instance, procédez comme suit : champ S'applique à comme suit:
    - Pour émettre un test de disponibilité à une seule instance ou à un seul équilibreur de charge, sélectionnez Simple, puis utilisez le menu pour sélectionner l'instance ou l'équilibreur de charge spécifique.
    - Pour émettre un test de disponibilité dans un groupe Monitoring, sélectionnez Groupe, puis utilisez le menu pour sélectionner le nom du groupe.
5. Facultatif: Pour définir la fréquence d'exécution du test de disponibilité, utilisez la méthode Check fréquence (Fréquence de vérification).
6. Facultatif: Pour sélectionner des régions du vérificateur ou pour configurer SSL certificats, authentification, en-têtes et ports pour HTTP et HTTPS cliquez sur Plus d'options de ciblage:
  - Régions : sélectionnez les régions dans lesquelles les tests de disponibilité doivent recevoir des requêtes. Un test de disponibilité doit comporter au moins trois vérificateurs. Il existe un vérificateur dans toutes les régions, sauf aux États-Unis, qui comporte trois vérificateurs. Le paramètre par défaut, Global, inclut dans toutes les régions.
  - Pings ICMP : configurez le test de disponibilité pour envoyer jusqu'à trois pings. Pour en savoir plus, consultez Utiliser des pings ICMP.
  - Méthode de requête: pour les tests HTTP, sélectionnez la méthode de requête.
  - Body (Corps) : pour les vérifications HTTP POST, saisissez le corps encodé en URL. Vous devez effectuer l'encodage vous-même. Pour toutes les autres vérifications, laissez cette champ vide.
  - En-tête de l'hôte : renseignez ce champ pour tester des hôtes virtuels. Ce champ n'est pas disponible pour les tests TCP.
  - Port : spécifiez un numéro de port.
  - En-têtes personnalisés : spécifiez des en-têtes personnalisés, puis chiffrez-les si souhaité. Le chiffrement masque les valeurs de l'en-tête dans le formulaire. Utilisez le chiffrement pour les en-têtes liés à l'authentification que vous ne souhaitez pas voir visibles par les autres.
  - Authentification : ces valeurs sont envoyées sous la forme d'un en-tête d'autorisation. Ce champ n'est pas disponible pour les tests TCP.
    
    Remarque : Ne définissez pas les champs Authentication (Authentification) lorsque vous envoyez un en-tête d'autorisation. Si vous définissez les champs Authentication (Authentification) et que vous envoyez un en-tête d'autorisation, une erreur Invalid Argument se produit.
    
    parmi les options suivantes :
    - Authentification de base: indiquez un seul nom d'utilisateur et mot de passe. Les mots de passe sont toujours masqués dans le formulaire.
    - Authentification de l'agent de service : lorsqu'elle est activée, un jeton d'identité est généré pour l'agent de service de surveillance. Cette option n'est disponible que pour les tests HTTPS.
  - Validation du certificat SSL: si vous avez sélectionné HTTPS comme URL ressource, le service tente par défaut de se connecter HTTPS et validez le certificat SSL. Les tests de disponibilité échouent si une URL comporte un certificat non valide. Un certificat peut être non valide pour les raisons suivantes:
    - Un certificat expiré
    - Un certificat autosigné
    - Certificat avec erreur de correspondance du nom de domaine
    - Un certificat qui utilise l'accès aux informations de l'autorité (AIA) .
    Remarque : Une certification SSL révoquée n'est pas considérée comme non valide.
    
    Pour forcer un test de disponibilité HTTPS à valider le certificat SSL, sélectionnez Valider les certificats SSL.
    
    Pour désactiver la validation des certificats SSL, décochez Valider les certificats SSL.
    
    Si vous possédez des certificats SSL avec Extensions AIA vous devez désactiver la validation des certificats SSL. Ces types de certificats ne sont pas compatibles et échouent à la séquence de validation. Généralement, le message d'erreur est "Réponse avec erreur handshake SSL en 10 000 ms".
    
    Vous pouvez utiliser la métrique monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires pour créer une règle d'alerte qui vous avertit avant l'expiration de votre certificat. Pour en savoir plus, consultez la section Exemples de règles : stratégie de test de disponibilité.
    
    Cochez la case Valider les certificats SSL.
Cliquez sur Continuer, puis configurez les exigences concernant les réponses. Tous les paramètres de cette section ont des valeurs par défaut:
- Pour modifier le délai avant expiration du test de disponibilité, utilisez le champ Délai avant expiration de la réponse. Un test de disponibilité échoue si aucune réponse n'est reçue de plusieurs emplacements dans ce délai.
  
  Remarque : Si vous créez des vérifications par rapport à des URL de redirection, augmentez le délai avant expiration de la réponse à 30 secondes ou plus.
- Pour configurer le test de disponibilité afin d'effectuer une correspondance de contenu, assurez-vous que le libellé d'activation est La correspondance de contenu est activée :
  - Dans le menu des options, sélectionnez Type de correspondance de contenu de la réponse. Ce champ détermine comment le contenu de la réponse est comparé aux données renvoyées. Par exemple, supposons que le contenu de la réponse soit abcd et le type de correspondance de contenu est Contient. Le test de disponibilité fonctionne uniquement lorsque les données de réponse contiennent abcd. Pour en savoir plus, consultez Validez les données de réponse.
  - Saisissez le contenu de la réponse. Le contenu de la réponse doit être une chaîne de 1 024 octets maximum. Dans l'API, ce champ est objet ContentMatcher.
  Remarque : Activez la correspondance du contenu de la réponse lorsque vous sélectionnez le protocole TCP.
- Pour éviter la création d'entrées de journal en raison de tests de disponibilité, Supprimez Échecs de la vérification du journal.
- Pour les tests de disponibilité HTTP, configurez les codes de réponse acceptables. Par défaut, les tests de disponibilité HTTP 2xx en tant que réponse positive.
Cliquez sur Continuer, puis configurez les notifications.

Pour être averti en cas d'échec d'un test de disponibilité, créez une règle d'alerte et configurez des canaux de notification pour cette règle :
1. Facultatif : modifiez le nom de la règle d'alerte.
2. Facultatif : Dans le champ Durée, sélectionnez la durée pendant laquelle les tests de disponibilité doivent échouer avant l'envoi de notifications. Par défaut, des notifications sont envoyées lorsqu'au moins deux régions signalent des échecs de test de disponibilité pendant au moins une minute.
3. Dans la zone Canaux de notification, cliquez sur Menu, sélectionnez les canaux à ajouter, puis cliquez sur OK.
  
  Dans le menu, les canaux de notification sont regroupés par ordre alphabétique pour chaque type de canal.
Si vous ne souhaitez pas créer de règle d'alerte, assurez-vous que le texte du bouton d'activation est Ne pas créer d'alerte.
Cliquez sur Continuer et effectuez votre test de disponibilité :
1. Saisissez un titre descriptif pour le test de disponibilité.
2. Facultatif : Pour ajouter des libellés définis par l'utilisateur à votre test de disponibilité, procédez comme suit :
  1. Cliquez sur Afficher les libellés utilisateur.
  2. Dans le champ Clé, saisissez le nom du libellé. Les noms de libellé doivent commencer par une lettre minuscule et peuvent contenir des lettres minuscules, des chiffres, des traits de soulignement et des tirets. Par exemple, saisissez severity.
  3. Dans le champ Valeur, saisissez une valeur pour votre libellé. Valeurs des étiquettes peut contenir lettres minuscules, chiffres, traits de soulignement et tirets. Par exemple, saisissez critical.
  4. Pour chaque libellé supplémentaire, cliquez sur Ajouter un libellé utilisateur, puis saisissez la clé et la valeur du libellé.
3. Pour vérifier la configuration du test disponibilité, cliquez sur Test (Tester). Si le résultat ne correspond pas à vos attentes, consultez la section Échec du test, corrigez votre configuration, puis effectuez à nouveau l'étape de vérification.
4. Cliquez sur Créer. Si vous sélectionnez Créer et qu'aucun champ obligatoire n'est renseigné, un message d'erreur s'affiche.

gcloud

Pour créer le test de disponibilité, exécutez la commande gcloud monitoring uptime create :

gcloud monitoring uptime create DISPLAY_NAME REQUIRED_FLAGS OPTIONAL_FLAGS

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

Remplacez DISPLAY_NAME par le nom de votre vérification de l'état de disponibilité.
Configurez REQUIRED_FLAGS pour spécifier la ressource vérifiée par le test de disponibilité. Par exemple, la commande suivante crée un test de disponibilité qui teste l'URL EXAMPLE.com pour une un projet particulier:
```
gcloud monitoring uptime create DISPLAY_NAME \
--resource-labels=host=EXAMPLE.com,project_id=PROJECT_ID \
--resource-type=uptime-url
```
La commande précédente spécifie les valeurs pour chaque libellé requis par le type de ressource uptime-url.

Remarque : Dans la commande précédente, définissez le champ resource-type sur uptime-url, n'utilisez pas uptime_url. Les commandes Google Cloud CLI ne suivent pas les mêmes conventions de dénomination que Cloud Monitoring. Pour obtenir la liste des valeurs valides du champ resource-type, consultez la documentation sur gcloud monitoring uptime create.
Configurez les indicateurs OPTIONAL_FLAGS pour remplacer les valeurs par défaut. Par exemple, vous devez définir l'option --protocol lorsque le n'est pas http.

API

Pour créer un test de disponibilité, appelez la méthode projects.uptimeCheckConfigs.create. Définissez les paramètres de la méthode comme suit :

parent : obligatoire. Il doit s'agir du nom du projet dans lequel créer le test de disponibilité. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud. Il a le format suivant :
```
projects/PROJECT_ID
```
Le corps de la requête doit contenir un objet UptimeCheckConfig pour le nouveau test de disponibilité. Cette page fournit des informations sur quelques champs. Pour obtenir une documentation complète sur cet objet et ses champs, consultez la page UptimeCheckConfig :
- Laissez le champ name de l'objet de configuration vide. Le système définit ce champ lors de la construction de l'objet de configuration de la réponse.
- Si vous configurez une vérification HTTP ou HTTPS, vous devez renseigner le champ HttpCheck de l'objet UptimeCheckConfig. Dans cet objet, définissez le champ requestMethod sur GET ou POST. Si ce champ est omis ou défini sur METHOD_UNSPECIFIED, une requête GET est émise.
  
  Si vous configurez une requête POST, effectuez contentType, facultatif customContentType body.

La méthode create renvoie l'objet UptimeCheckConfig pour la nouvelle configuration.

Si la configuration du temps d'activité créé ne fonctionne pas comme prévu, consultez Échec du test de cette page.

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 CreateUptimeCheck(string projectId, string hostName,
    string displayName)
{
    // Define a new config.
    var config = new UptimeCheckConfig()
    {
        DisplayName = displayName,
        MonitoredResource = new MonitoredResource()
        {
            Type = "uptime_url",
            Labels = { { "host", hostName } }
        },
        HttpCheck = new UptimeCheckConfig.Types.HttpCheck()
        {
            Path = "/",
            Port = 80,
        },
        Timeout = TimeSpan.FromSeconds(10).ToDuration(),
        Period = TimeSpan.FromMinutes(5).ToDuration()
    };
    // Create a client.
    var client = UptimeCheckServiceClient.Create();
    ProjectName projectName = new ProjectName(projectId);
    // Create the config.
    var newConfig = client.CreateUptimeCheckConfig(
        projectName,
        config,
        CallSettings.FromExpiration(
            Expiration.FromTimeout(
                TimeSpan.FromMinutes(2))));
    Console.WriteLine(newConfig.Name);
    return 0;
}

Java

private static void createUptimeCheck(
    String projectId, String displayName, String hostName, String pathName) throws IOException {
  CreateUptimeCheckConfigRequest request =
      CreateUptimeCheckConfigRequest.newBuilder()
          .setParent(ProjectName.format(projectId))
          .setUptimeCheckConfig(
              UptimeCheckConfig.newBuilder()
                  .setDisplayName(displayName)
                  .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.createUptimeCheckConfig(request);
    System.out.println("Uptime check created: " + config.getName());
  } catch (Exception e) {
    usage("Exception creating uptime check: " + e.toString());
    throw e;
  }
}

Go


// createGet creates an example uptime check on a GET request.
func createGet(w io.Writer, projectID 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.CreateUptimeCheckConfigRequest{
		Parent: "projects/" + projectID,
		UptimeCheckConfig: &monitoringpb.UptimeCheckConfig{
			DisplayName: "new GET uptime check",
			Resource: &monitoringpb.UptimeCheckConfig_MonitoredResource{
				MonitoredResource: &monitoredres.MonitoredResource{
					Type: "uptime_url",
					Labels: map[string]string{
						"host": "example.com",
					},
				},
			},
			CheckRequestType: &monitoringpb.UptimeCheckConfig_HttpCheck_{
				HttpCheck: &monitoringpb.UptimeCheckConfig_HttpCheck{
					RequestMethod: monitoringpb.UptimeCheckConfig_HttpCheck_GET,
					Path:          "/",
					Port:          80,
				},
			},
			Timeout: &duration.Duration{Seconds: 10},
			Period:  &duration.Duration{Seconds: 300},
		},
	}
	config, err := client.CreateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateUptimeCheckConfig GET: %w", err)
	}
	fmt.Fprintf(w, "Successfully created GET uptime check %q\n", config.GetDisplayName())
	return config, nil
}

// createPost creates an example uptime check on a POST request.
func createPost(w io.Writer, projectID 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.CreateUptimeCheckConfigRequest{
		Parent: "projects/" + projectID,
		UptimeCheckConfig: &monitoringpb.UptimeCheckConfig{
			DisplayName: "new POST uptime check",
			Resource: &monitoringpb.UptimeCheckConfig_MonitoredResource{
				MonitoredResource: &monitoredres.MonitoredResource{
					Type: "uptime_url",
					Labels: map[string]string{
						"host": "example.com",
					},
				},
			},
			CheckRequestType: &monitoringpb.UptimeCheckConfig_HttpCheck_{
				HttpCheck: &monitoringpb.UptimeCheckConfig_HttpCheck{
					RequestMethod: monitoringpb.UptimeCheckConfig_HttpCheck_POST,
					ContentType:   monitoringpb.UptimeCheckConfig_HttpCheck_URL_ENCODED,
					Path:          "/",
					Port:          80,
					Body:          []byte(base64.URLEncoding.EncodeToString([]byte("key: value"))),
				},
			},
			Timeout: &duration.Duration{Seconds: 10},
			Period:  &duration.Duration{Seconds: 300},
		},
	}
	config, err := client.CreateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateUptimeCheckConfig POST: %w", err)
	}
	fmt.Fprintf(w, "Successfully created POST uptime check %q\n", config.GetDisplayName())
	return config, 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 hostname = 'mydomain.com';

const request = {
  // i.e. parent: 'projects/my-project-id'
  parent: client.projectPath(projectId),
  uptimeCheckConfig: {
    displayName: 'My Uptime Check',
    monitoredResource: {
      // See the Uptime Check docs for supported MonitoredResource types
      type: 'uptime_url',
      labels: {
        host: hostname,
      },
    },
    httpCheck: {
      path: '/',
      port: 80,
    },
    timeout: {
      seconds: 10,
    },
    period: {
      seconds: 300,
    },
  },
};

// Creates an uptime check config for a GCE instance
const [uptimeCheckConfig] = await client.createUptimeCheckConfig(request);
console.log('Uptime check created:');
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\Api\MonitoredResource;
use Google\Cloud\Monitoring\V3\Client\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\CreateUptimeCheckConfigRequest;
use Google\Cloud\Monitoring\V3\UptimeCheckConfig;

/**
 * Example:
 * ```
 * create_uptime_check($projectId, 'myproject.appspot.com', 'Test Uptime Check!');
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $hostName
 * @param string $displayName
 */
function create_uptime_check($projectId, $hostName = 'example.com', $displayName = 'New uptime check')
{
    $projectName = 'projects/' . $projectId;
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $monitoredResource = new MonitoredResource();
    $monitoredResource->setType('uptime_url');
    $monitoredResource->setLabels(['host' => $hostName]);

    $uptimeCheckConfig = new UptimeCheckConfig();
    $uptimeCheckConfig->setDisplayName($displayName);
    $uptimeCheckConfig->setMonitoredResource($monitoredResource);
    $createUptimeCheckConfigRequest = (new CreateUptimeCheckConfigRequest())
        ->setParent($projectName)
        ->setUptimeCheckConfig($uptimeCheckConfig);

    $uptimeCheckConfig = $uptimeCheckClient->createUptimeCheckConfig($createUptimeCheckConfigRequest);

    printf('Created an uptime check: %s' . PHP_EOL, $uptimeCheckConfig->getName());
}

Python

def create_uptime_check_config_get(
    project_id: str, host_name: str = None, display_name: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        project_id: Google Cloud project id where the uptime check is created
        host_name: An example label's value for the "host" label
        display_name: A human friendly name of the configuration

    Returns:
        A structure that describes a new created uptime check
    """
    config = monitoring_v3.UptimeCheckConfig()
    config.display_name = display_name or "New GET uptime check"
    config.monitored_resource = {
        "type": "uptime_url",
        "labels": {"host": host_name or "example.com"},
    }
    config.http_check = {
        "request_method": monitoring_v3.UptimeCheckConfig.HttpCheck.RequestMethod.GET,
        "path": "/",
        "port": 80,
    }
    config.timeout = {"seconds": 10}
    config.period = {"seconds": 300}

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(
        request={"parent": project_id, "uptime_check_config": config}
    )
    pprint.pprint(new_config)
    return new_config


def create_uptime_check_config_post(
    project_id: str, host_name: str = None, display_name: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        project_id: Google Cloud project id where the uptime check is created
        host_name: An example label's value for the "host" label
        display_name: A human friendly name of the configuration

    Returns:
        A structure that describes a new created uptime check
    """
    config = monitoring_v3.UptimeCheckConfig()
    config.display_name = display_name or "New POST uptime check"
    config.monitored_resource = {
        "type": "uptime_url",
        "labels": {"host": host_name or "example.com"},
    }
    config.http_check = {
        "request_method": monitoring_v3.UptimeCheckConfig.HttpCheck.RequestMethod.POST,
        "content_type": monitoring_v3.UptimeCheckConfig.HttpCheck.ContentType.URL_ENCODED,
        "body": "foo=bar".encode("utf-8"),
        "path": "/",
        "port": 80,
    }
    config.timeout = {"seconds": 10}
    config.period = {"seconds": 300}

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(
        request={"parent": project_id, "uptime_check_config": config}
    )
    pprint.pprint(new_config)
    return new_config

Ruby

def create_uptime_check_config project_id: nil, host_name: nil, display_name: nil
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  project_name = client.project_path project: project_id
  config = {
    display_name:       display_name.nil? ? "New uptime check" : display_name,
    monitored_resource: {
      type:   "uptime_url",
      labels: { "host" => host_name.nil? ? "example.com" : host_name }
    },
    http_check:         { path: "/", port: 80 },
    timeout:            { seconds: 10 },
    period:             { seconds: 300 }
  }
  new_config = client.create_uptime_check_config \
    parent:              project_name,
    uptime_check_config: config
  puts new_config.name
  new_config
end

Terraform

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base. Pour en savoir plus, consultez la documentation de référence du fournisseur Terraform.

Pour créer un test de disponibilité et une règle d'alerte pour le surveiller, effectuer les opérations suivantes:

Modifiez votre fichier de configuration Terraform et ajoutez un google_monitoring_uptime_check_config ressource, puis appliquez le fichier de configuration.

L'exemple suivant présente une configuration qui vérifie URL publique:

resource "google_monitoring_uptime_check_config" "example" {
    display_name = "example"
    timeout      = "60s"

    http_check {
        port = "80"
        request_method = "GET"
    }

    monitored_resource {
        type = "uptime_url"
        labels = {
            project_id = "PROJECT_ID"
            host="EXAMPLE.com"
        }
    }

    checker_type = "STATIC_IP_CHECKERS"
}

Facultatif : Créez un canal de notification et une règle d'alerte :

Les étapes suivantes utilisent la console Google Cloud pour créer le canal de notification et la règle d'alerte. Cette approche garantit que la règle d'alerte ne surveille que les données générées par votre test de disponibilité.
1. Pour créer un canal de notification, procédez comme suit:
  1. Dans la console Google Cloud, accédez à la page Alertes :
    Accéder à l'interface des alertes
    
    Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.
  2. Sélectionnez Gérer les canaux de notification.
  3. Accédez au type de chaîne que vous souhaitez ajouter, cliquez sur Ajouter, puis puis terminez la boîte de dialogue.
2. Pour créer une règle d'alerte, procédez comme suit :
  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. Recherchez votre test de disponibilité, sélectionnez Plus, puis Ajouter une règle d'alerte.
  3. Dans la boîte de dialogue, accédez à la section Notifications et nom, développez Canaux de notification, puis effectuez vos sélections.
  4. Attribuez un nom à la règle d'alerte, puis cliquez sur Créer une règle.
Vous pouvez créer une règle d'alerte en ajoutant un google_monitoring_alert_policy à votre fichier de configuration et en appliquant la nouvelle configuration.

Il peut s'écouler jusqu'à 5 minutes avant que les résultats du test de disponibilité ne commencent à parvenir à Monitoring. Pendant ce temps, le tableau de bord du test de disponibilité indique l'état "aucune donnée disponible".

Utiliser des pings ICMP

Pour vous aider à résoudre les problèmes de test de disponibilité public ayant échoué, vous pouvez configurer vos tests de disponibilité pour qu'ils envoient jusqu'à trois pings ICMP pendant le test. Les pings peuvent vous aider à distinguer des défaillances causées, par exemple, par des problèmes de connectivité réseau et par des délais avant expiration dans votre application.

Par défaut, les tests de disponibilité n'envoient pas de pings. Chaque ping ajoute la latence du test de disponibilité. Les tests de disponibilité privés ne peuvent pas envoyer de pings.

Lorsqu'un test de disponibilité public échoue, les résultats des pings sont consignés dans les journaux Cloud Logging. Si le ping échoue, les champs suivants sont ajoutés au champ httpRequest dans l'entrée de journal :

rtt_usec: délai aller-retour pour chaque requête ping ayant échoué.
unreachable_count: nombre de requêtes ping ayant renvoyé le code d'état ICMP_DEST_UNREACH.
no_answer_count : nombre de requêtes ping ayant expiré et n'ayant renvoyé aucune réponse.

Les résultats des pings indiquant la réussite des tests de disponibilité ne sont pas consignés.

Configurer les pings

Chaque configuration de test de disponibilité inclut un objet HttpCheck ou un objet TcpCheck. Ces deux objets incluent un champ pingConfig. Utilisez ce champ pour spécifier le nombre de pings ICMP à inclure dans chaque vérification. jusqu'à 3. Par défaut, aucun ping n'est envoyé.

Pour configurer les pings, effectuez l'une des opérations suivantes:

Lorsque vous utilisez la console Google Cloud, développez Autres options de cible et saisissez une valeur dans le champ Pings ICMP.
Lorsque vous utilisez l'API Cloud Monitoring, utiliser l'objet PingConfig ; qui présente la structure suivante:
```
{
  "pingsCount": integer
}
```
Pour en savoir plus sur l'utilisation de l'API Monitoring pour les configurations de vérification de l'état de fonctionnement, consultez Créer une vérification de l'état de fonctionnement : API ou Modifier une vérification de l'état de fonctionnement : API.

Vérifier le test de disponibilité

Lorsque vous créez un test de disponibilité dans la console Google Cloud, vous vous pouvez tester la configuration avant de l'enregistrer.

Vérifications réussies