Synthetische Überwachung als Code mit Checkly und ilert

Dieser Beitrag stellt Checkly vor, die Lösung für synthetische Überwachung, und ihren Ansatz der Überwachung als Code. Dieser Gastbeitrag wurde von Hannes Lenke, dem CEO und Mitbegründer von Checkly, verfasst.

Zunächst einmal vielen Dank an Birol und das ilert-Team für die Gelegenheit, Checkly vorzustellen. ilert hat kürzlich angekündigt, seine Funktion zur Überwachung der Betriebszeit einzustellen, und mit uns an einer Integration gearbeitet, um sicherzustellen, dass bestehende Kunden nahtlos migrieren können.

Also, was ist Überwachung als Code und Checkly? Lassen Sie uns eintauchen!

Checkly und Überwachung als Code mit Terraform und CLI

Checkly ist die synthetische Überwachungslösung für moderne Entwickler, DevOps, SRE und Plattformtechnik-Teams mit Hunderten von Kunden weltweit, die die Plattform nutzen, um Software selbstbewusst bereitzustellen. Es ermöglicht die Konfiguration global verteilter API- und Browser-Überwachungen, die Alarme auslösen, wenn etwas schiefgeht.

‍

Bei Checkly sind wir der Meinung, dass die Überwachung als Code beginnen, automatisiert sein und in Ihrem Repository leben sollte. Überwachung als Code ermöglicht es Ihnen, API- und Browser-Checks von Ihrem Code-Repository aus zu codieren, zu testen und bereitzustellen und diese als Tests auszuführen oder als Überwachungen zu planen.

Derzeit unterstützt Checkly drei Tools für den Workflow der Überwachung als Code:

1. Der Checkly CLI
2. Ein Terraform-Anbieter
3. Ein Pulumi-Anbieter

Das beste Tool hängt von Ihren Zielen und der Struktur Ihrer Organisation ab.

Lassen Sie uns eintauchen und lernen, wie Sie Überwachungen über Terraform oder das Checkly CLI einrichten können.

‍

Konfiguration von Überwachungen über Terraform

Der Checkly Terraform-Anbieter ermöglicht es Ihnen, Ihre Einrichtung mithilfe von HashiCorp Terraform zu deklarieren. Beginnen Sie damit, indem Sie den Anweisungen im Einführungshandbuch folgen.

Zusammengefasst: Fügen Sie den Checkly Terraform-Anbieter Ihrem Projekt hinzu, legen Sie Ihre Anmeldeinformationen fest und konfigurieren Sie API- und Browser-Überwachungen über die gemeinsame Terraform-Syntax.

Zum Beispiel fügen Sie eine API-Check-Ressource am Ende Ihrer vorhandenen Terraform-Datei hinzu, um einen API-Monitor zu erstellen.

resource "checkly_check" "example-check" {
  name      = "Example check"
  type      = "API"
  activated = true
  frequency = 1

  locations = [
    "us-west-1",
    "eu-central-1"
  ]

  request {
    url              = "https://api.example.com/"
    follow_redirects = true
    skip_ssl         = false
    assertion {
      source     = "STATUS_CODE"
      comparison = "EQUALS"
      target     = "200"
    }
  }

Dieser API-Check überwacht api.example.com einmal pro Minute, läuft an zwei Standorten (us-west-1 und eu-central-1) und prüft auf einen ordnungsgemäßen 200-Statuscode.

Aber Ihr Überwachungsstack sollte nicht nur aus API-Checks bestehen!

Die Überwachung von Headless-Browsern ermöglicht es Ihnen, die Benutzererfahrung Ihrer Apps kontinuierlich zu testen. Ein Headless-Browser-Check kann über den folgenden Terraform-Code konfiguriert werden:

resource "checkly_check" "example-check" {
  name      = "Example check"
  type      = "API"
  activated = true
  frequency = 1

  locations = [
    "us-west-1",
    "eu-central-1"
  ]

  request {
    url              = "https://api.example.com/"
    follow_redirects = true
    skip_ssl         = false
    assertion {
      source     = "STATUS_CODE"
      comparison = "EQUALS"
      target     = "200"
    }
  }

Der definierte Browser-Check verwendet Playwright (ein modernes JavaScript-Testframework), um einen Browser zu starten und zu testen, ob die Seite unter playwright.dev mit dem korrekten Titel geliefert wird. Der Check wird alle fünf Minuten an zwei Standorten (eu-central-1 und us-west-1) durchgeführt, und der Parameter double_check legt fest, dass er im Falle eines Fehlers erneut durchgeführt wird, um die Zuverlässigkeit zu gewährleisten.

Nachdem Sie Ihre Überwachungen definiert haben, möchten Sie einen Alarmkanal einrichten, um sofort informiert zu werden, wenn einer fehlschlägt. Befolgen Sie diese Anleitung, erstellen Sie eine neue Checkly-Alarmquelle in ilert und speisen Sie sie mit Überwachungsfehlern von Checkly.

‍

Die Verbindung beider Dienste dauert nur wenige Minuten!

‍

Aber was ist, wenn Sie nicht darauf erpicht sind, Terraform zu verwenden?

Konfiguration von Überwachungen über das Checkly CLI

Das Checkly CLI bietet einen JavaScript/TypeScript-nativen Workflow aus Ihrem Code-Bestand für das Codieren, Testen und Bereitstellen synthetischer Überwachungen im großen Maßstab. Es wird mit nativer Unterstützung für Playwright-Tests geliefert und ermöglicht es Ihnen, Ihre Überwachungsinfrastruktur in Code bereitzustellen, ähnlich wie der Terraform-Anbieter.

Die Hauptvorteile des Checkly CLI sind:

1. Es vereint End-to-End-Tests und Überwachung in einem Workflow.
2. Es ist programmierbar, testbar und überprüfbar. Es funktioniert mit Ihrer Entwicklungs-Pipeline. Von Ihrer IDE über CI bis hin zur Produktion.
3. Es unterstützt Playwright-Tests nativ. (Keine Bindung; einfach Standard-*.spec.ts-Dateien schreiben).
4. Es ermöglicht es Ihnen, Ihre Alarmkanalressourcen zu definieren und zu codieren. Legen Sie Alarme für Slack, SMS und viele weitere Kanäle fest.
5. Es ist TypeScript-First und vollständig getypt für ein herausragendes Entwicklererlebnis mit Code-Vervollständigung.
6. Es kann in der Cloud oder Ihrem Netzwerk unter Verwendung von Private Locations ausgeführt werden

Die empfohlene Möglichkeit, ein neues Checkly CLI-Projekt zu initialisieren, besteht darin, den folgenden Befehl auszuführen.

npm create checkly

Folgen Sie unserer Documentation, wenn Sie loslegen möchten und nach detaillierten Einrichtungsanweisungen suchen.

Obwohl es viele Details zur Überwachung als Code mit dem Checkly CLI gibt, hebt dieser Artikel die grundlegenden Konzepte zur Erstellung von API- und Browser-Überwachungen hervor.

Erstellen Sie einen einfachen API-Check, indem Sie die öffentliche Checkly-API in einer api-check.check.ts-Datei wie folgt abrufen.

// api-check.check.ts
import { ApiCheck, AssertionBuilder, Frequency } from 'checkly/constructs'

new ApiCheck("hello-api", {
  name: "Hello API",
  locations: ["ap-south-1"],
  frequency: Frequency.EVERY_30_MINUTES,
  request: {
    method: "GET",
    url: "https://api.checklyhq.com/v1/runtimes",
    assertions: [AssertionBuilder.statusCode().equals(200)],
  },
});

Definieren Sie Browser-Checks über die Standard-Playwright-Testsyntax und importieren Sie diese automatisch aus Ihrem Repository über die globale Check-Übereinstimmungskonfiguration.

Hier ist ein Beispiel für einen Browser-Check, bei dem sich in einen Webshop eingeloggt wird, um die Anmelde-Routine zu testen.

import {test, expect} from "@playwright/test"

test("login", async ({page}) => {
  await page.goto("https://danube-web.shop/");
  await page.getByPlaceholder("Email").fill("user@email.com");
  await page.getByPlaceholder("Password").fill("supersecure");
  await page.getByRole("button", {name: "Sign in"}).click();

  await expect(page.getByText("Welcome back, user@email.com")).toBeVisible();
})

Ähnlich wie beim Terraform-Anbieter ermöglicht uns das CLI, Alarme einzurichten, um sicherzustellen, dass wir sofort informiert werden, wenn ein Fehler auftritt. Alarmkanäle können als Konstrukte deklariert werden, genau wie die API- und Browser-Checks, die Sie bereits oben gesehen haben.

Lassen Sie uns das Folgende zu einer Datei mit dem Namen "alert-channels.ts" in unserem Checkly CLI-Projekt hinzufügen:

// alert-channels.ts
import { EmailAlertChannel } from "checkly/constructs";

const sendDefaults = {
  sendFailure: true,
  sendRecovery: true,
  sendDegraded: false,
}

export const emailChannel = new EmailAlertChannel("email-channel-1", {
  address: "user@email.com",
  ...sendDefaults
})

Dieser Code definiert einen Alarmkanal, aber das allein reicht nicht aus, um bei fehlgeschlagenen Überprüfungen alarmiert zu werden. Warum nicht?

Um Alarme zu erhalten, müssen Sie Überprüfungen programmatisch mit Alarmkanälen über die Eigenschaft "alertChannels" verbinden. Auf diese Weise behalten Sie die volle Kontrolle über Ihre Überprüfungen und die von ihnen ausgelösten Alarme.

import { ApiCheck, AssertionBuilder, Frequency } from 'checkly/constructs'
import { emailChannel } from './email-channel'

new ApiCheck("hello-api", {
  name: "Hello API",
  locations: ["ap-south-1"],
  // define alert channel for this check
  alertChannels: [emailChannel],
  frequency: Frequency.EVERY_30_MINUTES,
  request: {
    method: "GET",
    url: "https://api.checklyhq.com/v1/runtimes",
    assertions: [AssertionBuilder.statusCode().equals(200)],
  },
});

Nachdem Sie alle Ressourcen definiert haben, wendet ein schnelles checkly deploy die Änderungen auf unserem Checkly-Konto an. Wir sind jetzt vollständig einsatzbereit, und unsere Checks werden planmäßig durchgeführt und informieren uns prompt, wenn etwas schiefgehen sollte. Das schnelle Erkennen von Fehlern in Ihrer API und in wichtigen Website-Abläufen ermöglicht es uns, schnell zu reagieren und negative Auswirkungen auf Ihre Benutzer zu minimieren.

Zusammenfassung

Wenn Sie ein ilert-Benutzer sind, der Terraform verwendet, großartig! Sie werden sich freuen zu erfahren, dass Checkly vollständig kompatibel mit diesem Workflow ist und sich nahtlos in ilert integriert, was es zu einer ausgezeichneten Option für diejenigen macht, die einen neuen Dienst zur Überwachung der Betriebszeit suchen.

Wenn Sie keine Infrastruktur als Code-Lösung verwenden, aber dennoch Überwachung als Code übernehmen möchten, ist das Checkly CLI die perfekte Lösung, um zu starten.

Und in jedem Fall, wenn Sie mehr über Checkly erfahren möchten, würden wir uns freuen, Ihnen eine Demo anzubieten und Sie einladen, es unter checklyhq.com zu testen.