Cost Sentry

+

Architektur

Cost Sentry besteht aus einer Reihe von Scripts und Konfigurationen, mit denen Sie Ressourcen herunterfahren können, wenn Google Cloud-Abrechnungsbudgets überschritten werden.

Dieses Script besteht aus den folgenden Komponenten :

  • Ereignisse – Warteschlange – Pub/Sub
  • Abrechnung – Kostenkontrolle – Budgets
  • Ereignisse – Ereignisbehandlung – Cloud Functions
  • Compute – VMs – Compute Engine
  • Computing – Serverless – Cloud Run

Mit diesem Script werden ein Budget, eine Nachrichtenwarteschlange und eine Cloud Function eingerichtet, um all das zu verwalten. Anschließend werden eine Beispiel-VM und ein containergestützter Dienst gestartet, der vom System verwaltet wird.


Jetzt starten

Klicken Sie auf den folgenden Link, um eine Kopie des Quellcodes in Cloud Shell aufzurufen. Dort können Sie mit einem einzigen Befehl eine funktionierende Kopie der Anwendung in Ihrem Projekt erstellen.

In Cloud Shell öffnen

Quellcode auf GitHub ansehen


Cost Sentry-Komponenten

Die Cost Sentry-Architektur nutzt mehrere Produkte. Im Folgenden finden Sie eine Liste der Komponenten sowie weitere Informationen zu den Komponenten, einschließlich Links zu ähnlichen Videos, Produktdokumentationen und interaktiven Schritt-für-Schritt-Anleitungen.
Video Docs Schritt-für-Schritt-Anleitungen
Cloud Pub/Sub Google Cloud Pub/Sub ist ein Nachrichtenbus, mit dem Anwendungen in verschiedenen Diensten auf verschiedenen Cloud-Komponenten in ein integriertes System eingebunden werden können.
Abrechnungsbudgets Mit Abrechnungsbudgets können Sie benachrichtigt werden und Maßnahmen ergreifen, wenn Ihre Abrechnung die von Ihnen festgelegten Grenzwerte überschreitet.
Cloud Functions Cloud Functions ist eine Funktionsplattform, mit der Sie auf Cloud Storage-Dateiuploads warten und Code ausführen können, um daraus Thumbnails zu erstellen.
Compute Engine Die Compute Engine ist die virtuelle Technologie von Google Cloud. Damit können Sie viele verschiedene VM-Konfigurationen erstellen, die Ihren Rechenanforderungen entsprechen.
Cloud Run Mit Cloud Run können Sie Anwendungen in einem Container ausführen, aber auf serverlose Weise, ohne die Anzahl der Instanzen, Prozessoren oder des Arbeitsspeichers konfigurieren zu müssen. Container hochladen, URL abrufen

Skripts

Das Installationsskript verwendet eine in go geschriebene ausführbare Datei und Terraform-Befehlszeilentools, um ein leeres Projekt zu erstellen und die Anwendung darin zu installieren. Die Ausgabe sollte eine funktionierende Anwendung und eine URL für die Load Balancing-IP-Adresse sein.

./main.tf

Dienste aktivieren

Google Cloud-Dienste sind in einem Projekt standardmäßig deaktiviert. Aktivieren Sie die folgenden Dienste, um Cost Sentry zu verwenden:

  • Abrechnungsbudgets: Hier können Sie die Abrechnung im Blick behalten und Abrechnungsbenachrichtigungen verwalten.
  • Cloud Build: Container-Images erstellen und in Cloud Run bereitstellen
  • Compute Engine: Implementierung virtueller Maschinen und Netzwerkdienste wie Load Balancing.
  • Cloud Functions: Reaktion auf Ereignisse der Dienstplattform
  • Cloud Run: Hier können Sie Container in einer serverlosen Umgebung hosten und URLs für den Zugriff auf die Anwendung angeben.
variable "gcp_service_list" {
        description = "The list of apis necessary for the project"
        type        = list(string)
        default = [
            "cloudresourcemanager.googleapis.com",
            "cloudbilling.googleapis.com",
            "billingbudgets.googleapis.com",
            "cloudbuild.googleapis.com",
            "compute.googleapis.com",
            "cloudfunctions.googleapis.com",
            "storage.googleapis.com",
            "run.googleapis.com"
        ]
}

resource "google_project_service" "all" {
    for_each           = toset(var.gcp_service_list)
    project            = var.project_number
    service            = each.key
    disable_on_destroy = false
}

Pub/Sub-Kanal erstellen

Erstellt einen Pub/Sub-Kanal, um auf Budgetereignisse zu hören und mit Cloud Functions zu reagieren

resource "google_pubsub_topic" "costsentry" {
    name = "${var.basename}-billing-channel"
    project    = var.project_number
}

Cloud Run-Dienst zum Erzwingen erstellen

Erstellen Sie einen Beispiel-Cloud Run-Dienst, auf dem die Abrechnung erzwungen werden soll.

resource "google_cloud_run_service" "app" {
    name     = "${var.basename}-run-service"
    location = var.region
    project  = var.project_id

    metadata {
        labels = {"${var.label}"=true}
    }

    template {
        spec {
            containers {
                image = "us-docker.pkg.dev/cloudrun/container/hello"
            }
        }

        metadata {
            annotations = {
                "autoscaling.knative.dev/maxScale" = "1000"
                "run.googleapis.com/client-name"   = "terraform"
            }
        }
    }
    autogenerate_revision_name = true
    depends_on = [google_project_service.all]
}

VM-Instanz erstellen

Erstellen Sie eine Compute Engine-Beispielinstanz, auf der die Erzwingung ausgeführt werden soll.

resource "google_compute_instance" "example" {
    name         = "${var.basename}-example"
    machine_type = "n1-standard-1"
    zone         = var.zone
    project      = var.project_id
    tags                    = ["http-server"]
    labels = {"${var.label}"=true}

    boot_disk {
        auto_delete = true
        device_name = "${var.basename}-example"
        initialize_params {
            image = "family/debian-10"
            size  = 200
            type  = "pd-standard"
        }
    }   

    network_interface {
        network = "default"
        access_config {
        // Ephemeral public IP
        }
    }

    depends_on = [google_project_service.all]
}

Budget erstellen

Erstellen Sie ein Budget, um die Ausgaben für Ihre Projekte im Blick zu behalten.

provisioner "local-exec" {
    command = <<-EOT
    gcloud beta billing budgets create --display-name ${var.basename}-budget \
    --billing-account ${var.billing_account} --budget-amount ${var.budgetamount} \
    --all-updates-rule-pubsub-topic=projects/${var.project_id}/topics/${var.basename}-billing-channel
    EOT
}

Dienstkonto erstellen und Berechtigungen festlegen

Erstellt ein Dienstkonto für die Cloud Functions-Aufrufe.

resource "google_service_account" "functions_accounts" {
    account_id   = local.safunctionuser
    description  = "Service Account for the costsentry to run as"
    display_name = local.safunction
    project      = var.project_number
}

Berechtigungen festlegen

Mit dem folgenden Befehl werden IAM-Rollen und Berechtigungen festgelegt, die es Cloud Build ermöglichen, die erforderlichen Dienste bereitzustellen.

Mit der Befehlsreihe wird Folgendes implementiert: Das Cloud Functions-Dienstkonto erhält die Berechtigung zum Verwalten von Cloud Run. Gewährt dem Cloud Functions-Dienstkonto die Berechtigung, Compute Engine-Instanzen zu beenden. Erteilt dem Cloud Build-Dienstkonto die Berechtigung, im Namen des Compute-Dienstkontos zu handeln.

variable "build_roles_list" {
        description = "The list of roles that fucntions needs for"
        type        = list(string)
        default = [
            "roles/run.admin",
            "roles/compute.instanceAdmin",
            "roles/iam.serviceAccountUser"
        ]
}

resource "google_project_iam_member" "allbuild" {
    for_each   = toset(var.build_roles_list)
    project    = var.project_number
    role       = each.key
    member     = "serviceAccount:${google_service_account.functions_accounts.email}"
    depends_on = [google_project_service.all,google_service_account.functions_accounts]
}

Cloud Functions-Funktion bereitstellen

Mit dem folgenden Befehl wird eine Cloud Function bereitgestellt, die Ressourcen deaktiviert, wenn eine Benachrichtigung ausgelöst wird.

resource "google_storage_bucket" "function_bucket" {
    name     = "${var.project_id}-function-deployer"
    project  = var.project_number
    location = var.location
}

resource "null_resource" "cloudbuild_function" {
    provisioner "local-exec" {
        command = <<-EOT
        cp code/function/function.go .
        cp code/function/go.mod .
        zip index.zip function.go
        zip index.zip go.mod
        rm go.mod
        rm function.go
        EOT
    }

    depends_on = [
        google_project_service.all
    ]
}

resource "google_storage_bucket_object" "archive" {
    name   = "index.zip"
    bucket = google_storage_bucket.function_bucket.name
    source = "index.zip"
    depends_on = [
        google_project_service.all,
        google_storage_bucket.function_bucket,
        null_resource.cloudbuild_function
    ]
}

resource "google_cloudfunctions_function" "function" {
    name    = var.basename
    project = var.project_id
    region  = var.region
    runtime = "go116"
    service_account_email = google_service_account.functions_accounts.email
    available_memory_mb   = 128
    source_archive_bucket = google_storage_bucket.function_bucket.name
    source_archive_object = google_storage_bucket_object.archive.name
    entry_point           = "LimitUsage"
    event_trigger {
        event_type = "google.pubsub.topic.publish"
        resource   = google_pubsub_topic.costsentry.name
    }

    environment_variables = {
        GOOGLE_CLOUD_PROJECT = var.project_id
        LABEL= var.label
    }

    depends_on = [
        google_storage_bucket.function_bucket,
        google_storage_bucket_object.archive,
        google_project_service.all
    ]
}

Fazit

Nach der Ausführung sollte in Ihrem Projekt eine Lösung zur Kostenkontrolle ausgeführt werden. Außerdem sollten Sie den gesamten Code haben, um diese Lösung an Ihre Umgebung anzupassen oder zu erweitern.