Kostenkontrolle

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Architektur

Cost Sentry umfasst eine Reihe von Skripts und Konfigurationen, mit denen Sie Ressourcen herunterfahren können, wenn Google Cloud Billing-Budgets überschritten werden.

Dieses Skript setzt sich aus den folgenden Komponenten zusammen :

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

Dieses Skript richtet ein Budget, eine Nachrichtenwarteschlange und eine Cloud Functions-Funktion ein, um all das zu verwalten. Anschließend werden eine Beispiel-VM und ein containergestützter Dienst erstellt, der vom System verwaltet wird.

Jetzt starten

Klicken Sie auf den folgenden Link, um eine Kopie des Quellcodes in Cloud Shell zu erhalten. Dort wird mit einem einzigen Befehl eine funktionierende Kopie der Anwendung in Ihrem Projekt erstellt.

In Cloud Shell öffnen

Quellcode auf GitHub ansehen

Cost Sentry-Komponenten

Bei der Cost Sentry-Architektur werden mehrere Produkte verwendet. Im Folgenden sind die Komponenten und weitere Informationen zu den Komponenten aufgeführt, darunter 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 Messaging-Bus zur Integration von Anwendungen in verschiedenen Diensten auf verschiedenen Cloud-Komponenten in ein integriertes System.
Abrechnungsbudgets Mit Abrechnungsbudgets werden Sie benachrichtigt und können Maßnahmen ergreifen, wenn die von Ihnen festgelegten Grenzwerte überschritten werden.
Cloud Functions Cloud Functions ist eine Dienstplattform, auf der Sie Uploads von Cloud Storage-Dateien beobachten und Code zur Erstellung von Miniaturansichten ausführen können.
Compute Engine Compute Engine ist die virtuelle Technologie von Google Cloud. Damit können Sie viele verschiedene VM-Konfigurationen erstellen, die sich an die Form Ihrer Computing-Anforderungen anpassen.
Cloud Run Mit Cloud Run können Sie Anwendungen in einem Container, aber serverlos ausführen, ohne die Anzahl der Instanzen, Prozessoren oder des Arbeitsspeichers konfigurieren zu müssen. Laden Sie einen Container hoch und rufen Sie eine URL ab.

Skripts

Das Installationsskript verwendet eine ausführbare Datei, die in go und den Terraform-Befehlszeilentools geschrieben wurde, um ein leeres Projekt zu übernehmen und die Anwendung darin zu installieren. Die Ausgabe sollte eine funktionierende Anwendung und eine URL für die IP-Adresse des Load-Balancings 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 Abrechnungen verwalten und Abrechnungsbenachrichtigungen verwalten.
  • Cloud Build: Container-Images erstellen und in Cloud Run bereitstellen.
  • Compute Engine: Virtuelle Maschinen und Netzwerkdienste wie Load-Balancing implementieren
  • Cloud Functions – Auf Dienstplattformereignisse reagieren
  • Cloud Run – 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 Ereignisse des Abrechnungsbudgets im Blick zu behalten und mit Cloud Functions zu antworten

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

Zu erzwingende Cloud Run-Dienst erstellen

Erstellen Sie einen Cloud Run-Beispieldienst, für den 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

Erstellt ein Budget zur Überwachung der Ausgaben für Ihre Projekte.

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, mit denen Cloud Build die erforderlichen Dienste bereitstellen kann.

Die Reihe von Befehlen implementiert Folgendes: Gewährt dem Cloud Functions-Dienstkonto die Berechtigung zum Verwalten von Cloud Run. Gewährt dem Cloud Functions-Dienstkonto die Berechtigung, Compute Engine-Instanzen zu beenden. Gewährt 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 Functions-Funktion 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 Kostenkontrolllösung ausgeführt werden. Außerdem sollten Sie den gesamten Code haben, um diese Lösung an Ihre Umgebung anzupassen.