Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
Atlaschevron-right

MongoDB Atlas com Terraform

SM
Samuel Molling9 min read • Published Jan 23, 2024 • Updated Jan 23, 2024
TerraformAtlas
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Neste tutorial, mostrarei como começar a usar o MongoDB Atlas com Terraform e criar alguns recursos simples. Essa primeira parte é mais simples e introdutória, mas no próximo artigo, explorarei itens mais complexos e como conectar a criação de vários recursos em um único módulo. O tutorial é destinado a pessoas que desejam manter sua infraestrutura como código (IaC) de forma padronizada e simples. Se você já utiliza ou deseja utilizar o IaC na plataforma MongoDB Atlas, este artigo é para você.
O que são módulos?
Eles são containers de código para vários recursos usados juntos. Eles servem a vários propósitos importantes na criação e gerenciamento de infraestrutura como código, como:
  1. Code reuse.
  2. Organização.
  3. Encapsulação.
  4. Gerenciamento de versões.
  5. facilidade de manutenção e escalabilidade.
  6. Compartilhamento na comunidade.
Tudo o que fazemos aqui está contido na documentaçãodoprovider/resource.
Observação: não usaremos um arquivo de backend. No entanto, para implementações produtivos, é extremamente importante e seguro armazenar o arquivo de estado em um local remoto, como um S3, GCS, Azurerm, etc.

Criar um projeto

Nesta primeira etapa, mergulharemos no processo de criação de um projeto usando Terraform. O Terraform é uma poderosa ferramenta de infraestrutura como código que permite gerenciar e provisionar recursos de TI de maneira eficiente e previsível. Ao usá-lo em conjunto com o MongoDB Atlas, você pode automatizar a criação e o gerenciamento de recursos de banco de dados na nuvem, garantindo uma infraestrutura consistente e confiável.
Para começar, você precisará instalar oTerraform em seu ambiente de desenvolvimento. Esta etapa é crucial, pois é a base para executar todos os scripts e definições de infraestrutura que criaremos. Após a instalação, a próxima etapa é configurar o Terraform para funcionar com o MongoDB Atlas. Você precisará de uma chave de API que tenha permissão para criar um projeto no momento.
Para criar uma chave de API, você deve:
  1. Selecione Access Manager na parte superior da página e clique em Acesso à organização.
  2. Clique em Criar chave de API . Organization Access Manager para a sua organização
  3. Insira uma breve descrição da chave API e a permissão necessária. Nesse caso, coloque-o como Proprietário da organização. Depois disso, clique em Avançar. Tela para criar sua chave de API
  4. Sua chave API será exibida na tela. Tela com informações sobre sua chave de API
  5. Liberar IP na lista de acesso (opcional): se você habilitou sua organização para usar chaves de API, o IP do solicitante deve ser lançado na lista de acesso; você deve incluir seu IP nesta lista. Para validar se ela está ativada ou não, Go Configurações da organização -> Exigir lista de acesso IP para a API de administração do Atlas. No meu caso, ele está desativado, pois é apenas uma demonstração, mas caso você esteja usando isso em uma organização, recomendamos fortemente que o habilite. Valide se a lista de acesso de solicitação de IP para APIs está ativada nas Configurações da organização
Depois de criar uma chave de API, vamos começar a trabalhar com o Terraform. Você pode usar o IDE de sua escolha; Estarei usando o VS Code. Crie os arquivos dentro de uma pasta. Os arquivos de que precisaremos neste ponto são:
  • principal.tf: Neste arquivo, definiremos o recurso principal, mongodbatlas_project. Aqui, você configurará o nome do projeto e o ID da organização, bem como outras configurações específicas, como equipes, limites e configurações de alerta.
  • provider.tf: Esse arquivo é onde definimos o provedor que estamos usando - no nosso caso, mongodbatlas. Aqui, você também incluirá as credenciais de acesso, como a chave da API.
  • terraform.tfvars: Esse arquivo contém as variáveis que serão usadas em nosso projeto — por exemplo, o nome do projeto, as informações da equipe e os limites, entre outras.
  • variable.tf: Aqui, definimos as variáveis mencionadas no arquivo terraform.tfvars, especificando o tipo e, opcionalmente, um valor padrão.
  • version.tf: Este arquivo é usado para especificar a versão do Terraform e os fornecedores que estamos usando.
O arquivo principal.tf é o centro do nosso projeto Terraform. Nela, você começa com a declaração da fonte de dados mongodbatlas_roles_org_id para obter o org_id, que é essencial para a criação do projeto. Em seguida, você define o recursomongodbatlas_project com várias configurações. Aqui estão alguns exemplos:
  • name e org_id são configurações básicas para o nome do projeto e o ID da organização.
  • Os blocos dinâmicos são usados para configurar dinamicamente equipes e limites, permitindo flexibilidade e reutilização de código.
  • Outras configurações, como with_default_alerts_settings e is_data_explorer_enabled, são opções para personalizar o comportamento do seu projeto MongoDB Atlas.
No arquivo main.tf, adicionaremos nosso recurso de projeto, chamado mongodbatlas_project.
1data "mongodbatlas_roles_org_id" "org" {}
2
3resource "mongodbatlas_project" "default" {
4 name = var.name
5 org_id = data.mongodbatlas_roles_org_id.org.org_id
6
7 dynamic "teams" {
8 for_each = var.teams
9 content {
10 team_id = teams.value.team_id
11 role_names = teams.value.role_names
12 }
13 }
14
15 dynamic "limits" {
16 for_each = var.limits
17 content {
18 name = limits.value.name
19 value = limits.value.value
20 }
21 }
22
23 with_default_alerts_settings = var.with_default_alerts_settings
24 is_collect_database_specifics_statistics_enabled = var.is_collect_database_specifics_statistics_enabled
25 is_data_explorer_enabled = var.is_data_explorer_enabled
26 is_extended_storage_sizes_enabled = var.is_extended_storage_sizes_enabled
27 is_performance_advisor_enabled = var.is_performance_advisor_enabled
28 is_realtime_performance_panel_enabled = var.is_realtime_performance_panel_enabled
29 is_schema_advisor_enabled = var.is_schema_advisor_enabled
30}
No arquivo do provedor, definiremos o provedor que estamos usando e a chave de API que será usada. Como estamos apenas testando, especificarei a chave da API como uma variável que inseriremos em nosso código. No entanto, quando estiver usando-o na produção, você não desejará passar a chave da API no código em texto exposto, portanto, é possível passá-la por meio de variáveis de ambiente ou até mesmo pelo gerenciador de segredos da AWS.
1provider "mongodbatlas" {
2 public_key = var.atlas_public_key
3 private_key = var.atlas_private_key
4}
No arquivo variável.tf, especificaremos as variáveis que estamos aguardando a passagem de um usuário. Como mencionei anteriormente, a chave API é um exemplo.
1variable "name" {
2 description = <<HEREDOC
3 The name of the project you want to create.
4 HEREDOC
5 type = string
6}
7
8variable "teams" {
9 description = <<HEREDOC
10 The list of teams that belong to the project.
11 The roles can be:
12 Organization:
13 ORG_OWNER
14 ORG_MEMBER
15 ORG_GROUP_CREATOR
16 ORG_BILLING_ADMIN
17 ORG_READ_ONLY
18 Project:
19 GROUP_CLUSTER_MANAGER
20 GROUP_DATA_ACCESS_ADMIN
21 GROUP_DATA_ACCESS_READ_ONLY
22 GROUP_DATA_ACCESS_READ_WRITE
23 GROUP_OWNER
24 GROUP_READ_ONLY
25 HEREDOC
26 type = list(object({
27 team_id = string
28 role_names = list(string)
29 }))
30 default = []
31}
32
33variable "is_collect_database_specifics_statistics_enabled" {
34 description = <<HEREDOC
35 If true, Atlas collects and stores database-specific statistics for the specified project.
36 HEREDOC
37 type = bool
38 default = true
39}
40
41variable "is_data_explorer_enabled" {
42 description = <<HEREDOC
43 If true, Atlas enables Data Explorer for the specified project.
44 HEREDOC
45 type = bool
46 default = false
47}
48
49variable "is_extended_storage_sizes_enabled" {
50 description = <<HEREDOC
51 If true, Atlas enables extended storage sizes for the specified project.
52 HEREDOC
53 type = bool
54 default = true
55}
56
57variable "is_performance_advisor_enabled" {
58 description = <<HEREDOC
59 If true, Atlas enables Performance Advisor for the specified project.
60 HEREDOC
61 type = bool
62 default = true
63}
64
65
66variable "is_realtime_performance_panel_enabled" {
67 description = <<HEREDOC
68 If true, Atlas enables the Real Time Performance Panel for the specified project.
69 HEREDOC
70 type = bool
71 default = true
72}
73
74
75variable "is_schema_advisor_enabled" {
76 description = <<HEREDOC
77 If true, Atlas enables Schema Advisor for the specified project.
78 HEREDOC
79 type = bool
80 default = true
81}
82
83
84variable "with_default_alerts_settings" {
85 description = <<HEREDOC
86 If true, Atlas enables default alerts settings for the specified project.
87 HEREDOC
88 type = bool
89 default = true
90}
91
92
93variable "limits" {
94 description = <<HEREDOC
95 Allows one to configure a variety of limits to a Project. The limits attribute is optional.
96 https://www.mongodb.com/pt-br/docs/atlas/reference/api-resources-spec/v2/#tag/Projects/operation/setProjectLimit
97 HEREDOC
98 type = list(object({
99 name = string
100 value = string
101 }))
102
103
104 default = []
105}
106
107
108variable "atlas_public_key" {
109 description = <<HEREDOC
110 The public key of the Atlas user you want to use to create the project.
111 HEREDOC
112 type = string
113}
114
115
116variable "atlas_private_key" {
117 description = <<HEREDOC
118 The private key of the Atlas user you want to use to create the project.
119 HEREDOC
120 type = string
121}
Como você pode ver, estamos colocando várias variáveis. A ideia é que possamos reutilizar o módulo para criar diferentes projetos com especificações diferentes. Por exemplo, é necessário que os dados dos bancos de dados estejam visíveis na Atlas Platform, então colocamos a variável is_data_explorer_enabledcomoTrue. Por outro lado, se, por algum motivo de segurança, a empresa não quiser que os usuários usem a plataforma para visualização de dados, é possível especificá-la como False, e o botão Collections que temos quando entramos no cluster dentro Atlas desaparecerá.
No arquivo version.tf, especificamos a versão do Terraform que usamos e os fornecedores necessários com suas respectivas versões. Essa configuração é crucial para que o código sempre seja executado na mesma versão, evitando inconsistências e incompatibilidades que possam surgir com as atualizações.
Veja como será nosso arquivo de provedores:
1terraform {
2 required_version = ">= 0.12"
3 required_providers {
4 mongodbatlas = {
5 source = "mongodb/mongodbatlas"
6 version = "1.14.0"
7 }
8 }
9}
  • required_version = ">= 0.12": esta linha especifica que seu projeto Terraform exige, no mínimo, a versão 0 do Terraform.12. Ao usar >=, você indica qualquer versão do Terraform a partir do 0.12 em diante é compatível com seu projeto. Isso oferece alguma flexibilidade ao permitir que os membros da equipe e os sistemas de automação usem versões mais recentes do Terraform, desde que não tenham mais de 0.12.
  • required_providers: Esta seção lista os fornecedores necessários para seu projeto Terraform. No seu caso, você está especificando o fornecedor mongodbotlas.
  • source = "mongodb/mongodbatlas": isso define a origem do provedor mongodbotlas. Aqui, mongodb/mongodbotlas é o identificador oficial do provedor MongoDB Atlas no Registro Terraform.
  • version = "1.14.0": Esta linha especifica a versão exata do provedor mongodbotlas que seu projeto utilizará, que é a versão 1.14.0. Ao contrário da configuração do Terraform, onde especificamos uma versão mínima, aqui você está definindo uma versão específica do fornecedor. Isso garante que todos que usarem seu código funcionem com a mesma versão do provedor, evitando discrepâncias e problemas relacionados a diferenças de versão.
Por fim, temos o arquivo de variável que será incluído em nosso código, .tfvars.
1name = "project-test"
2atlas_public_key = "YOUR PUBLIC KEY"
3atlas_private_key = "YOUR PRIVATE KEY"
Estamos especificando o valor da variável name, que é o nome do projeto e a chave pública/privada do nosso provedor. Você pode se perguntar: "Onde estão as outras variáveis que especificamos nos arquivos principal.tf e variável.tf?" A resposta é: Essas variáveis foram especificadas com um valor padrão no arquivo variable.tf - por exemplo, o valor de limites:
1variable "limits" {
2 description = <<HEREDOC
3 Allows one to configure a variety of limits to a Project. The limits attribute is optional.
4 https://www.mongodb.com/pt-br/docs/atlas/reference/api-resources-spec/v2/#tag/Projects/operation/setProjectLimit
5 HEREDOC
6 type = list(object({
7 name = string
8 value = string
9 }))
10 default = []
11}
Estamos dizendo que, se nenhuma informação for passada em .tfvars, o valor padrão estará vazio. Isso significa que não criará nenhuma regra de limite para o nosso projeto. Se quisermos especificar um limite, apenas colocamos a seguinte variável em .tfvars:
1name = "project-test"
2atlas_public_key = "YOUR PUBLIC KEY"
3atlas_private_key = "YOUR PRIVATE KEY"
4limits = [{
5 "name" : "atlas.project.deployment.clusters",
6 "value" : 26
7 }, {
8 "name" : "atlas.project.deployment.nodesPerPrivateLinkRegion",
9 "value" : 51
10}]
Agora é a hora de se inscrever. =D
Executamos um terraform init no terminal na pasta onde os arquivos estão localizados para que ele baixe os provedores, módulos, etc.
Agora que o init funcionou, vamos executar o plano e avaliar o que vai acontecer. Você pode executar o plano, como este terraform plan:
1samuelmolling@Samuels-MacBook-Pro project % terraform plan
2data.mongodbatlas_roles_org_id.org: Reading...
3data.mongodbatlas_roles_org_id.org: Read complete after 0s [id=5d7072c9014b769c4bd89f60]
4
5Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
6 + create
7
8Terraform will perform the following actions:
9
10 # mongodbatlas_project.default will be created
11 + resource "mongodbatlas_project" "default" {
12 + cluster_count = (known after apply)
13 + created = (known after apply)
14 + id = (known after apply)
15 + is_collect_database_specifics_statistics_enabled = true
16 + is_data_explorer_enabled = false
17 + is_extended_storage_sizes_enabled = true
18 + is_performance_advisor_enabled = true
19 + is_realtime_performance_panel_enabled = true
20 + is_schema_advisor_enabled = true
21 + name = "project-test"
22 + org_id = "5d7072c9014b769c4bd89f60"
23 + with_default_alerts_settings = true
24
25 + limits {
26 + current_usage = (known after apply)
27 + default_limit = (known after apply)
28 + maximum_limit = (known after apply)
29 + name = "atlas.project.deployment.clusters"
30 + value = 26
31 }
32 + limits {
33 + current_usage = (known after apply)
34 + default_limit = (known after apply)
35 + maximum_limit = (known after apply)
36 + name = "atlas.project.deployment.nodesPerPrivateLinkRegion"
37 + value = 51
38 }
39 }
40
41Plan: 1 to add, 0 to change, 0 to destroy.
42
43───────────────────────────────────────── ───────── ───────────────────────────────────────── ───────── ───────────────────────────────────────── ───────── ───────────────────────────────────────── ────
44
45Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run `terraform apply` now.
Mostrar! Foi exatamente o resultado que esperávamos ver: a criação de um recurso de projeto, com alguns limites e is_data_explorer_enabled definido como False. Vamos aplicar isso!
Ao executar o comando terraform apply, será solicitada a aprovação com yes ou no. Digite yes.
1samuelmolling@Samuels-MacBook-Pro project % terraform apply
2data.mongodbatlas_roles_org_id.org: Reading...
3data.mongodbatlas_roles_org_id.org: Read complete after 0s [id=5d7072c9014b769c4bd89f60]
4
5Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
6 + create
7
8Terraform will perform the following actions:
9
10 # mongodbatlas_project.default will be created
11 + resource "mongodbatlas_project" "default" {
12 + cluster_count = (known after apply)
13 + created = (known after apply)
14 + id = (known after apply)
15 + is_collect_database_specifics_statistics_enabled = true
16 + is_data_explorer_enabled = false
17 + is_extended_storage_sizes_enabled = true
18 + is_performance_advisor_enabled = true
19 + is_realtime_performance_panel_enabled = true
20 + is_schema_advisor_enabled = true
21 + name = "project-test"
22 + org_id = "5d7072c9014b769c4bd89f60"
23 + with_default_alerts_settings = true
24
25 + limits {
26 + current_usage = (known after apply)
27 + default_limit = (known after apply)
28 + maximum_limit = (known after apply)
29 + name = "atlas.project.deployment.clusters"
30 + value = 26
31 }
32 + limits {
33 + current_usage = (known after apply)
34 + default_limit = (known after apply)
35 + maximum_limit = (known after apply)
36 + name = "atlas.project.deployment.nodesPerPrivateLinkRegion"
37 + value = 51
38 }
39 }
40
41Plan: 1 to add, 0 to change, 0 to destroy.
42
43Do you want to perform these actions?
44 Terraform will perform the actions described above.
45 Only 'yes' will be accepted to approve.
46
47 Enter a value: yes
48
49mongodbatlas_project.default: Creating...
50mongodbatlas_project.default: Creation complete after 9s [id=659ed54eb3343935e840ce1f]
51
52Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
Agora, vamos dar uma olhada no Atlas para ver se o projeto foi criado com sucesso...
Visualização do MongoDB Atlas do nosso projeto
Funcionou!
Neste tutorial, vimos como criar nossa primeira chave de API. Criamos um projeto usando o Terraform e nosso primeiro módulo. Em um próximo artigo, vamos ver como criar um cluster e um usuário usando o Terraform e o Atlas.
Para saber mais sobre o MongoDB e várias ferramentas, Convido você a entrar no Centro do Desenvolvedor para ler os outros artigos.

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Tutorial

Como escolher a estratégia de chunking certa para seu aplicativo LLM


Jun 17, 2024 | 16 min read
Artigo

Pausar automaticamente clusters inativos


Sep 09, 2024 | 10 min read
Tutorial

Simplifique a pesquisa semântica do Atlas com LangChain e MongoDB


Oct 28, 2024 | 4 min read
Tutorial

Como usar os módulos de incorporações e reclassificação do Cohere com o MongoDB Atlas


Aug 14, 2024 | 10 min read
Sumário
  • Criar um projeto