Creare controlli di uptime pubblici

Console

Per creare un controllo di uptime utilizzando la console Google Cloud:

1. Nella console Google Cloud, vai alla pagina  Controlli di uptime:

   Vai a Controlli di uptime

   Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.

2. Fai clic su Crea controllo di uptime.

   

3. Specifica il target del controllo di uptime:

   1. Seleziona il protocollo. Puoi selezionare HTTP, HTTPS o TCP.

   2. Scegli uno dei seguenti tipi di risorse:

      • URL: qualsiasi nome host o indirizzo IPv4. Percorso e porta vanno inseriti separatamente.
      • Servizio LoadBalancer Kubernetes: servizio Kubernetes di tipo LoadBalancer.
      • Istanza: istanze Compute Engine o AWS EC2.
      • App Engine: applicazioni (moduli) App Engine.
      • Elastic Load Balancer: bilanciatore del carico AWS.

   3. Inserisci i campi specifici del protocollo:

      • Per i controlli TCP, inserisci la porta.

      • Per i controlli HTTP e HTTPS, puoi inserire un percorso all'interno dell'host o della risorsa. Tutti i controlli di uptime che utilizzano questi protocolli inviano una richiesta a http://target/path. In questa expressione, per una risorsa URL, target è un nome host o un indirizzo IP. Per una risorsa App Engine, target è un nome host derivato dal nome del servizio. Per le risorse di istanze e bilanciatori del carico, target è un indirizzo IP ricavato dal nome fornito per la risorsa o il gruppo di risorse.

        Se lasci vuoto il campo path o se imposti il valore su /, la richiesta viene inviata a http://target/.

        Ad esempio, per eseguire un controllo di uptime della risorsa URLexample.com/tester, imposta il campo Nome host su example.com e il campo Percorso su /tester.

        Supponiamo che tu abbia eseguito il deployment di un server in App Engine con un dispatcher che supporta / e /hello. Per emettere il controllo di uptime all'handler '/', lascia vuoto il campo Percorso. Per emettere il controllo del tempo di attività all'handler /hello, imposta il valore del campo Path su /hello.

   4. Inserisci i campi specifici della risorsa:

      • Per le risorse URL, inserisci il nome host nel campo Nome host. Ad esempio, inserisci example.com.

      • Per le risorse App Engine, inserisci il nome del servizio nel campo Servizio.

      • Per le risorse Elastic Load Balancer e Instance, compila il campo Si applica a come segue:

        • Per eseguire un controllo di uptime su una singola istanza o un singolo bilanciatore del carico, selezionare Singolo e utilizzare il menu per selezionare l'istanza o il bilanciatore del carico specifico.
        • Per eseguire un controllo di uptime in un gruppo di monitoraggio, selezionare Gruppo e utilizzare il menu per selezionare il nome del gruppo.

   5. (Facoltativo) Per impostare la frequenza di esecuzione del controllo dell'uptime, utilizza il campo Frequenza controllo.

   6. (Facoltativo) Per selezionare le regioni dei controlli o per configurare i certificati SSL, l'autenticazione, le intestazioni e le porte per i controlli HTTP e HTTPS, fai clic su Altre opzioni di destinazione:

      • Regioni: seleziona le regioni in cui devono essere ricevute le richieste per i controlli di uptime. Un controllo di uptime deve avere almeno tre controlli. È presente un ispettore in tutte le regioni, tranne negli Stati Uniti, che ne ha tre. L'impostazione predefinita, Globale, include tutte le regioni.
      • Ping ICMP: configura il controllo di uptime in modo da inviare fino a tre ping. Per ulteriori informazioni, consulta Utilizzare i ping ICMP.
      • Metodo richiesta: per i controlli HTTP, seleziona il metodo di richiesta.
      • Testo:per i controlli POST HTTP, inserisci il corpo codificato per l'URL. Devi eseguire la codifica autonomamente. Per tutti gli altri controlli, lascia vuoto questo campo.
      • Intestazione host: compila questo campo per controllare gli host virtuali. Questo campo non è disponibile per i controlli TCP.
      • Porta: specifica un numero di porta.
      • Intestazioni personalizzate: fornisci intestazioni personalizzate e, se lo desideri, criptale. La crittografia nasconde i valori dell'intestazione nel modulo. Utilizza la crittografia per le intestazioni relative all'autenticazione che non vuoi rendere visibili ad altri.

      • Autenticazione: questi valori vengono inviati come intestazione di autorizzazione. Questo campo non è disponibile per i controlli TCP.

        Scegli una delle seguenti opzioni:

        • Autenticazione di base: fornisci un singolo nome utente e una singola password. Le password sono sempre nascoste nel modulo.
        • Autenticazione dell'agente di servizio: se abilitata, viene generato un token di identità per l'agente di servizio di monitoraggio. Questa opzione è disponibile solo per i controlli HTTPS.

      • Convalida del certificato SSL: se hai selezionato HTTPS per una risorsa URL, per impostazione predefinita il servizio tenta di connettersi tramite HTTPS e convalidare il certificato SSL. I controlli di uptime non riescono quando un URL ha un certificato non valido. I motivi per cui un certificato non è valido includono:

        • Un certificato scaduto
        • Un certificato autofirmato
        • Un certificato con un nome di dominio non corrispondente
        • Un certificato che utilizza l'estensione per l'accesso alle informazioni sull'autorità (AIA).

        Per forzare un controllo dell'uptime HTTPS per convalidare il certificato SSL, selezionare Convalida certificati SSL.

        Per disattivare la convalida dei certificati SSL, deseleziona Convalida certificati SSL.

        Se disponi di certificati SSL con estensioni AIA, devi disattivare la convalida del certificato SSL. Questi tipi di documenti non sono supportati e non superano la sequenza di convalida. In genere, il messaggio di errore è "Ha restituito "SSL Handshake Error" in 10000 ms".

        Puoi utilizzare la metrica monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires per creare un criterio di avviso che ti invii una notifica prima della scadenza del certificato. Per ulteriori informazioni, consulta Criteri di esempio: criterio di controllo di uptime.

        Seleziona la casella di controllo Convalida certificati SSL.

4. Fai clic su Continua e configura i requisiti di risposta. Tutte le impostazioni in questa sezione hanno valori predefiniti:

   • Per modificare il periodo di timeout per il controllo di uptime, utilizza il campo Timeout risposta. Un controllo di uptime non va a buon fine quando non viene ricevuta alcuna risposta da più di una località entro questo periodo.

   • Per configurare il controllo di uptime in modo che esegua la corrispondenza dei contenuti, assicurati che l'etichetta del pulsante di attivazione/disattivazione sia La corrispondenza dei contenuti è abilitata:

     • Seleziona il Tipo di corrispondenza dei contenuti della risposta dal menu delle opzioni. Questo campo determina il modo in cui i contenuti della risposta vengono confrontati con i dati restituiti. Ad esempio, supponiamo che i contenuti della risposta siano abcd e che il tipo di corrispondenza dei contenuti sia Contiene. Il controllo di uptime è positivo solo se i dati di risposta contengono abcd. Per ulteriori informazioni, consulta la sezione Convalidare i dati di risposta.
     • Inserisci i contenuti della risposta. Il contenuto della risposta deve essere una stringa non più lunga di 1024 byte. Nell'API, questo campo è l'oggetto ContentMatcher.

   • Per impedire la creazione di voci di log a causa dei controlli di uptime, elimina Logging degli errori dei controlli.

   • Per i controlli di uptime HTTP, configura i codici di risposta accettabili. Per impostazione predefinita, i controlli di uptime HTTP contrassegnano qualsiasi risposta2xx come risposta positiva.

5. Fai clic su Continua e configura le notifiche.

   Per ricevere una notifica quando un controllo di uptime non va a buon fine, crea un criterio di avviso e configura canali di notifica per quel criterio:

   1. (Facoltativo) Aggiorna il nome del criterio di avviso.
   2. (Facoltativo) Nel campo Durata, seleziona per quanto tempo i controlli di uptime devono avere esito negativo prima che vengano inviate le notifiche. Per impostazione predefinita, le notifiche vengono inviate quando almeno due regioni segnalano errori di controllo dell'uptime per una durata di almeno un minuto.

   3. Nella casella Canali di notifica, fai clic su arrow_drop_down Menu, seleziona i canali da aggiungere e poi fai clic su Ok.

      Nel menu, i canali di notifica sono raggruppati in ordine alfabetico per ciascun tipo di canale.

   Se non vuoi creare un criterio di avviso, assicurati che il testo del pulsante di attivazione/disattivazione sia Non creare un avviso.

6. Fai clic su Continua e completa il controllo dell'uptime:

   1. Inserisci un titolo descrittivo per il controllo di uptime.

   2. (Facoltativo) Per aggiungere etichette definite dall'utente al controllo dell'uptime:

      1. Fai clic su expand_more Mostra etichette utente.
      2. Nel campo Chiave, inserisci un nome per l'etichetta. I nomi delle etichette devono iniziare con una lettera minuscola e possono contenere lettere minuscole, numeri, trattini bassi e trattini. Ad esempio, inserisci severity.
      3. Nel campo Valore, inserisci un valore per l'etichetta. I valori dell'etichetta possono contenere lettere minuscole, numeri, trattini bassi e trattini. Ad esempio, inserisci critical.
      4. Per ogni etichetta aggiuntiva, fai clic su Aggiungi etichetta utente e poi inserisci la chiave e il valore dell'etichetta.

   3. Per verificare la configurazione del controllo di uptime, fai clic su Test. Se il risultato non è quello previsto, consulta la sezione Verificare gli errori, correggi la configurazione e ripeti il passaggio di verifica.

   4. Fai clic su Crea. Se selezioni Crea e un campo obbligatorio non viene compilato, viene visualizzato un messaggio di errore.

gcloud

Per creare il controllo di uptime, esegui il comando gcloud monitoring uptime create:

gcloud monitoring uptime create DISPLAY_NAME REQUIRED_FLAGS OPTIONAL_FLAGS

Prima di eseguire il comando precedente, segui questi passaggi:

• Sostituisci DISPLAY_NAME con il nome del controllo di uptime.

• Configura REQUIRED_FLAGS per specificare la risorsa sottoposta a controllo dal controllo di uptime. Ad esempio, il seguente comando crea un controllo di uptime che testa l'URL EXAMPLE.com per un determinato progetto:

  gcloud monitoring uptime create DISPLAY_NAME \
  --resource-labels=host=EXAMPLE.com,project_id=PROJECT_ID \
  --resource-type=uptime-url
  

  Il comando precedente specifica i valori per ogni etichetta richiesta dal tipo di risorsa uptime-url.

• Configura i flag OPTIONAL_FLAGS per eseguire l'override dei valori predefiniti. Ad esempio, devi impostare il flag --protocol quando il protocollo non è http.

API

Per creare un controllo di uptime, chiama il metodo projects.uptimeCheckConfigs.create. Imposta i parametri del metodo come segue:

• parent: obbligatorio. Deve essere il nome del progetto in cui creare il controllo di uptime. Sostituisci PROJECT_ID con il tuo ID progetto Google Cloud. Il formato è:

  projects/PROJECT_ID
  

• Il corpo della richiesta deve contenere un oggetto UptimeCheckConfig per il nuovo controllo del tempo di attività. Questa pagina fornisce informazioni su alcuni campi. Per la documentazione completa su questo oggetto e sui relativi campi, consulta UptimeCheckConfig:

  • Lascia vuoto il campo name dell'oggetto di configurazione. Il sistema imposta questo campo quando crea l'oggetto di configurazione della risposta.

  • Se stai configurando un controllo HTTP o HTTPS, devi compilare il campo HttpCheck dell'oggetto UptimeCheckConfig. In questo oggetto, imposta il campo requestMethod come GET o POST. Se questo campo viene omesso o impostato su METHOD_UNSPECIFIED, viene emessa una richiesta GET.

    Se stai configurando una richiesta POST, compila i campi contentType, customContentType (facoltativo) e body.

Il metodo create restituisce l'oggetto UptimeCheckConfig per la nuova configurazione.

Se la configurazione del tempo di attività creata non funziona come previsto, consulta la sezione Controllare gli errori in questa pagina.

C#

Per autenticarti in Monitoraggio, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti in Monitoraggio, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti in Monitoraggio, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti in Monitoraggio, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti in Monitoraggio, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti in Monitoraggio, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti in Monitoraggio, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base. Per ulteriori informazioni, consulta la Terraform documentazione di riferimento del provider.

Per creare un controllo di uptime e un criterio di avviso per monitorarlo, segui questi passaggi:

1. Modifica il file di configurazione Terraform e aggiungi una risorsa google_monitoring_uptime_check_config, quindi applica il file di configurazione.

   L'esempio seguente illustra una configurazione che controlla un URL pubblico:

   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. (Facoltativo) Crea un canale di notifica e un criterio di avviso:

   I passaggi che seguono utilizzano la console Google Cloud per creare il canale di notifica e il criterio di avviso. Questo approccio garantisce che il criterio di avviso monitori solo i dati generati dal controllo di uptime.

   1. Per creare un canale di notifica:

      1. Nella console Google Cloud, vai alla pagina notifications Avvisi:

         Vai ad Avvisi

         Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.

      2. Seleziona Gestisci canali di notifica.
      3. Vai al tipo di canale che vuoi aggiungere, fai clic su Aggiungi e completa la finestra di dialogo.

   2. Per creare un criterio di avviso, segui questi passaggi:

      1. Nella console Google Cloud, vai alla pagina  Controlli di uptime:

         Vai a Controlli di uptime

         Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.

      2. Individua il controllo di uptime, seleziona more_vert Altro e poi Aggiungi criterio di avviso.
      3. Nella finestra di dialogo, vai alla sezione Notifiche e nome, espandi Canali di notifica ed effettua le tue selezioni.
      4. Assegna un nome al criterio di avviso e fai clic su Crea criterio.

   Puoi creare un criterio di avviso aggiungendo una risorsa google_monitoring_alert_policy al file di configurazione e applicando la nuova configurazione.