Membuat cek uptime publik

Dokumen ini menjelaskan cara membuat pemeriksaan uptime publik. Pemeriksaan uptime publik dapat mengeluarkan permintaan dari beberapa lokasi di seluruh dunia ke URL yang tersedia secara publik atau resource Google Cloud untuk melihat apakah resource merespons. Untuk informasi tentang cara membuat pemeriksaan uptime untuk jaringan pribadi, lihat Membuat pemeriksaan uptime pribadi.

Cek uptime publik dapat menentukan ketersediaan resource yang dipantau berikut:

Untuk link ke informasi tentang cara mengelola dan memantau pemeriksaan uptime, lihat bagian Langkah berikutnya dalam dokumen ini.

Tentang pemeriksaan uptime

Untuk HTTP dan HTTPS, semua pengalihan URL akan diikuti dan respons akhir yang diterima oleh pemeriksaan waktu aktif digunakan untuk mengevaluasi kriteria keberhasilan apa pun. Untuk pemeriksaan HTTPS, waktu habis masa berlaku sertifikat SSL dihitung berdasarkan sertifikat server yang diterima dalam respons akhir.

Agar pemeriksaan waktu aktif berhasil, kondisi berikut harus terpenuhi:

  • Status HTTP harus cocok dengan kriteria yang Anda tentukan.
  • Data respons tidak memiliki konten yang diperlukan atau konten yang diperlukan ada.

Pemeriksaan uptime tidak memuat aset halaman atau menjalankan JavaScript, dan konfigurasi default pemeriksaan uptime tidak menyertakan autentikasi.

Sebelum memulai

  1. Untuk mendapatkan izin yang Anda perlukan untuk membuat pemeriksaan waktu aktif, minta administrator untuk memberi Anda peran IAM berikut di project Anda:

    • Monitoring Editor (roles/monitoring.editor) - Pengguna konsol Google Cloud
    • Monitoring Uptime Check Configurations Editor (roles/monitoring.uptimeCheckConfigEditor) - Pengguna API
    • Monitoring AlertPolicy Editor (roles/monitoring.alertPolicyEditor) - Pengguna API
    • Monitoring NotificationChannel Editor (roles/monitoring.notificationChannelEditor) - Pengguna API

    Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat Mengelola akses ke project, folder, dan organisasi.

    Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui peran khusus atau peran bawaan lainnya.

  2. Pastikan resource yang ingin Anda periksa memiliki endpoint publik atau berada di balik firewall yang dapat dikonfigurasi.

    Untuk semua konfigurasi lainnya, Anda harus membuat pemeriksaan uptime pribadi. Untuk mengetahui informasi selengkapnya, lihat Membuat pemeriksaan uptime pribadi.

  3. Jika resource Anda dilindungi firewall, konfigurasikan firewall tersebut untuk mengizinkan traffic masuk dari alamat IP server pemeriksaan waktu aktif. Untuk mengetahui informasi selengkapnya, lihat Mencantumkan alamat IP server cek uptime.

  4. Konfigurasikan saluran notifikasi yang ingin Anda gunakan untuk menerima notifikasi. Sebaiknya Anda membuat beberapa jenis saluran notifikasi. Untuk informasi selengkapnya, lihat Membuat dan mengelola saluran notifikasi.

  5. Identifikasi minimal tiga pemeriksa untuk pemeriksaan uptime Anda. Region pemeriksaan uptime USA mencakup region USA_OREGON, USA_IOWA, dan USA_VIRGINIA. Setiap region USA_* memiliki satu pemeriksa, dan USA menyertakan ketiganya. Region pemeriksaan uptime lainnya, EUROPE, SOUTH_AMERICA, dan ASIA_PACIFIC, masing-masing memiliki satu pemeriksa.

    Jika Anda memilih Global saat menggunakan Konsol Google Cloud, atau memilih REGION_UNSPECIFIED saat menggunakan API, pemeriksaan uptime akan dikeluarkan dari semua region pemeriksaan uptime.

Membuat cek uptime

Bagian ini menjelaskan cara membuat dan mengonfigurasi pemeriksaan waktu aktif.

Untuk membuat pemeriksaan uptime bagi load balancer eksternal yang memiliki setidaknya satu port TCP atau HTTP/s yang dikonfigurasi, Anda dapat mengikuti petunjuk ini. Alternatifnya adalah membuka halaman Detail layanan untuk layanan tersebut, lalu klik Buat pemeriksaan uptime. Saat Anda memulai dari halaman Detail layanan, kolom khusus layanan akan terisi otomatis.

Konsol

Untuk membuat pemeriksaan uptime menggunakan konsol Google Cloud, lakukan hal berikut:

  1. Di konsol Google Cloud, buka halaman  Pemeriksaan waktu aktif:

    Buka Cek uptime

    Jika Anda menggunakan kotak penelusuran untuk menemukan halaman ini, pilih hasil yang subjudulnya adalah Monitoring.

  2. Klik Buat Cek Uptime.

    Buat dialog pemeriksaan uptime.

  3. Tentukan target cek uptime:

    1. Pilih protokol. Anda dapat memilih HTTP, HTTPS, atau TCP.

    2. Pilih salah satu jenis resource berikut:

      • URL: Alamat IPv4 atau nama host apa pun. Jalur dan port dimasukkan secara terpisah.
      • Layanan LoadBalancer Kubernetes: Layanan Kubernetes dari jenis LoadBalancer.
      • Instance: Instance Compute Engine atau AWS EC2.
      • App Engine: Aplikasi (modul) App Engine.
      • Elastic Load Balancer: Load balancer AWS.

    3. Masukkan kolom khusus protokol:

      • Untuk pemeriksaan TCP, masukkan port.

      • Untuk pemeriksaan HTTP dan HTTPS, Anda dapat memasukkan jalur dalam host atau resource. Semua pemeriksaan waktu beroperasi yang menggunakan protokol ini mengirim permintaan ke http://target/path. Dalam ekspresi ini, untuk resource URL, target adalah nama host atau alamat IP. Untuk resource App Engine, target adalah nama host yang berasal dari nama layanan. Untuk instance dan resource load balancer, target adalah alamat IP yang berasal dari nama yang Anda berikan untuk resource atau grup resource.

        Jika Anda mengosongkan kolom path atau menetapkan nilai ke /, permintaan akan dikeluarkan ke http://target/.

        Misalnya, untuk melakukan pemeriksaan waktu aktif ke resource URL example.com/tester, tetapkan kolom Hostname ke example.com dan kolom Path ke /tester.

        Misalkan Anda telah men-deploy server ke App Engine dengan dispatcher yang mendukung / dan /hello. Untuk mengeluarkan pemeriksaan waktu aktif ke pengendali '/', kosongkan kolom Jalur. Untuk mengeluarkan pemeriksaan waktu aktif ke pengendali /hello, tetapkan nilai kolom Path ke /hello.

    4. Masukkan kolom khusus resource:

      • Untuk resource URL, masukkan nama host di kolom Hostname. Misalnya, masukkan example.com.

      • Untuk resource App Engine, masukkan nama layanan di kolom Service.

      • Untuk resource Elastic Load Balancer dan Instance, isi kolom Berlaku untuk sebagai berikut:

        • Untuk melakukan pemeriksaan waktu aktif ke satu instance atau load balancer, pilih Tunggal, lalu gunakan menu untuk memilih instance atau load balancer tertentu.
        • Untuk melakukan pemeriksaan waktu aktif ke grup Pemantauan, pilih Grup, lalu gunakan menu untuk memilih nama grup.

    5. Opsional: Untuk menetapkan frekuensi pemeriksaan waktu aktif yang dijalankan, gunakan kolom Frekuensi pemeriksaan.

    6. Opsional: Untuk memilih wilayah pemeriksa, atau mengonfigurasi sertifikat SSL, autentikasi, header, dan port untuk pemeriksaan HTTP dan HTTPS, klik Opsi target lainnya:

      • Region: Pilih region tempat pemeriksaan uptime akan menerima permintaan. Pemeriksaan uptime harus memiliki minimal tiga pemeriksa. Ada satu pemeriksa di semua wilayah kecuali Amerika Serikat, yang memiliki tiga pemeriksa. Setelan default, Global, mencakup semua wilayah.
      • Ping ICMP: Konfigurasikan pemeriksaan uptime untuk mengirim hingga tiga ping. Untuk informasi selengkapnya, lihat Menggunakan ping ICMP.
      • Request Method: Untuk pemeriksaan HTTP, pilih metode permintaan.
      • Isi: Untuk pemeriksaan HTTP POST, masukkan isi yang dienkode URL; Anda harus melakukan encoding sendiri. Untuk semua pemeriksaan lainnya, biarkan kolom ini kosong.
      • Header host: Isi kolom ini untuk memeriksa host virtual. Kolom ini tidak tersedia untuk pemeriksaan TCP.
      • Port: Tentukan nomor port.
      • Header Kustom: Berikan header kustom, dan enkripsi jika diinginkan. Enkripsi menyembunyikan nilai header dalam formulir. Gunakan enkripsi untuk header yang terkait dengan autentikasi yang tidak ingin Anda perlihatkan kepada orang lain.

      • Autentikasi: Nilai ini dikirim sebagai header Otorisasi. Kolom ini tidak tersedia untuk pemeriksaan TCP.

        Pilih dari opsi berikut:

        • Autentikasi Dasar: Masukkan satu nama pengguna dan sandi. Sandi selalu tersembunyi dalam formulir.
        • Autentikasi Agen Layanan: Jika diaktifkan, token identitas akan dibuat untuk monitoring agen layanan. Opsi ini hanya tersedia untuk pemeriksaan HTTPS.

      • Validasi Sertifikat SSL: Jika Anda memilih HTTPS untuk resource URL, secara default, layanan akan mencoba terhubung melalui HTTPS dan memvalidasi sertifikat SSL. Pemeriksaan waktu aktif gagal jika URL memiliki sertifikat yang tidak valid. Alasan sertifikat tidak valid meliputi hal-hal berikut:

        • Masa berlaku sertifikat habis
        • Sertifikat yang ditandatangani sendiri
        • Sertifikat dengan ketidakcocokan nama domain
        • Sertifikat yang menggunakan ekstensi Akses Informasi Otoritas (AIA).

        Untuk memaksa pemeriksaan waktu aktif HTTPS memvalidasi sertifikat SSL, pilih Validasi sertifikat SSL.

        Untuk menonaktifkan validasi sertifikat SSL, hapus centang pada Validasi sertifikat SSL.

        Jika memiliki Sertifikat SSL dengan Ekstensi AIA, Anda harus menonaktifkan validasi sertifikat SSL. Jenis sertifikat ini tidak didukung dan gagal dalam urutan validasi. Biasanya, pesan errornya adalah "Merespons dengan Error handshake SSL dalam 10.000 md".

        Anda dapat menggunakan metrik monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires untuk membuat kebijakan pemberitahuan yang memberi tahu Anda sebelum sertifikat berakhir masa berlakunya. Untuk mengetahui informasi selengkapnya, lihat Contoh kebijakan: Kebijakan pemeriksaan uptime.

        Pilih kotak centang Validasi sertifikat SSL.

  4. Klik Lanjutkan dan konfigurasikan persyaratan respons. Semua setelan di bagian ini memiliki nilai default:

    • Untuk mengubah periode waktu tunggu untuk pemeriksaan waktu aktif, gunakan kolom Response Timeout. Pemeriksaan uptime akan gagal jika tidak ada respons yang diterima dari lebih dari satu lokasi dalam periode ini.

    • Untuk mengonfigurasi pemeriksaan waktu aktif guna melakukan pencocokan konten, pastikan label tombolnya adalah Pencocokan konten diaktifkan:

      • Pilih Jenis Pencocokan Konten Respons dari menu opsi. Kolom ini menentukan cara konten respons dibandingkan dengan data yang ditampilkan. Misalnya, anggaplah konten respons adalah abcd dan jenis pencocokan konten adalah Berisi. Pemeriksaan waktu aktif hanya berhasil jika data respons berisi abcd. Untuk informasi selengkapnya, lihat Memvalidasi data respons.
      • Masukkan Konten respons. Isi respons harus berupa string yang tidak lebih dari 1.024 byte. Di API, kolom ini adalah objek ContentMatcher.

    • Untuk mencegah entri log dibuat karena pemeriksaan uptime, hapus Kegagalan pemeriksaan log.

    • Untuk pemeriksaan uptime HTTP, konfigurasikan kode respons yang dapat diterima. Secara default, pemeriksaan uptime HTTP menandai respons 2xx sebagai respons yang berhasil.

  5. Klik Lanjutkan dan konfigurasikan notifikasi.

    Untuk mendapatkan notifikasi saat cek uptime gagal, buat kebijakan pemberitahuan dan konfigurasikan saluran notifikasi untuk kebijakan tersebut:

    1. Opsional: Perbarui nama kebijakan pemberitahuan.
    2. Opsional: Di kolom Duration, pilih durasi kegagalan pemeriksaan uptime sebelum notifikasi dikirim. Secara default, notifikasi akan dikirim jika setidaknya dua region melaporkan kegagalan pemeriksaan uptime selama durasi minimal satu menit.

    3. Di kotak berlabel Saluran notifikasi, klik Menu, pilih saluran yang akan ditambahkan, lalu klik Oke.

      Di menu, saluran notifikasi dikelompokkan menurut abjad untuk setiap jenis saluran.

    Jika Anda tidak ingin membuat kebijakan pemberitahuan, pastikan teks tombol tombol adalah Jangan buat pemberitahuan.

  6. Klik Lanjutkan dan selesaikan pemeriksaan uptime Anda:

    1. Masukkan judul deskriptif untuk pemeriksaan uptime.

    2. Opsional: Untuk menambahkan label yang ditentukan pengguna ke pemeriksaan waktu aktif, lakukan tindakan berikut:

      1. Klik Tampilkan label pengguna.
      2. Di kolom Key, masukkan nama untuk label. Nama label harus diawali dengan huruf kecil, dan dapat berisi huruf kecil, angka, garis bawah, dan tanda pisah. Misalnya, masukkan severity.
      3. Di kolom Nilai, masukkan nilai untuk label Anda. Nilai label dapat berisi huruf kecil, angka, garis bawah, dan tanda hubung. Misalnya, masukkan critical.
      4. Untuk setiap label tambahan, klik Tambahkan label pengguna, lalu masukkan kunci dan nilai label.

    3. Untuk memverifikasi konfigurasi pemeriksaan uptime, klik Uji. Jika hasilnya tidak seperti yang Anda harapkan, lihat Memeriksa kegagalan, perbaiki konfigurasi Anda, lalu ulangi langkah verifikasi.

    4. Klik Create. Jika Anda memilih Buat dan kolom wajib diisi tidak diisi, pesan error akan ditampilkan.

gcloud

Untuk membuat pemeriksaan waktu aktif, jalankan perintah gcloud monitoring uptime create:

gcloud monitoring uptime create DISPLAY_NAME REQUIRED_FLAGS OPTIONAL_FLAGS

Sebelum menjalankan perintah sebelumnya, lakukan hal berikut:

  • Ganti DISPLAY_NAME dengan nama untuk pemeriksaan uptime Anda.

  • Konfigurasikan REQUIRED_FLAGS untuk menentukan resource yang diselidiki oleh pemeriksaan uptime. Misalnya, perintah berikut akan membuat pemeriksaan waktu aktif yang menguji URL EXAMPLE.com untuk project tertentu:

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

    Perintah sebelumnya menentukan nilai untuk setiap label yang diperlukan oleh jenis resource uptime-url.

  • Konfigurasikan flag OPTIONAL_FLAGS untuk mengganti nilai default. Misalnya, Anda harus menetapkan tanda --protocol jika protokol bukan http.

API

Untuk membuat pemeriksaan waktu aktif, panggil metode projects.uptimeCheckConfigs.create. Tetapkan parameter metode sebagai berikut:

  • parent: Wajib diisi. Ini harus berupa nama project tempat membuat pemeriksaan uptime. Ganti PROJECT_ID dengan project ID Google Cloud Anda. Formatnya adalah:

    projects/PROJECT_ID

  • Isi permintaan harus berisi objek UptimeCheckConfig untuk pemeriksaan uptime baru. Halaman ini memberikan informasi tentang beberapa kolom. Untuk dokumentasi lengkap tentang objek ini dan kolomnya, lihat UptimeCheckConfig:

    • Biarkan kolom name objek konfigurasi kosong. Sistem menetapkan kolom ini saat membuat objek konfigurasi respons.

    • Jika mengonfigurasi pemeriksaan HTTP atau HTTPS, Anda harus mengisi kolom HttpCheck dari objek UptimeCheckConfig. Dalam objek ini, tetapkan kolom requestMethod sebagai GET atau POST. Jika kolom ini dihilangkan atau ditetapkan ke METHOD_UNSPECIFIED, permintaan GET akan dikeluarkan.

      Jika Anda mengonfigurasi permintaan POST, isi kolom contentType, customContentType opsional, dan body.

Metode create menampilkan objek UptimeCheckConfig untuk konfigurasi baru.

Jika konfigurasi waktu aktif yang dibuat tidak berfungsi seperti yang diharapkan, lihat bagian Memeriksa kegagalan di halaman ini.

C#

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi penyedia Terraform.

Untuk membuat pemeriksaan uptime dan kebijakan pemberitahuan guna memantau pemeriksaan tersebut, lakukan langkah berikut:

  1. Edit file konfigurasi Terraform dan tambahkan resource google_monitoring_uptime_check_config, lalu terapkan file konfigurasi.

    Contoh berikut mengilustrasikan konfigurasi yang memeriksa URL publik:

    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. Opsional: Buat saluran notifikasi dan kebijakan pemberitahuan:

    Langkah-langkah berikut menggunakan konsol Google Cloud untuk membuat saluran notifikasi dan kebijakan pemberitahuan. Pendekatan ini memastikan bahwa kebijakan pemberitahuan hanya memantau data yang dihasilkan oleh pemeriksaan uptime Anda.

    1. Untuk membuat saluran notifikasi, lakukan tindakan berikut:

      1. Di konsol Google Cloud, buka halaman  Alerting:

        Buka Pemberitahuan

        Jika Anda menggunakan kotak penelusuran untuk menemukan halaman ini, pilih hasil yang subjudulnya adalah Monitoring.

      2. Pilih Kelola saluran notifikasi.
      3. Buka jenis saluran yang ingin ditambahkan, klik Tambahkan, lalu selesaikan dialog.

    2. Untuk membuat kebijakan pemberitahuan, lakukan langkah berikut:

      1. Di konsol Google Cloud, buka halaman  Pemeriksaan waktu aktif:

        Buka Cek uptime

        Jika Anda menggunakan kotak penelusuran untuk menemukan halaman ini, pilih hasil yang subjudulnya adalah Monitoring.

      2. Temukan pemeriksaan uptime Anda, pilih Lainnya, lalu pilih Tambahkan kebijakan pemberitahuan.
      3. Dalam dialog, buka bagian Notifications and name, luaskan Notification Channels, lalu buat pilihan Anda.
      4. Beri nama kebijakan pemberitahuan, lalu klik Create policy.

    Anda dapat membuat kebijakan pemberitahuan dengan menambahkan resource google_monitoring_alert_policy ke file konfigurasi dan menerapkan konfigurasi baru.

Mungkin ada penundaan hingga 5 menit sebelum hasil pemeriksaan uptime mulai mengalir ke Monitoring. Selama waktu tersebut, dasbor pemeriksaan uptime melaporkan status sebagai "tidak ada data yang tersedia".

Menggunakan ping ICMP

Untuk membantu memecahkan masalah kegagalan cek uptime publik, Anda dapat mengonfigurasi cek uptime untuk mengirim hingga 3 ping ICMP selama pemeriksaan. Ping dapat membantu Anda membedakan antara kegagalan yang disebabkan, misalnya, oleh masalah konektivitas jaringan dan waktu tunggu habis di aplikasi Anda.

Secara default, pemeriksaan waktu beroperasi tidak mengirim ping. Setiap ping menambahkan beberapa latensi ke pemeriksaan uptime. Pemeriksaan uptime pribadi tidak dapat mengirim ping.

Jika pemeriksaan uptime publik gagal, hasil ping akan ditulis ke log Cloud Logging. Jika ping gagal, kolom berikut akan ditambahkan ke kolom httpRequest dalam entri log:

  • rtt_usec: waktu bolak-balik untuk setiap permintaan ping yang gagal.
  • unreachable_count: jumlah permintaan ping yang menampilkan kode status ICMP_DEST_UNREACH.
  • no_answer_count: jumlah permintaan ping yang waktu tunggunya habis dan tidak menampilkan respons.

Hasil ping untuk pemeriksaan uptime yang berhasil tidak dicatat ke dalam log.

Mengonfigurasi ping

Setiap konfigurasi pemeriksaan waktu aktif menyertakan objek HttpCheck atau objek TcpCheck. Kedua objek ini menyertakan kolom pingConfig. Gunakan kolom ini untuk menentukan jumlah ping ICMP yang akan disertakan dengan setiap pemeriksaan, maksimal 3. Secara default, tidak ada ping yang dikirim.

Untuk mengonfigurasi ping, lakukan salah satu hal berikut:

  • Saat menggunakan konsol Google Cloud, luaskan Opsi target lainnya dan masukkan nilai di kolom ICMP Pings.

  • Saat menggunakan Cloud Monitoring API, gunakan objek PingConfig, yang memiliki struktur berikut:

    {
  "pingsCount": integer
}

    Untuk informasi selengkapnya tentang cara menggunakan Monitoring API untuk konfigurasi pemeriksaan waktu aktif, lihat Membuat pemeriksaan waktu aktif: API atau Mengedit pemeriksaan waktu aktif: API.

Memverifikasi cek uptime

Saat membuat pemeriksaan uptime di konsol Google Cloud, Anda dapat menguji konfigurasi sebelum menyimpannya.

Pemeriksaan yang berhasil

Pemeriksaan waktu aktif berhasil jika kondisi berikut terpenuhi:

  • Status HTTP cocok dengan kriteria yang Anda pilih.
  • Respons tidak memiliki konten yang diperlukan atau penelusuran respons untuk konten yang diperlukan berhasil.

Pemeriksaan yang gagal

Berikut adalah beberapa kemungkinan penyebab kegagalan pemeriksaan waktu aktif:

  • Error Koneksi - Ditolak: Jika Anda menggunakan jenis koneksi HTTP default, pastikan Anda telah menginstal server web yang merespons permintaan HTTP. Error koneksi dapat terjadi pada instance baru jika Anda belum menginstal server web; lihat Panduan memulai untuk Compute Engine. Jika menggunakan jenis koneksi HTTPS, Anda mungkin harus melakukan langkah-langkah konfigurasi tambahan. Untuk masalah firewall, lihat Mencantumkan alamat IP server cek uptime.
  • Nama atau layanan tidak ditemukan: Nama host mungkin salah.
  • 403 Dilarang: Layanan menampilkan kode error ke pemeriksa uptime. Misalnya, konfigurasi server web Apache default menampilkan kode ini di Amazon Linux, tetapi menampilkan kode 200 (Sukses) di beberapa versi Linux lainnya. Lihat tutorial LAMP untuk Amazon Linux atau dokumentasi server web Anda.
  • 404 Not found: Jalur mungkin salah.

  • 408 Waktu tunggu permintaan habis, atau tidak ada respons: Nomor port mungkin salah, layanan mungkin tidak berjalan, layanan mungkin tidak dapat diakses, atau waktu tunggu mungkin terlalu rendah. Pastikan firewall Anda mengizinkan traffic dari server uptime; lihat Mencantumkan alamat IP server cek uptime. Batas waktu tunggu ditentukan sebagai bagian dari opsi Validasi Respons.

    Waktu tunggu permintaan mungkin terjadi karena kemacetan jaringan. Misalnya, karena kepadatan jaringan sementara, Anda mungkin melihat bahwa satu pemeriksa gagal, tetapi semua pemeriksa lainnya berhasil. Kegagalan satu pemeriksa tidak menyebabkan notifikasi saat kebijakan pemberitahuan Anda menggunakan konfigurasi default.

Jika pemeriksaan uptime Anda dikonfigurasi untuk mengirim ping, hasil ping untuk pemeriksaan uptime yang gagal akan ditulis ke Cloud Logging. Untuk informasi selengkapnya, lihat Menggunakan ping ICMP.

Langkah selanjutnya