O objetivo desta postagem do weblog é fornecer práticas recomendadas sobre como usar terraform para configurar o Rockset para ingerir os dados em duas coleções e como configurar uma visualização e consulta lambdas que são usadas em um aplicativo, além de mostrar o fluxo de trabalho de atualização posterior dos lambdas de consulta. Isso imita como usamos o terraform no Rockset para gerenciar os recursos do Rockset.
Terraform é o mais common usado DevOps ferramenta para gerenciamento de infraestrutura, que permite definir seu infraestrutura como códigoe então a ferramenta fará a configuração e calculará as etapas necessárias para passar do estado atual para o estado desejado.
Por último, veremos como usar ações do GitHub para executar automaticamente terraform plan para solicitações pull e, assim que a solicitação pull for aprovada e mesclada, ela será executada terraform apply para fazer as alterações necessárias.
A configuração completa do terraform usada nesta postagem do weblog está disponível aqui.
Terraforma
Para acompanhar por conta própria, você precisará de:
e você também precisa instalar o terraform no seu computador, que é tão simples quanto no macOS.
$ brew faucet hashicorp/faucet
$ brew set up hashicorp/faucet/terraform
(instruções para outros sistemas operacionais estão disponíveis no hyperlink acima)
Configuração do provedor
O primeiro passo para usar terraform é configurar os provedores que usaremos, Rockset e AWS. Crie um arquivo chamado _provider.tf com o conteúdo.
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"
}
Ambos os provedores usam variáveis de ambiente para ler as credenciais necessárias para acessar os respectivos serviços.
- Conjunto de foguetes:
ROCKSET_APIKEYeROCKSET_APISERVER - AWS:
AWS_ACCESS_KEY_IDeAWS_SECRET_ACCESS_KEYouAWS_PROFILE
Configuração de back-end
O Terraform salva informações sobre a infraestrutura gerenciada e configuração em um arquivo de estado. Para compartilhar esse estado entre execuções locais em seu computador e execuções automatizadas de ações do GitHub, usamos o chamado configuração de back-endque armazena o estado em um bucket AWS S3, para que todas as invocações do terraform possam usá-lo.
backend "s3" {
bucket = "rockset-community-terraform"
key = "weblog/state"
area = "us-west-2"
}
⚠️ Para uma implantação de produção, certifique-se de configurar bloqueio de estado também.
Função IAM da AWS
Para permitir que o Rockset ingira o conteúdo de um bucket S3, primeiro precisamos criar uma função AWS IAM que o Rockset usará para acessar o conteúdo do bucket. Ele usa um fonte de dados para ler informações sobre sua organização Rockset, para que ela possa configurar a AWS corretamente.
information rockset_account present {}
useful resource "aws_iam_policy" "rockset-s3-integration" {
identify = var.rockset_role_name
coverage = templatefile("${path.module}/information/coverage.json", {
bucket = var.bucket
prefix = var.bucket_prefix
})
}
useful resource "aws_iam_role" "rockset" {
identify = var.rockset_role_name
assume_role_policy = information.aws_iam_policy_document.rockset-trust-policy.json
}
information "aws_iam_policy_document" "rockset-trust-policy" {
assertion {
sid = ""
impact = "Permit"
actions = (
"sts:AssumeRole"
)
principals {
identifiers = (
"arn:aws:iam::${information.rockset_account.present.account_id}:root"
)
kind = "AWS"
}
situation {
take a look at = "StringEquals"
values = (
information.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
}
Isso cria uma função entre contas do AWS IAM que o Rockset pode usar para ingerir dados.
Integração Rockset S3
Agora podemos criar a integração que permite ao Rockset ingerir dados do S3, usando a função IAM acima.
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)
}
⚠️ Você pode obter um AWS cross-account function erro se você pular o time_sleep recursoporque leva alguns segundos para que a função AWS recém-criada seja propagada, portanto, isso evita que você exact executar novamente terraform apply de novo.
Coleção Rockset
Com a integração agora podemos criar um espaço de trabalho para armazenar todos os recursos que iremos adicionar e, em seguida, configurar um coleção que ingerem dados usando a integração S3 acima.
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/motion pictures/*.json"
}
}
Coleção Kafka
A seguir, configuraremos uma coleção de uma fonte Confluent Cloud e adicionaremos um transformação de ingestão que resume os dados.
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("information/transformation.sql")
}
O SQL para a transformação de ingestão é armazenado em um arquivo separado, que o terraform injeta na configuração.
SELECT
COUNT(i.orderid) AS orders,
SUM(i.orderunits) AS models,
i.deal with.zipcode,
i.deal with.state,
-- bucket information 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.deal with.state != 'State_'
GROUP BY
_event_time,
i.deal with.zipcode,
i.deal with.state
Visualizar
Com os dados ingeridos em uma coleção, podemos criar um visualizarque limita quais documentos de uma coleção podem ser acessados por meio dessa visualização.
useful resource rockset_view english-movies {
identify = "english-movies"
question = file("information/view.sql")
workspace = rockset_workspace.weblog.identify
depends_on = (rockset_alias.motion pictures)
}
A visão precisa de uma explicação explícita depends_on meta-argumento já que o terraform não interpreta o SQL para a visualização que reside em um arquivo separado.
Alias
Um apelido é uma forma de se referir a uma coleção existente por um nome diferente. Esta é uma maneira conveniente de alterar a coleção que um conjunto de consultas usa, sem precisar atualizar o SQL de todas elas.
useful resource rockset_alias motion pictures {
collections = ("${rockset_workspace.weblog.identify}.${rockset_s3_collection.motion pictures.identify}")
identify = "motion pictures"
workspace = rockset_workspace.weblog.identify
}
Por exemplo, se começarmos a ingerir filmes de um fluxo Kafka, podemos atualizar o alias para fazer referência à nova coleção e todas as consultas começarão a usá-lo imediatamente.
Papel
Criamos uma função que se limita a executar lambdas de consulta apenas no espaço de trabalho do weblog e, em seguida, salvamos a chave de API no AWS Programs Supervisor Parameter Retailer para recuperação posterior pelo código que executará o lambda. Dessa forma, as credenciais nunca terão que ser expostas a um ser humano.
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"
kind = "SecureString"
worth = rockset_api_key.ql-only.key
}
Consultar Lambda
A consulta lambda armazena o SQL em um arquivo separado e possui uma tag que usa a variável terraform stable_version que quando definido, é usado para fixar o secure tag para essa versão da consulta lambda e, se não for definida, apontará para a versão mais recente.
Colocar o SQL em um arquivo separado não é um requisito, mas facilita a leitura e você pode copiar/colar o SQL no console do Rockset para tentar manualmente as alterações. Outro benefício é que a revisão das alterações no SQL é mais fácil quando ele não está misturado com outras alterações, como seria se fosse colocado alinhado com a configuração do terraform.
SELECT
title,
TIME_BUCKET(
YEARS(1),
PARSE_TIMESTAMP('%Y-%m-%d', release_date)
) as 12 months,
reputation
FROM
weblog.motion pictures AS m
the place
release_date != ''
AND reputation > 10
GROUP BY
12 months,
title,
reputation
order by
reputation desc
useful resource "rockset_query_lambda" "top-rated" {
identify = "top-rated-movies"
workspace = rockset_workspace.weblog.identify
sql {
question = file("information/top-rated.sql")
}
}
useful resource "rockset_query_lambda_tag" "secure" {
identify = "secure"
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
}
Aplicando a configuração
Com todos os arquivos de configuração no lugar, é hora de “aplicar” as alterações, o que significa que o terraform irá ler os arquivos de configuração e interrogar Rockset e AWS para a configuração atual e, em seguida, calcular quais etapas precisam ser executadas para chegar ao estado last.
O primeiro passo é executar terraform initque fará obtain de todos os provedores de terraform necessários e configurará o back-end do S3.
$ terraform init
Initializing the backend...
Efficiently configured the backend "s3"! Terraform will mechanically
use this backend until the backend configuration modifications.
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 companion, key ID DB47D0C3DF97C936)
Accomplice 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 document the supplier
picks it made above. Embrace this file in your model management repository
in order that Terraform can assure to make the identical picks by default when
you run "terraform init" sooner or later.
Terraform has been efficiently initialized!
You might now start working with Terraform. Attempt working "terraform plan" to see
any modifications which might be required to your infrastructure. All Terraform instructions
ought to now work.
In case you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working listing. In case you neglect, different
instructions will detect it and remind you to take action if obligatory.
Em seguida, corremos terraform plan para obter uma lista de quais recursos o terraform irá criar e ver a ordem em que ele os criará.
$ terraform plan
information.rockset_account.present: Studying...
information.rockset_account.present: Learn full after 0s (id=318212636800)
information.aws_iam_policy_document.rockset-trust-policy: Studying...
information.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 likely 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 = "Permit"
+ Useful resource = (
+ "arn:aws:s3:::rockset-community-datasets",
)
+ Sid = "BucketActions"
},
+ {
+ Motion = (
+ "s3:GetObject",
)
+ Impact = "Permit"
+ 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 likely 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 vary, 0 to destroy.
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Be aware: You did not use the -out possibility to avoid wasting this plan, so Terraform cannot assure to take precisely these actions in the event you run "terraform apply" now. 7s 665ms 13:53:32
Revise a saída e verifique se ela está fazendo o que você espera e então você estará pronto para aplicar as alterações usando terraform apply. Isso repete o resultado do plano e solicita que você verifique se está pronto para aplicar as alterações
$ terraform apply
information.rockset_account.present: Studying...
information.rockset_account.present: Learn full after 0s (id=318212636800)
information.aws_iam_policy_document.rockset-trust-policy: Studying...
information.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 likely be created
+ useful resource "time_sleep" "wait_30s" {
+ create_duration = "15s"
+ id = (identified after apply)
}
Plan: 16 so as to add, 0 to vary, 0 to destroy.
Do you need to carry out these actions?
Terraform will carry out the actions described above.
Solely 'sure' will likely be accepted to approve.
Enter a price: 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.secure: Creating...
rockset_query_lambda_tag.secure: Creation full after 0s (id=weblog.top-rated-movies.secure)
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.motion pictures: Creating...
rockset_kafka_collection.orders: Nonetheless creating... (20s elapsed)
rockset_s3_collection.motion pictures: 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.motion pictures: Nonetheless creating... (20s elapsed)
rockset_s3_collection.motion pictures: Nonetheless creating... (30s elapsed)
rockset_s3_collection.motion pictures: Nonetheless creating... (40s elapsed)
rockset_s3_collection.motion pictures: Creation full after 43s (id=weblog.movies-s3)
rockset_alias.motion pictures: Creating...
rockset_alias.motion pictures: Creation full after 1s (id=weblog.motion pictures)
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"
Portanto, em cerca de 1 minuto, ele criou todos os recursos necessários (e 30 segundos foram gastos aguardando a propagação da função AWS IAM).
Atualizando recursos
Uma vez aplicada a configuração inicial, talvez seja necessário fazer modificações em um ou mais recursos, por exemplo, atualizar o SQL para uma consulta lambda. O Terraform nos ajudará a planejar essas mudanças e aplicar apenas o que mudou.
SELECT
title,
TIME_BUCKET(
YEARS(1),
PARSE_TIMESTAMP('%Y-%m-%d', release_date)
) as 12 months,
reputation
FROM
weblog.motion pictures AS m
the place
release_date != ''
AND reputation > 11
GROUP BY
12 months,
title,
reputation
order by
reputation desc
Também atualizaremos o variables.tf arquivo para fixar o secure tag para a versão atual, para que o secure não muda até que o tenhamos testado adequadamente.
variable "stable_version" {
kind = string
default = "0eb04bfed335946d"
description = "Question Lambda model for the secure tag. If empty, the most recent model is used."
}
Agora podemos prosseguir e aplicar as alterações.
$ terraform apply
information.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.secure: Refreshing state... (id=weblog.top-rated-movies.secure)
information.rockset_account.present: Learn full after 1s (id=318212636800)
information.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)
information.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.motion pictures: Refreshing state... (id=weblog.movies-s3)
rockset_alias.motion pictures: Refreshing state... (id=weblog.motion pictures)
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 likely 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 12 months,
reputation
FROM
weblog.motion pictures AS m
the place
release_date != ''
AND reputation > 10
GROUP BY
12 months,
title,
reputation
order by
reputation desc
EOT -> null
}
+ sql {
+ question = <<-EOT
SELECT
title,
TIME_BUCKET(
YEARS(1),
PARSE_TIMESTAMP('%Y-%m-%d', release_date)
) as 12 months,
reputation
FROM
weblog.motion pictures AS m
the place
release_date != ''
AND reputation > 11
GROUP BY
12 months,
title,
reputation
ORDER BY
reputation desc
EOT
}
}
Plan: 0 so as to add, 1 to vary, 0 to destroy.
Do you need to carry out these actions?
Terraform will carry out the actions described above.
Solely 'sure' will likely be accepted to approve.
Enter a price: 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"
Como você pode ver, ele atualizou a versão lambda da consulta conforme o SQL mudou.
Executando a consulta Lambda
Você pode execute a consulta lambda na linha de comando usando curl. Isso lê o apikey do AWS SSM Parameter Retailer e, em seguida, executa o lambda usando o newest marcação.
$ 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-Kind: software/json'
Quando verificarmos que a consulta lambda retorna os resultados corretos, podemos prosseguir e atualizar a tag estável para a saída do último terraform apply comando.
variable "stable_version" {
kind = string
default = "2e268a64224ce9b2"
description = "Question Lambda model for the secure tag. If empty, the most recent model is used."
}
Por fim, aplique as alterações novamente para atualizar a tag.
$ terraform apply
rockset_workspace.weblog: Refreshing state... (id=weblog)
information.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.secure: Refreshing state... (id=weblog.top-rated-movies.secure)
information.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)
information.aws_iam_policy_document.rockset-trust-policy: Studying...
aws_ssm_parameter.api-key: Refreshing state... (id=/rockset/weblog/apikey)
information.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.motion pictures: Refreshing state... (id=weblog.movies-s3)
rockset_alias.motion pictures: Refreshing state... (id=weblog.motion pictures)
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.secure will likely be up to date in-place
~ useful resource "rockset_query_lambda_tag" "secure" {
id = "weblog.top-rated-movies.secure"
identify = "secure"
~ model = "0eb04bfed335946d" -> "2af51ce4d09ec319"
# (2 unchanged attributes hidden)
}
Plan: 0 so as to add, 1 to vary, 0 to destroy.
Do you need to carry out these actions?
Terraform will carry out the actions described above.
Solely 'sure' will likely be accepted to approve.
Enter a price: sure
rockset_query_lambda_tag.secure: Modifying... (id=weblog.top-rated-movies.secure)
rockset_query_lambda_tag.secure: Modifications full after 1s (id=weblog.top-rated-movies.secure)
Apply full! Assets: 0 added, 1 modified, 0 destroyed.
Outputs:
latest-version = "2e268a64224ce9b2"
Agora o secure tag refere-se à versão mais recente da consulta lambda.
Ação GitHub
Para fazer uso da infraestrutura como código, colocaremos todas as configurações do terraform em um repositório git hospedado pelo GitHub e utilizaremos o solicitação pull fluxo de trabalho para alterações de terraform.
Configuraremos uma ação do GitHub para ser executada automaticamente terraform plan para cada pull request e poste um comentário no PR mostrando as mudanças planejadas.
Assim que a solicitação pull for aprovada e mesclada, ela será executada terraform apply para fazer as alterações em sua solicitação pull para Rockset.
Configurar
Esta seção é uma versão abreviada de Automatize o Terraform com ações do GitHubque explicará todas as etapas com muito mais detalhes.
Salve o arquivo abaixo como .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.consequence }}`
#### Terraform Initialization ⚙️`${{ steps.init.consequence }}`
#### Terraform Validation 🤖`${{ steps.validate.consequence }}`
#### Terraform Plan 📖`${{ steps.plan.consequence }}`
Present Plan
```n
${course of.env.PLAN}
```
*Pushed by: @${{ github.actor }}, Motion: `${{ github.event_name }}`*`;
github.relaxation.points.createComment({
issue_number: context.subject.quantity,
proprietor: context.repo.proprietor,
repo: context.repo.repo,
physique: output
})
working-directory: terraform/weblog
- identify: Terraform Plan Standing
if: steps.plan.consequence == '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
⚠️ Observe que esta é uma configuração simplificada, para uma configuração de nível de produção você deve executar terraform plan -out FILE e salve o arquivo, para que ele possa ser usado como entrada para terraform apply FILEportanto, apenas as alterações exatas aprovadas na solicitação pull serão aplicadas. Mais informações podem ser encontradas aqui.
Solicitação pull
Quando você cria um solicitação pull que altera a configuração do terraform, o fluxo de trabalho será executado terraform plan e comentário no PR, que contém o resultado do plano.
Isso permite que o revisor veja que a alteração pode ser aplicada e, clicando em “Mostrar Plano”, poderá ver exatamente quais alterações serão feitas.
Quando o PR for aprovado e incorporado ao ramo principal, irá acionar outro Fluxo de trabalho de ação do GitHub run que aplica a mudança.
Palavras finais
Agora temos uma configuração de infraestrutura como código totalmente funcional que implantará alterações na configuração do seu Rockset automaticamente após revisão por pares.