Crea controlli di uptime pubblici

Questo documento descrive come creare un controllo di uptime pubblico. Un controllo di uptime pubblico può inviare richieste da più località agli URL disponibili pubblicamente o alle risorse Google Cloud per vedere a cui la risorsa risponde. Per informazioni su come creare i controlli di uptime per le reti private, Crea controlli di uptime privati.

I controlli di uptime pubblici possono determinare la disponibilità di: risorse monitorate:

Per i link alle informazioni su come gestire e monitorare i controlli di uptime, consulta la sezione Passaggi successivi di questo documento.

Informazioni sui controlli di uptime

Per HTTP e HTTPS vengono seguiti tutti i reindirizzamenti URL e la risposta finale ricevuto dal controllo di uptime viene usato per valutare i criteri di successo. Per Controlli HTTPS, la data di scadenza del certificato SSL viene calcolata in base al certificato del server ricevuto nella risposta finale.

Affinché un controllo di uptime riesca, devono essere soddisfatte le seguenti condizioni:

  • Lo stato HTTP deve corrispondere ai criteri specificati.
  • I dati della risposta non hanno contenuti obbligatori oppure sono presenti contenuti richiesti.

I controlli di uptime non caricano asset delle pagine e non eseguono JavaScript e il metodo di un controllo di uptime non include l'autenticazione.

Prima di iniziare

  1. Per ottenere le autorizzazioni necessarie per creare controlli di uptime, chiedi all'amministratore di concederti i seguenti ruoli IAM sul tuo progetto:

    • Editor Monitoring (roles/monitoring.editor) - Utenti della console Google Cloud
    • Editor configurazioni controlli di uptime Monitoring (roles/monitoring.uptimeCheckConfigEditor) - Utenti API
    • Editor AlertPolicy Monitoring (roles/monitoring.alertPolicyEditor) - Utenti API
    • Editor NotificationChannel Monitoring (roles/monitoring.notificationChannelEditor) - Utenti API

    Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

    Potresti anche riuscire a ottenere le autorizzazioni richieste tramite la ruoli o altri ruoli predefiniti ruoli.

  2. Verifica che la risorsa che vuoi controllare dispone di un endpoint pubblico o si trova dietro un firewall configurabile.

    Per tutte le altre configurazioni, devi creare un controllo di uptime privato. Per ulteriori informazioni, vedi Crea controlli di uptime privati.

  3. Quando la risorsa è protetta da un firewall, configuralo per consentire il traffico in entrata dagli indirizzi IP dei server per il controllo di uptime. Per ulteriori informazioni, vedi Elenca gli indirizzi IP dei server per il controllo di uptime.

  4. Configura i canali di notifica che vuoi utilizzare per la ricezione notifiche. Ti consigliamo di creare più tipi di notifiche canali. Per ulteriori informazioni, vedi Creare e gestire i canali di notifica.

  5. Identifica almeno tre controlli per il controllo di uptime. La regione USA relativa ai controlli di uptime include USA_OREGON, USA_IOWA e USA_VIRGINIA. Ciascuno dei USA_* regioni ha un controllo e USA li include tutti e tre. Le altre regioni per i controlli di uptime, EUROPE, SOUTH_AMERICA e ASIA_PACIFIC, ognuno ha uno controllo.

    Se selezioni Globale quando utilizzi la console Google Cloud oppure selezioni REGION_UNSPECIFIED quando si utilizza l'API, vengono emessi controlli di uptime tutte le regioni per i controlli di uptime.

Crea un controllo di uptime

Questa sezione spiega come creare e configurare i controlli di uptime.

Per creare un controllo di uptime per un bilanciatore del carico esterno che ha su almeno una porta TCP o HTTP/s configurata, puoi seguire queste istruzioni. In alternativa, vai alla pagina Dettagli servizio del servizio. e fai clic su Crea controllo di uptime. Se inizi dalla Dettagli servizio, i campi specifici del servizio sono precompilati.

Console

Per creare un controllo di uptime utilizzando la console Google Cloud, 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 Monitoraggio.

  2. Fai clic su Crea controllo di uptime.

    Crea una finestra di dialogo per il controllo di uptime.

  3. Specifica l'obiettivo 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. Il percorso e la porta sono stati inseriti separatamente.
      • Servizio LoadBalancer per Kubernetes: servizio Kubernetes di LoadBalancer di testo.
      • Istanza: istanze di Compute Engine o AWS EC2.
      • App Engine: applicazioni App Engine (moduli).
      • 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 protocolli inviano una richiesta a http://target/path. In questo per una risorsa URL, target è un nome host o un indirizzo IP. Per una risorsa App Engine, target è un nome host derivato dal il nome del servizio. Per le risorse di istanza e bilanciatore del carico, target è un indirizzo IP derivato dal nome che fornita per la risorsa o per 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 emettere un controllo di uptime alla risorsa URL example.com/tester, imposta il campo Nome host su example.com e il campo Percorso su /tester.

        Supponi di aver eseguito il deployment di un server in App Engine con un supervisore che supporta / e /hello. Per emettere il controllo di uptime al "/" lascia vuoto il campo Path. Per emettere il controllo di uptime al gestore /hello, imposta il valore Percorso su /hello.

    4. Inserisci i campi specifici delle risorse:

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

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

      • Per le risorse Elastic Load Balancer e Instance, completa la configurazione nel campo Si applica a, come segue:

        • Per emettere un controllo di uptime a una singola istanza o bilanciatore del carico, seleziona Singolo e utilizza per selezionare l'istanza o il bilanciatore del carico specifici.
        • Per inviare un controllo di uptime a un gruppo di Monitoring, seleziona Gruppo, quindi utilizza per selezionare il nome del gruppo.

    5. (Facoltativo) Per impostare la frequenza di esecuzione del controllo di uptime, utilizza il metodo Campo Controlla frequenza.

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

      • Regioni: seleziona le regioni in cui si verificano i controlli di uptime ricevono le richieste. Un controllo di uptime deve avere almeno tre controlli. È presente un controllo in tutte le regioni tranne negli Stati Uniti, che ha tre dama. L'impostazione predefinita, Globale, include in tutte le regioni.
      • Ping ICMP: configura il controllo di uptime per inviare fino a tre ping. Per saperne di più, consulta l'articolo Utilizzare i ping ICMP.
      • Request Method (Metodo di richiesta): per i controlli HTTP, seleziona il metodo di richiesta.
      • Corpo: per i controlli POST HTTP, inserisci il corpo della codifica dell'URL; tu devono eseguire la codifica autonomamente. Per tutti gli altri controlli, lascia questo vuoto.
      • 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 necessario, criptale desiderato. La crittografia nasconde i valori dell'intestazione nel modulo. Utilizza la crittografia per le intestazioni relative all'autenticazione che che non vuoi siano visibili agli altri.

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

        Scegli una delle seguenti opzioni:

        • Autenticazione di base: fornisci un singolo nome utente e password. Le password sono sempre nascoste nel modulo.
        • Service Agent Authentication (Autenticazione agente di servizio): quando viene abilitata una viene generato un token di identità per il monitoraggio agente di servizio. Questa opzione è disponibile soltanto per i controlli HTTPS.

      • Convalida certificato SSL: se hai selezionato HTTPS per un URL per impostazione predefinita il servizio tenta di connettersi HTTPS e convalida il certificato SSL. I controlli di uptime hanno esito negativo quando un URL ha un certificato non valido. I motivi di un certificato non valido sono i seguenti:

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

        Per forzare un controllo di uptime HTTPS per convalidare il certificato SSL, Seleziona Convalida i certificati SSL.

        Per disabilitare la convalida dei certificati SSL, cancella Convalida i certificati SSL.

        Se disponi di certificati SSL con Estensioni AIA, devi disabilitare la convalida del certificato SSL. Questi tipi di certificati non sono supportati e non superano la sequenza di convalida. In genere, il messaggio di errore è "Risposta inviata con SSL handshake Error in 10000 ms".

        Puoi usare la metrica monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires per creare un criterio di avviso che ti avvisa prima che del certificato scade. Per ulteriori informazioni, vedi Esempi di criteri: criteri 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 di questa sezione hanno valori predefiniti:

    • Per modificare il periodo di timeout per il controllo di uptime, utilizza il metodo Timeout risposta. Un controllo di uptime ha esito negativo quando risposta ricevuta da più località in questo periodo.

    • Per configurare il controllo di uptime per eseguire la corrispondenza dei contenuti, Assicurati che l'etichetta di attivazione/disattivazione sia Corrispondenza dei contenuti abilitata:

      • Seleziona il Tipo di corrispondenza di contenuto della risposta dal menu delle opzioni. Questo campo determina il modo in cui il contenuto della risposta viene confrontato con che ha restituito dati. Ad esempio, supponiamo che il contenuto della risposta sia abcd e il tipo di corrispondenza dei contenuti è Contiene. Il controllo di uptime ha esito positivo solo quando i dati della risposta contengono abcd. Per ulteriori informazioni, vedi Convalida i dati delle risposte.
      • Inserisci i Contenuti della risposta. Il contenuto della risposta deve essere una stringa non più lungo di 1024 byte. Nell'API, questo campo è ContentMatcher.

    • Per evitare che vengano create voci di log a causa dei controlli di uptime, Deseleziona Errori nel controllo dei log.

    • Per i controlli di uptime HTTP, configura i codici di risposta accettabili. Per impostazione predefinita, i controlli di uptime HTTP contrassegnano qualsiasi Risposta 2xx come risposta riuscita.

  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'istanza criterio di avviso e configura canali di notifica per le norme in questione:

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

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

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

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

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

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

    2. (Facoltativo) Per aggiungere etichette definite dall'utente al controllo di uptime, procedi nel seguente modo:

      1. Fai clic su 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. Valori etichetta può contenere lettere minuscole, numeri, trattini bassi e trattini. Ad esempio: inserisci critical.
      4. Per ogni etichetta aggiuntiva, fai clic su Aggiungi etichetta utente e inserisci la chiave e il valore dell'etichetta.

    3. Per verificare la configurazione dei controlli di uptime, fai clic su Test. Se il risultato non è quello previsto, consulta Controllare gli errori. correggere la configurazione e ripetere 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 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 test il controllo di uptime. Ad esempio, il comando seguente crea un controllo di uptime che verifica l'URL EXAMPLE.com per un progetto specifico:

    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 tipo di risorsa uptime-url.

  • Configura i flag OPTIONAL_FLAGS per eseguire l'override del valore predefinito e i relativi valori. Ad esempio, devi impostare il flag --protocol quando diverso da 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 ID progetto Google Cloud. Il formato è:

    projects/PROJECT_ID

  • Il corpo della richiesta deve contenere un oggetto UptimeCheckConfig per la nuova e un controllo di uptime. Questa pagina fornisce informazioni su alcuni campi. Per documentazione completa su questo oggetto e i suoi campi, consulta UptimeCheckConfig:

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

    • Se stai configurando un controllo HTTP o HTTPS, devi inserire il campo HttpCheck del UptimeCheckConfig oggetto. In questo oggetto, imposta requestMethod campo 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, completa il contentType, facoltativo customContentType e body.

Il metodo create restituisce UptimeCheckConfig per la nuova configurazione.

Se la configurazione dell'uptime creata non funziona come previsto, consulta la sezione Sezione Controlla gli errori di questa pagina.

C#

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 Terraform documentazione di riferimento del provider.

Per creare un controllo di uptime e un criterio di avviso per monitorare il controllo, procedi nel seguente modo:

  1. Modifica il file di configurazione di Terraform e aggiungi un google_monitoring_uptime_check_config risorsa e applicare il file di configurazione.

    L'esempio seguente illustra una configurazione che verifica 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:

    Nei passaggi seguenti viene utilizzata la console Google Cloud per creare la notifica il canale e il criterio di avviso. Questo approccio garantisce che il criterio di avviso monitora solo i dati generati dal controllo di uptime.

    1. Per creare un canale di notifica:

      1. Nella console Google Cloud, vai alla Pagina Avvisi:

        Vai ad Avvisi

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

      2. Seleziona Gestisci canali di notifica.
      3. Vai al tipo di canale che vuoi aggiungere, fai clic su Aggiungi e quindi 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 Monitoraggio.

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

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

Potrebbe verificarsi un ritardo massimo di 5 minuti prima che i risultati del controllo di uptime inizino a confluire in Monitoring. Durante questo periodo, la dashboard dei controlli di uptime segnala lo stato come "nessun dato disponibile".

Utilizza ping ICMP

Per aiutarti a risolvere i problemi relativi a controlli di uptime pubblici non riusciti, puoi configurare dei controlli di uptime per inviare emette un ping da ICMP durante la verifica. I ping possono aiutarti a distinguere tra causati, ad esempio, da problemi di connettività di rete e i timeout nella tua applicazione.

Per impostazione predefinita, i controlli di uptime non inviano ping. Ogni ping aggiunge latenza al controllo di uptime. I controlli di uptime privati non possono inviare ping.

Quando un controllo di uptime pubblico non va a buon fine, i risultati dei ping vengono scritti in nei log di Cloud Logging. Se il ping non va a buon fine, i seguenti campi vengono aggiunti al campo httpRequest nella voce di log:

  • rtt_usec: tempo di round trip per ogni richiesta di ping non riuscita.
  • unreachable_count: numero di richieste ping che hanno restituito codice di stato ICMP_DEST_UNREACH.
  • no_answer_count: numero di richieste ping con timeout e non ha restituito alcuna risposta.

I risultati dei ping relativi ai controlli di uptime riusciti non vengono registrati.

Configura i ping

Ogni configurazione dei controlli di uptime include un oggetto HttpCheck o un oggetto TcpCheck. Entrambi questi oggetti includono un campo pingConfig. Utilizza questo campo per specificare il numero di ping ICMP da includere in ogni controllo, fino a 3. Per impostazione predefinita, non viene inviato alcun ping.

Per configurare i ping, esegui una delle seguenti operazioni:

  • Quando utilizzi la console Google Cloud, espandi Altre opzioni di target e inserisci un valore nei ping ICMP .

  • Quando utilizzi l'API Cloud Monitoring, utilizza l'oggetto PingConfig, che ha la seguente struttura:

    {
  "pingsCount": integer
}

    Per ulteriori informazioni sull'uso dell'API Monitoring per configurazioni dei controlli di uptime, Crea un controllo di uptime: API oppure Modificare un controllo di uptime: API.

Verificare il controllo di uptime

Quando crei un controllo di uptime nella console Google Cloud, può testare la configurazione prima di salvare.

Controlli riusciti

Un controllo di uptime ha esito positivo quando le seguenti condizioni sono vere:

  • Lo stato HTTP corrisponde ai criteri selezionati.
  • La risposta non ha contenuti obbligatori o una ricerca della risposta per i contenuti richiesti.

Controlli non superati

Di seguito sono riportate alcune possibili cause di un errore del controllo di uptime:

  • Errore di connessione - Rifiutato: se utilizzi il protocollo HTTP predefinito di connessione, verifica di aver installato un server web che in risposta a richieste HTTP. Può verificarsi un errore di connessione su una nuova istanza se non hai installato un server web; vedi il Guida rapida per Compute Engine. Se utilizzi un tipo di connessione HTTPS, potrebbe essere necessario eseguire passaggi di configurazione aggiuntivi. Per problemi di firewall, vedi Elenca gli indirizzi IP dei server per il controllo di uptime.
  • Nome o servizio non trovato: il nome host potrebbe non essere corretto.
  • 403 Accesso negato: il servizio restituisce un codice di errore all'uptime controllo. Ad esempio, la configurazione predefinita del server web restituisce questo codice in Amazon Linux, ma il codice 200 (Operazione riuscita) in alcune altre versioni di Linux. Consulta le Tutorial su LAMP per Amazon Linux o la documentazione del server web.
  • 404 Non trovato: il percorso potrebbe non essere corretto.
  • 408 Timeout richiesta o nessuna risposta: il numero di porta potrebbe essere potrebbe non essere in esecuzione, il servizio potrebbe non sono accessibili oppure il timeout potrebbe essere troppo basso. Verifica che il firewall consente il traffico dai server di uptime, vedi Elenca gli indirizzi IP dei server per il controllo di uptime. Il limite di timeout viene specificato nell'ambito del modulo Response Validation le opzioni di CPU e memoria disponibili.

Se il controllo di uptime è configurato per inviare ping, i risultati dei ping per i controlli di uptime non riusciti vengono scritti in Cloud Logging. Per ulteriori informazioni, consulta Utilizzare i ping ICMP.

Passaggi successivi