Remark utiliser Terraform avec Rockset

L’objectif de cet article de weblog est de fournir les meilleures pratiques sur la façon d’utiliser terraform pour configurer Rockset pour ingérer les données dans deux collections, et remark configurer une vue et interroger les lambdas qui sont utilisés dans une software, ainsi que pour montrer le flux de travail de mise à jour ultérieure des lambdas de requête. Cela imite la façon dont nous utilisons terraform chez Rockset pour gérer les ressources Rockset.

Terraform est le plus utilisé DevOps outil de gestion d’infrastructure, qui vous permet de définir votre infrastructure en tant que codepuis l’outil prendra la configuration et calculera les étapes nécessaires pour la faire passer de l’état actuel à l’état souhaité.

Enfin, nous verrons remark utiliser les actions GitHub pour exécuter automatiquement terraform plan pour les demandes d’extraction, et une fois la demande d’extraction approuvée et fusionnée, elle s’exécutera terraform apply pour apporter les modifications requises.

La configuration complète de terraform utilisée dans cet article de weblog est disponible ici.

Terraforme

Pour suivre par vous-même, vous aurez besoin de :

et vous devez également installer terraform sur votre ordinateur, ce qui est aussi easy que cela sur macOS.

$ brew faucet hashicorp/faucet
$ brew set up hashicorp/faucet/terraform

(les directions pour les autres systèmes d’exploitation sont disponibles dans le lien ci-dessus)

Configuration du fournisseur

La première étape de l’utilisation terraform est de configurer les fournisseurs que nous utiliserons, Rockset et AWS. Créer un fichier nommé _provider.tf avec le contenu.

terraform {
  required_providers {
        aws = {
            supply = "hashicorp/aws"
            model = "~> 4"
    }
    rockset = {
      supply = "rockset/rockset"
            model = "0.6.2"
    }
  }
}

supplier rockset {}
supplier aws {
    area = "us-west-2"
}

Les deux fournisseurs utilisent des variables d’environnement pour lire les informations d’identification dont ils ont besoin pour accéder aux providers respectifs.

• Jeu de fusée : ROCKSET_APIKEY et ROCKSET_APISERVER
• AWS : AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEYou AWS_PROFILE

Configuration dorsale

Terraform enregistre les informations sur l’infrastructure gérée et la configuration dans un fichier d’état. Pour partager cet état entre les exécutions locales sur votre ordinateur et les exécutions automatisées à partir des actions GitHub, nous utilisons un soi-disant configuration dorsalequi stocke l’état dans un compartiment AWS S3, afin que toutes les invocations de terraform puissent l’utiliser.

backend "s3" {
    bucket = "rockset-community-terraform"
    key    = "weblog/state"
    area = "us-west-2"
  }

⚠️ Pour un déploiement en manufacturing, assurez-vous de configurer état de verrouillage aussi.

Rôle AWS IAM

Pour permettre à Rockset d’ingérer le contenu d’un compartiment S3, nous devons d’abord créer un rôle AWS IAM que Rockset utilisera pour accéder au contenu du compartiment. Il utilise un la supply de données pour lire des informations sur votre organisation Rockset, afin qu’elle puisse configurer AWS correctement.

knowledge rockset_account present {}

useful resource "aws_iam_policy" "rockset-s3-integration" {
  identify   = var.rockset_role_name
  coverage = templatefile("${path.module}/knowledge/coverage.json", {
    bucket = var.bucket
    prefix = var.bucket_prefix
  })
}

useful resource "aws_iam_role" "rockset" {
  identify               = var.rockset_role_name
  assume_role_policy = knowledge.aws_iam_policy_document.rockset-trust-policy.json
}

knowledge "aws_iam_policy_document" "rockset-trust-policy" {
  assertion {
    sid     = ""
    impact  = "Enable"
    actions = (
      "sts:AssumeRole"
    )
    principals {
      identifiers = (
        "arn:aws:iam::${knowledge.rockset_account.present.account_id}:root"
      )
      sort = "AWS"
    }
    situation {
      take a look at   = "StringEquals"
      values = (
        knowledge.rockset_account.present.external_id
      )
      variable = "sts:ExternalId"
    }
  }
}

useful resource "aws_iam_role_policy_attachment" "rockset_s3_integration" {
  function       = aws_iam_role.rockset.identify
  policy_arn = aws_iam_policy.rockset-s3-integration.arn
}

Cela crée un rôle entre comptes AWS IAM que Rockset est autorisé à utiliser pour ingérer des données.

Intégration de Rockset S3

Nous pouvons maintenant créer l’intégration qui permet à Rockset d’ingérer des données à partir de S3, en utilisant le rôle IAM ci-dessus.

useful resource "time_sleep" "wait_30s" {
  depends_on      = (aws_iam_role.rockset)
  create_duration = "15s"
}

useful resource "rockset_s3_integration" "integration" {
  identify         = var.bucket
  aws_role_arn = aws_iam_role.rockset.arn
  depends_on   = (time_sleep.wait_30s)
}

⚠️ Vous pouvez obtenir un AWS cross-account function erreur si vous sautez le time_sleep Ressourceautomotive la propagation du rôle AWS nouvellement créé prend quelques secondes, ce qui vous évite d’avoir à réexécuter terraform apply encore.

Assortment de fusées

Avec l’intégration, nous sommes maintenant en mesure de créer un espace de travail pour contenir toutes les ressources que nous ajouterons, puis de configurer un assortment qui ingèrent des données à l’aide de l’intégration S3 ci-dessus.

useful resource rockset_workspace weblog {
  identify = "weblog"
}

useful resource "rockset_s3_collection" "assortment" {
  identify           = var.assortment
  workspace      = rockset_workspace.weblog.identify
  retention_secs = var.retention_secs
  supply {
    format           = "json"
    integration_name = rockset_s3_integration.integration.identify
    bucket           = var.bucket
    sample          = "public/films/*.json"
  }
}

Assortment Kafka

Ensuite, nous allons configurer une assortment à partir d’une supply Confluent Cloud et ajouter un ingérer la transformation qui résume les données.

useful resource "rockset_kafka_integration" "confluent" {
  identify         = var.bucket
  aws_role_arn = aws_iam_role.rockset.arn
  use_v3            = true
  bootstrap_servers = var.KAFKA_REST_ENDPOINT
  security_config = {
    api_key = var.KAFKA_API_KEY
    secret  = var.KAFKA_API_SECRET
  }
}

useful resource "rockset_kafka_collection" "orders" {
  identify           = "orders"
  workspace      = rockset_workspace.weblog.identify
  retention_secs = var.retention_secs
  supply {
    integration_name = rockset_kafka_integration.confluent.identify
  }
  field_mapping_query = file("knowledge/transformation.sql")
}

Le SQL de la transformation d’ingestion est stocké dans un fichier séparé, que terraform injecte dans la configuration.

SELECT
    COUNT(i.orderid) AS orders,
    SUM(i.orderunits) AS models,
    i.handle.zipcode,
    i.handle.state,
    -- bucket knowledge in 5 minute buckets
    TIME_BUCKET(MINUTES(5), TIMESTAMP_MILLIS(i.ordertime)) AS _event_time
FROM
    _input AS i
WHERE
    -- drop all data with an incorrect state
    i.handle.state != 'State_'
GROUP BY
    _event_time,
    i.handle.zipcode,
    i.handle.state

Voir

Avec les données ingérées dans une assortment, nous pouvons créer un voirqui limite les paperwork d’une assortment accessibles through cette vue.

useful resource rockset_view english-movies {
  identify      = "english-movies"
  question     = file("knowledge/view.sql")
  workspace = rockset_workspace.weblog.identify
  depends_on = (rockset_alias.films)
}

La vue a besoin d’un explicite depends_on méta-argument automotive terraform n’interprète pas le SQL pour la vue qui réside dans un fichier séparé.

Alias

Un alias est un moyen de faire référence à une assortment existante par un nom différent. C’est un moyen pratique de pouvoir changer la assortment utilisée par un ensemble de requêtes, sans avoir à mettre à jour le SQL pour chacune d’entre elles.

useful resource rockset_alias films {
  collections = ("${rockset_workspace.weblog.identify}.${rockset_s3_collection.films.identify}")
  identify        = "films"
  workspace   = rockset_workspace.weblog.identify
}

Par exemple, si nous avons commencé à ingérer des movies à partir d’un flux Kafka, nous pouvons mettre à jour l’alias pour référencer la nouvelle assortment et toutes les requêtes commencent à l’utiliser immédiatement.

Rôle

Nous créons un rôle limité à l’exécution des lambdas de requête uniquement dans l’espace de travail du weblog, puis enregistrons la clé API dans le magasin de paramètres AWS Methods Supervisor pour une récupération ultérieure par le code qui exécutera le lambda. De cette façon, les informations d’identification n’auront jamais à être exposées à un humain.

useful resource rockset_role read-only {
  identify = "blog-read-only"
  privilege {
    motion = "EXECUTE_QUERY_LAMBDA_WS"
    cluster = "*ALL*"
    resource_name = rockset_workspace.weblog.identify
  }
}

useful resource "rockset_api_key" "ql-only" {
  identify = "blog-ql-only"
  function = rockset_role.read-only.identify
}

useful resource "aws_ssm_parameter" "api-key" {
  identify  = "/rockset/weblog/apikey"
  sort  = "SecureString"
  worth = rockset_api_key.ql-only.key
}

Requête Lambda

La requête lambda stocke le SQL dans un fichier séparé et possède une balise qui utilise la variable terraform stable_version qui, lorsqu’il est défini, est utilisé pour épingler le steady balise à cette model de la requête lambda, et si elle n’est pas définie, elle pointera vers la dernière model.

Placer le SQL dans un fichier séparé n’est pas obligatoire, mais cela facilite la lecture et vous pouvez copier/coller le SQL dans la console Rockset pour essayer manuellement les modifications. Un autre avantage est que l’examen des modifications apportées au SQL est plus facile lorsqu’il n’est pas mélangé à d’autres modifications, comme ce serait le cas s’il était placé en ligne avec la configuration de terraform.

SELECT
    title,
    TIME_BUCKET(
            YEARS(1),
            PARSE_TIMESTAMP('%Y-%m-%d', release_date)
        ) as yr,
  recognition
FROM
    weblog.films AS m
the place
    release_date != ''
  AND recognition > 10
GROUP BY
    yr,
    title,
    recognition
order by
    recognition desc

useful resource "rockset_query_lambda" "top-rated" {
  identify      = "top-rated-movies"
  workspace = rockset_workspace.weblog.identify
  sql {
    question = file("knowledge/top-rated.sql")
  }
}

useful resource "rockset_query_lambda_tag" "steady" {
  identify         = "steady"
  query_lambda = rockset_query_lambda.top-rated.identify
  model      = var.stable_version == "" ? rockset_query_lambda.top-rated.model : var.stable_version
  workspace    = rockset_workspace.weblog.identify
}

Software de la configuration

Avec tous les fichiers de configuration en place, il est temps « d’appliquer » les modifications, ce qui signifie que terraform lira les fichiers de configuration et interrogera Rockset et AWS pour la configuration actuelle, puis calculera les étapes à suivre pour accéder au état remaining.

La première étape consiste à courir terraform initqui téléchargera tous les fournisseurs de terraform requis et configurera le backend S3.

$ terraform init

Initializing the backend...

Efficiently configured the backend "s3"! Terraform will routinely
use this backend until the backend configuration adjustments.

Initializing supplier plugins...
- Discovering hashicorp/aws variations matching "~> 4.0"...
- Discovering rockset/rockset variations matching "~> 0.6.2"...
- Putting in hashicorp/aws v4.39.0...
- Put in hashicorp/aws v4.39.0 (signed by HashiCorp)
- Putting in hashicorp/time v0.9.1...
- Put in hashicorp/time v0.9.1 (signed by HashiCorp)
- Putting in rockset/rockset v0.6.2...
- Put in rockset/rockset v0.6.2 (signed by a HashiCorp accomplice, key ID DB47D0C3DF97C936)

Companion and group suppliers are signed by their builders.
If you would like to know extra about supplier signing, you possibly can examine it right here:
https://www.terraform.io/docs/cli/plugins/signing.html

Terraform has created a lock file .terraform.lock.hcl to report the supplier
alternatives it made above. Embody this file in your model management repository
in order that Terraform can assure to make the identical alternatives by default when
you run "terraform init" sooner or later.

Terraform has been efficiently initialized!

You could now start working with Terraform. Strive working "terraform plan" to see
any adjustments which can be required to your infrastructure. All Terraform instructions
ought to now work.

Should you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working listing. Should you overlook, different
instructions will detect it and remind you to take action if needed.

Ensuite, nous courons terraform plan pour obtenir une liste des ressources que terraform va créer et pour voir l’ordre dans lequel il les créera.

$ terraform plan
knowledge.rockset_account.present: Studying...
knowledge.rockset_account.present: Learn full after 0s (id=318212636800)
knowledge.aws_iam_policy_document.rockset-trust-policy: Studying...
knowledge.aws_iam_policy_document.rockset-trust-policy: Learn full after 0s (id=2982727827)

Terraform used the chosen suppliers to generate the next execution plan. Useful resource actions are indicated with the next symbols:
  + create

Terraform will carry out the next actions:

  # aws_iam_policy.rockset-s3-integration will probably be created
  + useful resource "aws_iam_policy" "rockset-s3-integration" {
      + arn       = (identified after apply)
      + id        = (identified after apply)
      + identify      = "rockset-s3-integration"
      + path      = "/"
      + coverage    = jsonencode(
            {
              + Id        = "RocksetS3IntegrationPolicy"
              + Assertion = (
                  + {
                      + Motion   = (
                          + "s3:ListBucket",
                        )
                      + Impact   = "Enable"
                      + Useful resource = (
                          + "arn:aws:s3:::rockset-community-datasets",
                        )
                      + Sid      = "BucketActions"
                    },
                  + {
                      + Motion   = (
                          + "s3:GetObject",
                        )
                      + Impact   = "Enable"
                      + Useful resource = (
                          + "arn:aws:s3:::rockset-community-datasets/*",
                        )
                      + Sid      = "ObjectActions"
                    },
                )
              + Model   = "2012-10-17"
            }
        )
      + policy_id = (identified after apply)
      + tags_all  = (identified after apply)
    }

...

# rockset_workspace.weblog will probably be created
  + useful resource "rockset_workspace" "weblog" {
      + created_by  = (identified after apply)
      + description = "created by Rockset terraform supplier"
      + id          = (identified after apply)
      + identify        = "weblog"
    }

Plan: 15 so as to add, 0 to alter, 0 to destroy.

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Word: You did not use the -out possibility to save lots of this plan, so Terraform cannot assure to take precisely these actions in the event you run "terraform apply" now.                                                                                         7s 665ms  13:53:32

Passez en revue la sortie et vérifiez qu’elle fait ce que vous attendez, puis vous êtes prêt à appliquer les modifications à l’aide de terraform apply. Cela répète la sortie du plan et vous demande de vérifier que vous êtes prêt à appliquer les modifications

$ terraform apply
knowledge.rockset_account.present: Studying...
knowledge.rockset_account.present: Learn full after 0s (id=318212636800)
knowledge.aws_iam_policy_document.rockset-trust-policy: Studying...
knowledge.aws_iam_policy_document.rockset-trust-policy: Learn full after 0s (id=2982727827)

Terraform used the chosen suppliers to generate the next execution plan. Useful resource actions are indicated with the next symbols:
  + create

Terraform will carry out the next actions:

...

# time_sleep.wait_30s will probably be created
  + useful resource "time_sleep" "wait_30s" {
      + create_duration = "15s"
      + id              = (identified after apply)
    }

Plan: 16 so as to add, 0 to alter, 0 to destroy.

Do you need to carry out these actions?
  Terraform will carry out the actions described above.
  Solely 'sure' will probably be accepted to approve.

  Enter a worth: sure

rockset_workspace.weblog: Creating...
rockset_kafka_integration.confluent: Creating...
rockset_workspace.weblog: Creation full after 0s (id=weblog)
rockset_role.read-only: Creating...
rockset_query_lambda.top-rated: Creating...
rockset_role.read-only: Creation full after 1s (id=blog-read-only)
rockset_api_key.ql-only: Creating...
rockset_api_key.ql-only: Creation full after 0s (id=blog-ql-only)
rockset_query_lambda.top-rated: Creation full after 1s (id=weblog.top-rated-movies)
rockset_query_lambda_tag.steady: Creating...
rockset_query_lambda_tag.steady: Creation full after 0s (id=weblog.top-rated-movies.steady)
rockset_kafka_integration.confluent: Creation full after 1s (id=confluent-cloud-blog)
rockset_kafka_collection.orders: Creating...
aws_ssm_parameter.api-key: Creating...
aws_iam_role.rockset: Creating...
aws_iam_policy.rockset-s3-integration: Creating...
aws_ssm_parameter.api-key: Creation full after 1s (id=/rockset/weblog/apikey)
aws_iam_policy.rockset-s3-integration: Creation full after 1s (id=arn:aws:iam::459021908517:coverage/rockset-s3-integration)
aws_iam_role.rockset: Creation full after 2s (id=rockset-s3-integration)
aws_iam_role_policy_attachment.rockset_s3_integration: Creating...
time_sleep.wait_30s: Creating...
aws_iam_role_policy_attachment.rockset_s3_integration: Creation full after 0s (id=rockset-s3-integration-20221114233744029000000001)
rockset_kafka_collection.orders: Nonetheless creating... (10s elapsed)
time_sleep.wait_30s: Nonetheless creating... (10s elapsed)
time_sleep.wait_30s: Creation full after 15s (id=2022-11-14T23:37:58Z)
rockset_s3_integration.integration: Creating...
rockset_s3_integration.integration: Creation full after 0s (id=rockset-community-datasets)
rockset_s3_collection.films: Creating...
rockset_kafka_collection.orders: Nonetheless creating... (20s elapsed)
rockset_s3_collection.films: Nonetheless creating... (10s elapsed)
rockset_kafka_collection.orders: Nonetheless creating... (30s elapsed)
rockset_kafka_collection.orders: Creation full after 34s (id=weblog.orders)
rockset_s3_collection.films: Nonetheless creating... (20s elapsed)
rockset_s3_collection.films: Nonetheless creating... (30s elapsed)
rockset_s3_collection.films: Nonetheless creating... (40s elapsed)
rockset_s3_collection.films: Creation full after 43s (id=weblog.movies-s3)
rockset_alias.films: Creating...
rockset_alias.films: Creation full after 1s (id=weblog.films)
rockset_view.english-movies: Creating...
rockset_view.english-movies: Creation full after 1s (id=weblog.english-movies)

Apply full! Assets: 16 added, 0 modified, 0 destroyed.

Outputs:

latest-version = "0eb04bfed335946d"

Ainsi, en environ 1 minute, il a créé toutes les ressources requises (et 30 secondes ont été passées à attendre que le rôle AWS IAM se propage).

Mise à jour des ressources

Une fois la configuration initiale appliquée, nous pouvons être amenés à apporter des modifications à une ou plusieurs ressources, par exemple mettre à jour le SQL pour une requête lambda. Terraform nous aidera à planifier ces changements et à n’appliquer que ce qui a changé.

SELECT
    title,
    TIME_BUCKET(
            YEARS(1),
            PARSE_TIMESTAMP('%Y-%m-%d', release_date)
        ) as yr,
  recognition
FROM
    weblog.films AS m
the place
    release_date != ''
  AND recognition > 11
GROUP BY
    yr,
    title,
    recognition
order by
    recognition desc

Nous mettrons également à jour le variables.tf fichier pour épingler le steady balise à la model actuelle, de sorte que le steady ne change pas tant que nous ne l’avons pas correctement testé.

variable "stable_version" {
  sort = string
  default = "0eb04bfed335946d"
  description = "Question Lambda model for the steady tag. If empty, the newest model is used."
}

Nous pouvons maintenant continuer et appliquer les modifications.

$ terraform apply
knowledge.rockset_account.present: Studying...
rockset_workspace.weblog: Refreshing state... (id=weblog)
rockset_kafka_integration.confluent: Refreshing state... (id=confluent-cloud-blog)
rockset_role.read-only: Refreshing state... (id=blog-read-only)
rockset_query_lambda.top-rated: Refreshing state... (id=weblog.top-rated-movies)
rockset_kafka_collection.orders: Refreshing state... (id=weblog.orders)
rockset_api_key.ql-only: Refreshing state... (id=blog-ql-only)
rockset_query_lambda_tag.steady: Refreshing state... (id=weblog.top-rated-movies.steady)
knowledge.rockset_account.present: Learn full after 1s (id=318212636800)
knowledge.aws_iam_policy_document.rockset-trust-policy: Studying...
aws_iam_policy.rockset-s3-integration: Refreshing state... (id=arn:aws:iam::459021908517:coverage/rockset-s3-integration)
aws_ssm_parameter.api-key: Refreshing state... (id=/rockset/weblog/apikey)
knowledge.aws_iam_policy_document.rockset-trust-policy: Learn full after 0s (id=2982727827)
aws_iam_role.rockset: Refreshing state... (id=rockset-s3-integration)
aws_iam_role_policy_attachment.rockset_s3_integration: Refreshing state... (id=rockset-s3-integration-20221114233744029000000001)
time_sleep.wait_30s: Refreshing state... (id=2022-11-14T23:37:58Z)
rockset_s3_integration.integration: Refreshing state... (id=rockset-community-datasets)
rockset_s3_collection.films: Refreshing state... (id=weblog.movies-s3)
rockset_alias.films: Refreshing state... (id=weblog.films)
rockset_view.english-movies: Refreshing state... (id=weblog.english-movies)

Terraform used the chosen suppliers to generate the next execution plan. Useful resource actions are indicated with the next symbols:
  ~ replace in-place

Terraform will carry out the next actions:

  # rockset_query_lambda.top-rated will probably be up to date in-place
  ~ useful resource "rockset_query_lambda" "top-rated" {
        id          = "weblog.top-rated-movies"
        identify        = "top-rated-movies"
      ~ model     = "0eb04bfed335946d" -> (identified after apply)
        # (3 unchanged attributes hidden)

      - sql {
          - question = <<-EOT
                SELECT
                    title,
                    TIME_BUCKET(
                            YEARS(1),
                            PARSE_TIMESTAMP('%Y-%m-%d', release_date)
                        ) as yr,
                  recognition
                FROM
                    weblog.films AS m
                the place
                    release_date != ''
                  AND recognition > 10
                GROUP BY
                    yr,
                    title,
                    recognition
                order by
                    recognition desc
            EOT -> null
        }
      + sql {
          + question = <<-EOT
                SELECT
                    title,
                    TIME_BUCKET(
                            YEARS(1),
                            PARSE_TIMESTAMP('%Y-%m-%d', release_date)
                        ) as yr,
                  recognition
                FROM
                    weblog.films AS m
                the place
                    release_date != ''
                  AND recognition > 11
                GROUP BY
                    yr,
                    title,
                    recognition
                ORDER BY
                    recognition desc
            EOT
        }
    }

Plan: 0 so as to add, 1 to alter, 0 to destroy.

Do you need to carry out these actions?
  Terraform will carry out the actions described above.
  Solely 'sure' will probably be accepted to approve.

  Enter a worth: sure

rockset_query_lambda.top-rated: Modifying... (id=weblog.top-rated-movies)
rockset_query_lambda.top-rated: Modifications full after 0s (id=weblog.top-rated-movies)

Apply full! Assets: 0 added, 1 modified, 0 destroyed.

Outputs:

latest-version = "2e268a64224ce9b2"

Comme vous pouvez le voir, il a mis à jour la model lambda de la requête au fur et à mesure que le SQL changeait.

Exécution de la requête Lambda

Tu peux exécuter la requête lambda depuis la ligne de commande en utilisant curl. Cela lit l’apikey à partir du magasin de paramètres AWS SSM, puis exécute le lambda à l’aide du newest étiqueter.

$ curl --request POST 
    --url https://api.usw2a1.rockset.com/v1/orgs/self/ws/weblog/lambdas/top-rated-movies/tags/newest 
  -H "Authorization: ApiKey $(aws ssm get-parameters --with-decryption --query 'Parameters(*).{Worth:Worth}'  --output=textual content --names /rockset/weblog/apikey)" 
  -H 'Content material-Sort: software/json'

Lorsque nous avons vérifié que la requête lambda renvoie les bons résultats, nous pouvons continuer et mettre à jour la balise steady à la sortie du dernier terraform apply commande.

variable "stable_version" {
  sort = string
  default = "2e268a64224ce9b2"
  description = "Question Lambda model for the steady tag. If empty, the newest model is used."
}

Enfin, appliquez à nouveau les modifications pour mettre à jour la balise.

$ terraform apply
rockset_workspace.weblog: Refreshing state... (id=weblog)
knowledge.rockset_account.present: Studying...
rockset_kafka_integration.confluent: Refreshing state... (id=confluent-cloud-blog)
rockset_query_lambda.top-rated: Refreshing state... (id=weblog.top-rated-movies)
rockset_role.read-only: Refreshing state... (id=blog-read-only)
rockset_kafka_collection.orders: Refreshing state... (id=weblog.orders)
rockset_api_key.ql-only: Refreshing state... (id=blog-ql-only)
rockset_query_lambda_tag.steady: Refreshing state... (id=weblog.top-rated-movies.steady)
knowledge.rockset_account.present: Learn full after 1s (id=318212636800)
aws_iam_policy.rockset-s3-integration: Refreshing state... (id=arn:aws:iam::459021908517:coverage/rockset-s3-integration)
knowledge.aws_iam_policy_document.rockset-trust-policy: Studying...
aws_ssm_parameter.api-key: Refreshing state... (id=/rockset/weblog/apikey)
knowledge.aws_iam_policy_document.rockset-trust-policy: Learn full after 0s (id=2982727827)
aws_iam_role.rockset: Refreshing state... (id=rockset-s3-integration)
aws_iam_role_policy_attachment.rockset_s3_integration: Refreshing state... (id=rockset-s3-integration-20221114233744029000000001)
time_sleep.wait_30s: Refreshing state... (id=2022-11-14T23:37:58Z)
rockset_s3_integration.integration: Refreshing state... (id=rockset-community-datasets)
rockset_s3_collection.films: Refreshing state... (id=weblog.movies-s3)
rockset_alias.films: Refreshing state... (id=weblog.films)
rockset_view.english-movies: Refreshing state... (id=weblog.english-movies)

Terraform used the chosen suppliers to generate the next execution plan. Useful resource actions are indicated with the next symbols:
  ~ replace in-place

Terraform will carry out the next actions:

  # rockset_query_lambda_tag.steady will probably be up to date in-place
  ~ useful resource "rockset_query_lambda_tag" "steady" {
        id           = "weblog.top-rated-movies.steady"
        identify         = "steady"
      ~ model      = "0eb04bfed335946d" -> "2af51ce4d09ec319"
        # (2 unchanged attributes hidden)
    }

Plan: 0 so as to add, 1 to alter, 0 to destroy.

Do you need to carry out these actions?
  Terraform will carry out the actions described above.
  Solely 'sure' will probably be accepted to approve.

  Enter a worth: sure

rockset_query_lambda_tag.steady: Modifying... (id=weblog.top-rated-movies.steady)
rockset_query_lambda_tag.steady: Modifications full after 1s (id=weblog.top-rated-movies.steady)

Apply full! Assets: 0 added, 1 modified, 0 destroyed.

Outputs:

latest-version = "2e268a64224ce9b2"

Maintenant le steady La balise fait référence à la dernière model de la requête lambda.

Motion GitHub

Pour utiliser Infrastructure as Code, nous allons placer toutes les configurations de terraform dans un référentiel git hébergé par GitHub et utiliser le demande d’extraction flux de travail pour les changements de terraform.

Nous allons configurer une motion GitHub pour qu’elle s’exécute automatiquement terraform plan pour chaque pull request, et poster un commentaire sur le PR indiquant les changements prévus.

Une fois la pull request approuvée et fusionnée, elle s’exécutera terraform apply pour apporter les modifications dans votre pull request à Rockset.

Set up

Cette part est une model abrégée de Automatisez Terraform avec les actions GitHubqui vous expliquera toutes les étapes de manière beaucoup plus détaillée.

Enregistrez le fichier ci-dessous sous .github/workflows/terraform.yml

identify: "Terraform"

on:
  push:
    branches:
      - grasp
  pull_request:

jobs:
  terraform:
    identify: "Terraform"
    runs-on: ubuntu-latest
    steps:
      - identify: Checkout
        makes use of: actions/checkout@v3

      - identify: Setup Terraform
        makes use of: hashicorp/setup-terraform@v1
        with:
          # terraform_version: 0.13.0:
          cli_config_credentials_token: ${{ secrets and techniques.TF_API_TOKEN }}

      - identify: Terraform Format
        id: fmt
        run: terraform fmt -check
        working-directory: terraform/weblog

      - identify: Terraform Init
        id: init
        run: terraform init
        working-directory: terraform/weblog

      - identify: Terraform Validate
        id: validate
        run: terraform validate -no-color
        working-directory: terraform/weblog

      - identify: Terraform Plan
        id: plan
        if: github.event_name == 'pull_request'
        run: terraform plan -no-color -input=false
        working-directory: terraform/weblog
        continue-on-error: true

      - makes use of: actions/github-script@v6
        if: github.event_name == 'pull_request'
        env:
          PLAN: "terraformn${{ steps.plan.outputs.stdout }}"
        with:
          github-token: ${{ secrets and techniques.GITHUB_TOKEN }}
          script: |
            const output = `#### Terraform Format and Fashion 🖌`${{ steps.fmt.final result }}`
            #### Terraform Initialization ⚙️`${{ steps.init.final result }}`
            #### Terraform Validation 🤖`${{ steps.validate.final result }}`
            #### Terraform Plan 📖`${{ steps.plan.final result }}`

            <particulars><abstract>Present Plan</abstract>

            ```n
            ${course of.env.PLAN}
            ```

            </particulars>

            *Pushed by: @${{ github.actor }}, Motion: `${{ github.event_name }}`*`;

            github.relaxation.points.createComment({
              issue_number: context.challenge.quantity,
              proprietor: context.repo.proprietor,
              repo: context.repo.repo,
              physique: output
            })
          working-directory: terraform/weblog

      - identify: Terraform Plan Standing
        if: steps.plan.final result == 'failure'
        run: exit 1

      - identify: Terraform Apply
        if: github.ref == 'refs/heads/grasp' && github.event_name == 'push'
        run: terraform apply -auto-approve -input=false
        working-directory: terraform/weblog

⚠️ Notez qu’il s’agit d’une configuration simplifiée, pour une configuration de niveau de manufacturing, vous devez exécuter terraform plan -out FILE et enregistrez le fichier, afin qu’il puisse être utilisé comme entrée pour terraform apply FILE, de sorte que seules les modifications exactes approuvées dans la demande d’extraction sont appliquées. Plus d’informations peuvent être trouvées ici.

Demande d’extraction

Lorsque vous créez un demande d’extraction qui modifie la configuration de terraform, le flux de travail s’exécutera terraform plan et commentaire sur le PR, qui contient la sortie du plan.

Cela permet à l’examinateur de voir que la modification peut être appliquée, et en cliquant sur « Afficher le plan », il peut voir exactement quelles modifications vont être apportées.

Lorsque le PR est approuvé et fusionné dans la branche principale, il déclenchera un autre Workflow d’motion GitHub run qui applique la modification.

Derniers mots

Nous avons maintenant une configuration d’infrastructure en tant que code entièrement fonctionnelle qui déploiera automatiquement les modifications apportées à votre configuration Rockset après examen par les pairs.