Membuat cek uptime publik

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

Cek uptime publik dapat menentukan ketersediaan resource yang dimonitor berikut:

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

Tentang cek uptime

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

Agar cek uptime berhasil, kondisi berikut harus dipenuhi:

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

Cek uptime tidak memuat aset halaman atau menjalankan JavaScript, dan konfigurasi default cek uptime tidak menyertakan autentikasi.

Sebelum memulai

  1. Untuk mendapatkan izin yang Anda perlukan guna membuat cek uptime, minta administrator untuk memberi Anda peran IAM berikut di project Anda:

    • Editor Pemantauan (roles/monitoring.editor) - Pengguna konsol Google Cloud
    • Editor Konfigurasi Cek Uptime Monitoring (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 pemberian peran, lihat Mengelola akses.

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

  2. Pastikan resource yang ingin diperiksa memiliki endpoint publik atau berada di belakang firewall yang dapat dikonfigurasi.

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

  3. Jika resource Anda berada di belakang firewall, konfigurasikan firewall tersebut untuk mengizinkan traffic masuk dari alamat IP server cek uptime. Untuk mengetahui informasi lebih lanjut, lihat Mencantumkan alamat IP server cek uptime.

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

  5. Identifikasi setidaknya tiga checker untuk cek uptime Anda. Wilayah cek uptime USA mencakup wilayah USA_OREGON, USA_IOWA, dan USA_VIRGINIA. Setiap region USA_* memiliki satu pemeriksa, dan USA menyertakan ketiganya. Wilayah cek 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, cek uptime akan dikeluarkan dari semua region cek uptime.

Membuat cek uptime

Bagian ini menjelaskan cara membuat dan mengonfigurasi cek uptime.

Guna membuat cek uptime untuk load balancer eksternal yang memiliki minimal satu port TCP atau HTTP/s yang dikonfigurasi, Anda dapat mengikuti petunjuk berikut. Alternatifnya adalah dengan membuka halaman Detail layanan untuk layanan, lalu klik Buat cek uptime. Saat Anda memulai dari halaman Detail layanan, kolom khusus layanan akan terisi otomatis.

Konsol

Untuk membuat cek uptime menggunakan konsol Google Cloud, lakukan langkah berikut:

  1. Di panel navigasi konsol Google Cloud, pilih Monitoring, lalu pilih  Uptime checks:

    Buka Cek uptime

  2. Klik Buat Cek Uptime.

    Membuat dialog cek 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.
      • Kubernetes LoadBalancer Service: Layanan Kubernetes jenis LoadBalancer.
      • Instance: Instance Compute Engine atau AWS EC2.
      • App Engine: Aplikasi App Engine (modul).
      • Load Balancer Elastis: 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 cek uptime 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 resource instance dan load balancer, target adalah alamat IP yang berasal dari nama yang Anda berikan untuk resource atau grup resource.

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

        Misalnya, untuk melakukan cek uptime 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 memberikan cek uptime ke pengendali '/', kosongkan kolom Path. Untuk mengeluarkan cek uptime 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 Load Balancer Elastis dan Instance, lengkapi kolom Berlaku untuk sebagai berikut:

        • Untuk mengeluarkan cek uptime ke satu instance atau load balancer, pilih Single, lalu gunakan menu untuk memilih instance atau load balancer tertentu.
        • Untuk memberikan cek uptime ke grup Monitoring, pilih Group, lalu gunakan menu untuk memilih nama grup.

    5. Opsional: Untuk menetapkan seberapa sering cek uptime dijalankan, gunakan kolom Check frekuensi.

    6. Opsional: Untuk memilih region pemeriksa, atau mengonfigurasi sertifikat SSL, autentikasi, header, dan port untuk pemeriksaan HTTP dan HTTPS, klik More target options:

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

      • Authentication: Nilai ini dikirim sebagai header Otorisasi. Bidang 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 agen layanan pemantauan. 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. Cek uptime gagal jika URL memiliki sertifikat yang tidak valid. Alasan sertifikat tidak valid meliputi:

        • Sertifikat yang habis masa berlakunya
        • Sertifikat yang ditandatangani sendiri
        • Sertifikat dengan nama domain tidak cocok
        • Sertifikat yang menggunakan ekstensi Authority Information Access (AIA).

        Untuk memaksakan pemeriksaan waktu beroperasi HTTPS guna memvalidasi sertifikat SSL, pilih Validasi sertifikat SSL.

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

        Jika Anda memiliki Sertifikat SSL dengan Ekstensi AIA, Anda harus menonaktifkan validasi sertifikat SSL. Jenis sertifikat ini tidak didukung dan gagal dalam urutan validasi. Biasanya, pesan error-nya adalah "Direspons 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 akan memberi tahu Anda sebelum masa berlaku sertifikat Anda berakhir. Untuk mengetahui informasi selengkapnya, lihat Contoh kebijakan: Kebijakan cek uptime.

        Pilih kotak centang Validate SSL certificate.

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

    • Untuk mengubah periode waktu tunggu cek uptime, gunakan kolom Waktu Tunggu Respons. Cek uptime akan gagal saat tidak ada respons yang diterima dari lebih dari satu lokasi dalam periode ini.

    • Untuk mengonfigurasi cek uptime guna melakukan pencocokan konten, pastikan label beralihnya adalah Pencocokan konten diaktifkan:

      • Pilih Response Content Match Type dari menu opsi. Kolom ini menentukan cara konten respons dibandingkan dengan data yang ditampilkan. Misalnya, asumsikan konten respons adalah abcd dan jenis pencocokan konten adalah Berisi. Cek uptime hanya berhasil jika data respons berisi abcd. Untuk mengetahui informasi selengkapnya, baca bagian Memvalidasi data respons.
      • Masukkan Konten respons. Konten respons harus berupa string yang berukuran maksimal 1.024 byte. Di API, kolom ini adalah objek ContentMatcher.

    • Untuk mencegah entri log dibuat karena cek uptime, hapus Log check failed.

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

  5. Klik Lanjutkan dan konfigurasikan notifikasi.

    Agar menerima notifikasi saat cek uptime gagal, buat kebijakan pemberitahuan dan konfigurasi saluran notifikasi untuk kebijakan tersebut:

    1. Opsional: Perbarui nama kebijakan pemberitahuan.
    2. Opsional: Di kolom Durasi, pilih berapa lama cek uptime harus gagal sebelum notifikasi dikirim. Secara default, notifikasi dikirim saat setidaknya dua region melaporkan kegagalan cek uptime selama durasi setidaknya satu menit.

    3. Di kotak berlabel Notification channels, klik Menu, pilih saluran yang akan ditambahkan, lalu klik OK.

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

    Jika Anda tidak ingin membuat kebijakan pemberitahuan, pastikan teks tombolnya adalah Do not create an alert.

  6. Klik Continue dan selesaikan cek uptime Anda:

    1. Masukkan judul deskriptif untuk cek uptime.

    2. Opsional: Untuk menambahkan label yang ditentukan pengguna ke cek uptime Anda, lakukan tindakan berikut:

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

    3. Untuk memverifikasi konfigurasi cek uptime Anda, klik Test. Jika hasilnya tidak sesuai harapan, lihat Memeriksa kegagalan, memperbaiki konfigurasi, lalu ulangi langkah verifikasi.

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

gcloud

Untuk membuat cek uptime, jalankan perintah gcloud monitoring uptime create:

gcloud monitoring uptime create DISPLAY_NAME REQUIRED_FLAGS OPTIONAL_FLAGS

Sebelum Anda menjalankan perintah sebelumnya, lakukan hal berikut:

  • Ganti DISPLAY_NAME dengan nama untuk cek uptime Anda.

  • Konfigurasikan REQUIRED_FLAGS untuk menentukan pemeriksaan resource berdasarkan cek uptime. Misalnya, perintah berikut membuat cek uptime 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 flag --protocol jika protokol bukan http.

API

Untuk membuat cek uptime, panggil metode projects.uptimeCheckConfigs.create. Tetapkan parameter metode sebagai berikut:

  • parent: Wajib diisi. Ini harus merupakan nama project untuk membuat cek uptime. Ganti PROJECT_ID dengan project ID Google Cloud Anda. Formatnya adalah:

    projects/PROJECT_ID

  • Isi permintaan harus berisi objek UptimeCheckConfig untuk pemeriksaan uptime yang 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 menyetel 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 dihapus atau ditetapkan ke METHOD_UNSPECIFIED, permintaan GET akan dikeluarkan.

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

Metode create menampilkan objek UptimeCheckConfig untuk konfigurasi baru.

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

C#

Untuk mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 cek uptime dan kebijakan pemberitahuan untuk memantau cek tersebut, lakukan langkah berikut:

  1. Edit file konfigurasi Terraform Anda 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 cek uptime Anda.

    1. Untuk membuat saluran notifikasi, lakukan hal berikut:

      1. Di panel navigasi konsol Google Cloud, pilih Monitoring, lalu pilih  Alerting:

        Buka Alerting

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

    2. Untuk membuat kebijakan pemberitahuan, lakukan langkah berikut:

      1. Di panel navigasi konsol Google Cloud, pilih Monitoring, lalu pilih  Uptime checks:

        Buka Cek uptime

      2. Temukan cek uptime Anda, pilih Lainnya, lalu pilih Add alert policy.
      3. Pada dialog yang muncul, buka bagian Notifikasi dan nama, luaskan Saluran Notifikasi, lalu tentukan 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 akan ada penundaan hingga 5 menit sebelum hasil cek uptime mulai masuk ke Monitoring. Selama waktu itu, dasbor cek uptime melaporkan status sebagai "tidak ada data yang tersedia".

Menggunakan ping ICMP

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

Secara default, cek uptime tidak mengirim ping. Setiap ping menambahkan latensi ke cek uptime. Cek uptime pribadi tidak dapat mengirim ping.

Jika cek 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 round-trip untuk setiap permintaan ping yang gagal.
  • unreachable_count: jumlah permintaan ping yang menampilkan kode status ICMP_DEST_UNREACH.
  • no_answer_count: jumlah permintaan ping dengan waktu habis dan tidak menampilkan respons.

Hasil ping untuk cek uptime yang berhasil tidak akan dicatat.

Mengonfigurasi ping

Setiap konfigurasi cek uptime mencakup 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, hingga 3. Secara default, tidak ada ping yang dikirim.

Untuk mengonfigurasi ping, lakukan salah satu hal berikut:

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

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

    {
  "pingsCount": integer
}

    Untuk mengetahui informasi selengkapnya tentang cara menggunakan Monitoring API untuk konfigurasi cek uptime, lihat Membuat cek uptime: API atau Mengedit cek uptime: API.

Memverifikasi cek uptime Anda

Saat membuat cek uptime di Konsol Google Cloud, Anda dapat menguji konfigurasi sebelum menyimpannya.

Pemeriksaan berhasil

Cek uptime akan 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 cek uptime:

  • 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. Baca 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 waktu beroperasi. Misalnya, konfigurasi server web Apache default menampilkan kode ini pada Amazon Linux, tetapi menampilkan kode 200 (Success) pada beberapa versi Linux lainnya. Lihat tutorial LAMP untuk Amazon Linux atau dokumentasi server web Anda.
  • 404 Not found: Jalur mungkin salah.
  • Waktu tunggu permintaan 408, atau tidak ada respons: Nomor port mungkin salah, layanan mungkin tidak berjalan, layanan mungkin tidak dapat diakses, atau waktu tunggu mungkin terlalu rendah. Periksa apakah firewall Anda mengizinkan traffic dari server waktu beroperasi; lihat Mencantumkan alamat IP server cek uptime. Batas waktu tunggu ditentukan sebagai bagian dari opsi Validasi Respons.

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

Langkah selanjutnya