Créer des tests de disponibilité publics

Console

Pour créer un test de disponibilité à l'aide de la console Google Cloud, 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. Cliquez sur Create Uptime Check (Créer un test de disponibilité).

   

3. 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.

   3. Renseignez les champs spécifiques au protocole :

      • Pour les vérifications TCP, saisissez le port.

      • Pour les vérifications HTTP et HTTPS, vous pouvez saisir un chemin d'accès dans votre hôte ou votre 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 émettre 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 (Chemin d'accès) 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.

      • 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é à 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 le champ Check frequency (Fréquence de vérification).

   6. Facultatif: Pour sélectionner des régions de vérification ou des certificats SSL, l'authentification, les en-têtes et les ports 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 comporte trois vérificateurs. Le paramètre par défaut, Global, inclut 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 vérifications 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 ce 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.

        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: 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 pour une ressource d'URL, le service tente par défaut de se connecter via HTTPS et valide le certificat SSL. Les tests de disponibilité échouent si une URL comporte un certificat non valide. Un certificat peut ne pas être valide pour diverses raisons:

        • Un certificat expiré
        • Un certificat autosigné
        • Certificat avec erreur de correspondance du nom de domaine
        • Certificat qui utilise l'extension AIA (Authority Information Access).

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

4. 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.

   • Pour configurer le test de disponibilité pour effectuer une correspondance de contenu, assurez-vous que le libellé d'activation est La correspondance de contenu est activée:

     • Sélectionnez le type de correspondance du contenu de la réponse dans le menu des options. 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 de contenu soit Contient. Le test de disponibilité n'aboutit que lorsque les données de réponse contiennent abcd. Pour en savoir plus, consultez 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 maximum. Dans l'API, ce champ est l'objet ContentMatcher.

   • Pour empêcher la création d'entrées de journal en raison de tests de disponibilité, effacez Échecs de vérification du journal.

   • Pour les vérifications de disponibilité HTTP, configurez les codes de réponse acceptés. Par défaut, les tests de disponibilité HTTP marquent toute réponse 2xx comme une réponse réussie.

5. 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 vérifications 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 arrow_drop_down 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.

6. 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 expand_more Afficher les étiquettes utilisateur.
      2. Dans le champ Clé, saisissez un nom pour le 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é. Les valeurs de libellé peuvent contenir des lettres minuscules, des chiffres, des traits de soulignement et des 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'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 vérification de l'état de disponibilité.

• Configurez REQUIRED_FLAGS pour spécifier la ressource explorée par le test de disponibilité. Par exemple, la commande suivante crée une vérification de l'état 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 les valeurs pour chaque libellé requis par le type de ressource uptime-url.

• Configurez les indicateurs OPTIONAL_FLAGS pour remplacer les valeurs par défaut. Par exemple, vous devez définir l'indicateur --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 facultatif 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

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

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.

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

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

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

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

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 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, procédez comme suit:

1. Modifiez votre fichier de configuration Terraform et 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"
   }
   

2. 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 notificationsAlertes :

         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 canal que vous souhaitez ajouter, cliquez sur Ajouter, puis remplissez 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 more_vert 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 une ressource google_monitoring_alert_policy à votre fichier de configuration et en appliquant la nouvelle configuration.