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 à travers le monde vers des URL accessibles au public ou des ressources Google Cloud pour voir si la ressource répond. Pour en savoir plus sur la création de tests de disponibilité pour les réseaux privés, consultez la page Créer des tests de disponibilité privés.

Les tests de disponibilité publics peuvent déterminer la disponibilité des ressources surveillées 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 contenu requis, ou le contenu requis est présent.

Les tests de disponibilité ne chargent pas les éléments de page ni n'exécutent JavaScript. De plus, la configuration par défaut d'un test de disponibilité n'inclut pas l'authentification.

Avant de commencer

Pour obtenir les autorisations nécessaires pour créer des tests de disponibilité, demandez à votre administrateur de vous attribuer les rôles IAM suivants sur votre projet:
- Éditeur Monitoring (roles/monitoring.editor) - Utilisateurs de la console Google Cloud
- Éditeur de configuration des 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 section Gérer les accès.

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 à vérifier possède 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 la page Créer des tests de disponibilité privés.
Lorsque votre ressource se trouve derrière un pare-feu, configurez-le de manière à autoriser le trafic entrant provenant des adresses IP des serveurs de tests de disponibilité. Pour en savoir plus, consultez la section Répertorier les adresses IP des serveurs de tests de disponibilité.
Configurez les canaux de notification que vous souhaitez utiliser pour recevoir des 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 pour les tests de disponibilité inclut les régions USA_OREGON, USA_IOWA et USA_VIRGINIA. Chacune des régions USA_* comporte un vérificateur, et USA inclut les trois. Les autres régions pour les tests de disponibilité, EUROPE, SOUTH_AMERICA et ASIA_PACIFIC, disposent chacune d'un vérificateur.

Si vous sélectionnez Mondial dans la console Google Cloud ou REGION_UNSPECIFIED avec l'API, les tests de disponibilité sont émis à partir de toutes les régions concernées.

Créer un test de disponibilité

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

Si vous souhaitez créer un test de disponibilité pour un équilibreur de charge externe sur lequel au moins un port TCP ou HTTP/S est configuré, suivez les instructions ci-dessous. Vous pouvez également accéder à la page Informations sur le service du service, puis cliquer sur Créer un test de disponibilité. Lorsque vous commencez à partir de la page Informations sur le 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 le panneau de navigation de la console Google Cloud, sélectionnez Monitoring, puis Tests de disponibilité:
Accéder aux tests de disponibilité
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 Internal IP (Adresse IP interne), car ce type de ressource ne peut pas être la 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 d'accès dans 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 Hostname (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é au gestionnaire "/", laissez le champ Chemin d'accès vide. Pour émettre le test de disponibilité au gestionnaire /hello, définissez la valeur du champ Path sur /hello.
4. Renseignez les champs spécifiques à la ressource :
  - Pour les ressources URL, saisissez le nom d'hôte dans le champ Nom d'hôte. Par exemple, saisissez example.com.
    
    Remarque :Créez des vérifications par rapport à des URL directes si possible.
  - Pour les ressources App Engine, saisissez le nom du service dans le champ Service.
  - Pour les ressources Elastic Load Balancer et Instance, renseignez le champ S'applique à comme suit:
    - Pour émettre un test de disponibilité sur une seule instance ou un seul équilibreur de charge, sélectionnez Unique, puis utilisez le menu pour sélectionner l'instance ou l'équilibreur de charge spécifique.
    - Pour envoyer un test de disponibilité à un groupe Monitoring, sélectionnez Group (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 le champ Fréquence de vérification.
6. Facultatif: Pour sélectionner des régions du vérificateur ou pour configurer des certificats, une authentification, des en-têtes et des ports SSL pour les vérifications HTTP et HTTPS, cliquez sur Autres options de cible:
  - 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, à l'exception des États-Unis, qui en comptent trois. Le paramètre par défaut, Mondial, inclut toutes les régions.
  - Pings ICMP: configurez le test de disponibilité pour qu'il envoie jusqu'à trois pings. Pour en savoir plus, consultez la section 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 tests POST HTTP, saisissez le corps encodé au format URL. Vous devez effectuer l'encodage vous-même. Pour toutes les autres vérifications, laissez ce champ vide.
  - Host header (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 l'en-tête "Authorization". Si vous définissez les champs Authentication (Authentification) et 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 un seul mot de passe. Les mots de passe sont toujours masqués dans le formulaire.
    - Authentification de l'agent de service: lorsque cette option 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 pour une ressource d'URL, le service tente par défaut de se connecter via HTTPS et de valider le certificat SSL. Les tests de disponibilité échouent lorsqu'une URL comporte un certificat non valide. Un certificat peut être non valide pour les raisons suivantes:
    - Un certificat arrivé à expiration
    - Un certificat autosigné
    - Un certificat dont le nom de domaine ne correspond pas
    - Un certificat qui utilise l'extension Authority Information Access (AIA).
    Remarque :Une certification SSL révoquée n'est pas considérée comme non valide.
    
    Pour forcer un test de disponibilité HTTPS afin de valider le certificat SSL, sélectionnez Valider les certificats SSL.
    
    Pour désactiver la validation des certificats SSL, désélectionnez la case Valider les certificats SSL.
    
    Si vous disposez de certificats SSL avec des 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 et configurez les exigences de réponse. 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 lorsqu'aucune réponse n'est reçue de la part de plusieurs emplacements au cours de cette période.
  
  Remarque :Si vous créez des tests par rapport à des URL de redirection, définissez le délai d'expiration de la réponse sur 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 Le contenu est activé:
  - Dans le menu des options, sélectionnez le type de correspondance du 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 que le type de correspondance du contenu soit Contient. Le test de disponibilité ne réussit que si les données de la réponse contiennent abcd. Pour en savoir plus, consultez la section Valider 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 au maximum. Dans l'API, ce champ correspond à l'objet ContentMatcher.
  Remarque :Activez la mise en correspondance du contenu de la réponse lorsque vous sélectionnez le protocole TCP.
- Pour empêcher la création d'entrées de journal en raison des tests de disponibilité, désélectionnez Échecs de la vérification des journaux.
- Pour les tests de disponibilité HTTP, configurez les codes de réponse acceptables. Par défaut, les tests de disponibilité HTTP marquent n'importe quelle réponse 2xx comme une réponse réussie.
Cliquez sur Continuer et configurez les notifications.

Pour être averti lorsqu'un test de disponibilité échoue, créez une règle d'alerte et configurez des canaux de notification pour cette règle:
1. (Facultatif) Mettez à jour le nom de la règle d'alerte.
2. Facultatif: Dans le champ Duration (Durée), sélectionnez la durée pendant laquelle les tests de disponibilité doivent échouer avant l'envoi de notifications. Par défaut, les notifications sont envoyées lorsqu'au moins deux régions signalent des échecs de tests de disponibilité pendant une durée minimale d'une minute.
3. Dans la zone intitulée 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 bien Do not create an alert (Ne pas créer d'alerte).
Cliquez sur Continuer et effectuez le test de disponibilité:
1. Saisissez un titre descriptif pour le test de disponibilité.
2. Facultatif: Pour ajouter des étiquettes définies 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 d'étiquettes 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 la valeur du libellé. Les valeurs d'étiquette peuvent contenir des lettres minuscules, des chiffres, des traits de soulignement et des tirets. Par exemple, saisissez critical.
  4. Pour chaque étiquette supplémentaire, cliquez sur Ajouter une étiquette 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 Vérifier les échecs, corrigez votre configuration, puis répétez l'étape de vérification.
4. Cliquez sur Créer. Si vous sélectionnez Créer et qu'un champ obligatoire n'est pas 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 test de disponibilité.
Configurez REQUIRED_FLAGS pour spécifier la ressource examinée par le test de disponibilité. Par exemple, la commande suivante crée un test de disponibilité qui teste l'URL EXAMPLE.com pour 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 des valeurs pour chaque libellé requis par le type de ressource uptime_url.
Configurez les options OPTIONAL_FLAGS pour remplacer les valeurs par défaut. Par exemple, vous devez définir l'option --protocol lorsque le protocole 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, renseignez les champs contentType, customContentType facultatifs et body.

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

Si la configuration du test de disponibilité créé ne fonctionne pas comme prévu, consultez la section É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 permettant de le surveiller, procédez comme suit:

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

L'exemple suivant illustre une configuration qui vérifie une 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 le test de disponibilité.
1. Pour créer un canal de notification, procédez comme suit:
  1. Dans le panneau de navigation de la console Google Cloud, sélectionnez Monitoring, puis Alertes :
    Accéder à l'interface des alertes
  2. Sélectionnez Gérer les canaux de notification.
  3. Accédez au type de canal que vous souhaitez ajouter, cliquez sur Ajouter, puis renseignez la boîte de dialogue.
2. Pour créer une règle d'alerte, procédez comme suit :
  1. Dans le panneau de navigation de la console Google Cloud, sélectionnez Monitoring, puis Tests de disponibilité:
    Accéder aux tests de disponibilité
  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 et effectuez vos sélections.
  4. Nommez la règle d'alerte, puis cliquez sur Créer une règle.
Pour créer une règle d'alerte, ajoutez une ressource google_monitoring_alert_policy à votre fichier de configuration et appliquez 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 liés aux échecs des tests de disponibilité publics, vous pouvez les configurer de sorte qu'ils envoient jusqu'à trois pings ICMP au cours du test. Les pings peuvent vous aider à distinguer les défaillances dues, par exemple, à des problèmes de connectivité réseau et à des délais d'inactivité de votre application.

Par défaut, les tests de disponibilité n'envoient pas de pings. Chaque ping ajoute une certaine latence au 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 écrits 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 qui ont expiré et n'ont renvoyé aucune réponse.

Les résultats des pings pour les tests de disponibilité réussis ne sont pas consignés.

Configurer les pings

Chaque configuration de test de disponibilité inclut un objet HttpCheck ou TcpCheck. Ces deux objets incluent un champ pingConfig. Utilisez ce champ pour spécifier le nombre de pings ICMP à inclure à 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, utilisez l'objet PingConfig, dont la structure est la suivante:
```
{
  "pingsCount": integer
}
```
Pour en savoir plus sur l'utilisation de l'API Monitoring pour les configurations de tests de disponibilité, consultez la page Créer un test de disponibilité: API ou Modifier un test de disponibilité: API.

Vérifier le test de disponibilité

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

Vérifications réussies

Un test de disponibilité réussit lorsque les conditions suivantes sont remplies:

L'état HTTP correspond aux critères sélectionnés.
La réponse n'a pas de contenus obligatoires, ou la recherche des contenus obligatoires dans la réponse a abouti.

Vérifications ayant échoué

Voici des causes possibles de l'échec d'un test de disponibilité :

Erreur de connexion - Refusée : si vous utilisez le type de connexion HTTP par défaut, vérifiez qu'un serveur Web est installé et qu'il répond aux requêtes HTTP. Une erreur de connexion peut se produire sur une nouvelle instance si vous n'avez pas installé de serveur Web. Consultez la section Démarrage rapide pour Compute Engine. Si vous utilisez le type de connexion HTTPS, vous devrez peut-être effectuer des étapes de configuration supplémentaires. Pour les problèmes de pare-feu, consultez la section Répertorier les adresses IP des serveurs de tests de disponibilité.
Nom ou service introuvable : le nom d'hôte est peut-être incorrect.
403 (interdit) : le service renvoie un code d'erreur au vérificateur de tests de disponibilité. Par exemple, la configuration par défaut du serveur Web Apache renvoie ce code sous Amazon Linux, mais elle renvoie le code 200 (succès) sous d'autres versions de Linux. Consultez le tutoriel LAMP pour Amazon Linux ou la documentation de votre serveur Web.
404 (introuvable) : le chemin d'accès est peut-être incorrect.
408 (Délai avant expiration de la requête) ou absence de réponse : le numéro de port est peut-être incorrect, le service ne fonctionne peut-être pas ou est peut-être inaccessible, ou le délai avant expiration est peut-être trop court. Vérifiez que votre pare-feu autorise le trafic provenant de serveurs de tests de disponibilité. Consultez la section Répertorier les adresses IP des serveurs de tests de disponibilité. Le délai avant expiration est spécifié dans les options de validation de réponse.

Si votre test de disponibilité est configuré pour envoyer des pings, les résultats des pings des tests de disponibilité ayant échoué sont écrits dans Cloud Logging. Pour en savoir plus, consultez la section Utiliser des pings ICMP.