Frais de port

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Architecture

Cost Sentry est un ensemble de scripts et de configurations qui vous permet d'arrêter les ressources en cas de dépassement des budgets de facturation Google Cloud.

Ce script se compose des éléments suivants :

  • Événements – File d'attente – Pub/Sub
  • Facturation - Contrôle des coûts - Budgets
  • Événements – Gestion des événements – Cloud Functions
  • Calcul – VM – Compute Engine
  • Calcul – Sans serveur – Cloud Run

Ce script configure un budget, une file d'attente de messages et une fonction Cloud pour gérer tout cela. Il génère ensuite un exemple de VM et un service de conteneurs gérés par le système.


Get Started

Cliquez sur le lien suivant pour accéder à une copie du code source dans Cloud Shell. Une seule commande suffit ensuite pour lancer une copie de travail de l'application dans votre projet.

Ouvrir dans Cloud Shell

Afficher le code source sur GitHub


Composants de Cost Sentry

L'architecture de Sentry utilise plusieurs produits. Vous trouverez ci-dessous la liste des composants, ainsi que des informations complémentaires, y compris des liens vers des vidéos similaires, la documentation du produit et des tutoriels interactifs.
Vidéo Docs Tutoriels
Google Cloud Pub/Sub Google Cloud Pub/Sub est un service de messagerie permettant d'intégrer des applications à différents services sur différents composants cloud au sein d'un système intégré.
Budgets de facturation Les budgets de facturation vous permettent de recevoir des notifications et de prendre des mesures lorsque votre facturation dépasse les seuils que vous avez définis.
Cloud Functions Cloud Functions est une plate-forme de services qui vous permet d'écouter des fichiers Cloud Storage importés et d'exécuter du code pour en créer des vignettes.
Compute Engine Compute Engine est la technologie virtuelle de Google Cloud. Elle vous permet de lancer de nombreuses configurations de VM pour répondre à vos besoins informatiques.
Cloud Run Cloud Run vous permet d'exécuter des applications dans un conteneur, mais sans serveur, sans avoir à configurer le nombre d'instances, de processeurs ou de mémoire. Importez un conteneur et obtenez une URL.

Scripts

Le script d'installation utilise un exécutable écrit dans go et les outils CLI Terraform pour effectuer un projet vide et y installer l'application. Le résultat doit être une application opérationnelle et une URL pour l'adresse IP d'équilibrage de charge.

./main.tf

Activer les services

Les services Google Cloud sont désactivés par défaut dans un projet. Pour utiliser la fonctionnalité Sentry de coûts, activez les services suivants:

  • Budgets de facturation : suivez la facturation et gérez les alertes de facturation.
  • Cloud Build : créez des images de conteneurs et déployez-les sur Cloud Run.
  • Compute Engine : implémentez des machines virtuelles et des services réseau, comme l'équilibrage de charge.
  • Cloud Functions : répondre aux événements de plate-forme de service
  • Cloud Run : hébergez des conteneurs dans un environnement sans serveur et fournissez des URL pour accéder à l'application.
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
}

Créer un canal Pub/Sub

crée un canal Pub/Sub pour écouter les événements du budget de facturation et répondre avec Cloud Functions ;

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

Créer un service Cloud Run à appliquer

Créer un exemple de service Cloud Run sur lequel exécuter la facturation

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]
}

Créer une instance de VM

Créer un exemple d'instance Compute Engine sur laquelle exécuter la mesure d'application

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]
}

Créer un budget

Il crée un budget pour surveiller les dépenses dans vos projets.

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
}

Créer un compte de service et définir des autorisations

crée un compte de service pour les appels de la fonction Cloud ;

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
}

Définir des autorisations

La commande suivante définit des rôles et des autorisations IAM permettant à Cloud Build de déployer les services requis.

La série de commandes met en œuvre ce qui suit : permet au compte de service Cloud Functions de gérer Cloud Run. Accorde au compte de service Cloud Functions l'autorisation d'arrêter les instances Compute Engine. Accorde au compte de service Cloud Build l'autorisation d'agir au nom du compte de service Compute.

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]
}

Déployer une fonction Cloud

La commande suivante déploie une fonction Cloud qui désactive les ressources lorsqu'une alerte est déclenchée.

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
    ]
}

Conclusion

Une fois l'exécution terminée, une solution de contrôle des coûts doit désormais s'exécuter dans votre projet. De plus, vous devez disposer de tout le code nécessaire pour modifier ou étendre cette solution en fonction de votre environnement.