> ## Content Index
> Fetch the complete content index at: https://www.azurebrasil.cloud/llms.txt
> Use this file to discover other available public pages before exploring further.

# Utilizando o Azure Key Vault para guardar informações sensíveis no Terraform
- URL: https://www.azurebrasil.cloud/blog/utilizando-o-azure-key-vault-para-guardar-segredos-do-terraform/
- Published: 2024-01-11T14:48:39.000Z
- Updated: 2024-01-11T14:48:39.000Z
- Author: Talles Valiatti

Sempre que vamos criar alguma infraestrutura por meio de IaC ([Terraform](https://www.terraform.io/?ref=azurebrasil.cloud), [Bicep](https://learn.microsoft.com/pt-br/azure/azure-resource-manager/bicep/?ref=azurebrasil.cloud), [Pulumi](https://www.pulumi.com/?ref=azurebrasil.cloud), etc ...) é de extrema importância mantermos os segredos (ex: *strings* de conexões) seguras. Inspirado nisso, resolvi escrever esse post com a intenção de mostrar como podemos guardar os segredos das nossas soluções no [Azure Key Vault ](https://learn.microsoft.com/pt-br/azure/key-vault/general/basic-concepts?ref=azurebrasil.cloud)e utilizá-los dentro do nosso código do Terraform.

Vamos precisar que você tenha o [Terraform instalado na sua máquina local](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli?ref=azurebrasil.cloud)!

Para iniciar o nosso código, devemos criar definir o [*provider*](https://developer.hashicorp.com/terraform/language/providers?ref=azurebrasil.cloud) que será utilizado. ([Azure](https://learn.microsoft.com/en-us/azure/developer/terraform/overview?ref=azurebrasil.cloud)!)

```providers.tf
terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
  }
}

provider "azurerm" {
  features {}
}
```

Após isso, já podermos criar o arquivo *variables.tf* que contém as [variáveis](https://developer.hashicorp.com/terraform/language/values/variables?ref=azurebrasil.cloud) que serão utilizadas ao longo do nosso código Terraform.

Observe que a variável "*my-secret*" está sendo definida de uma forma bem simples. Em casos reais de produção, esse segredo deve ser inserido no código de [forma segura](https://developer.hashicorp.com/terraform/tutorials/configuration-language/sensitive-variables?ref=azurebrasil.cloud)!

```
variable "default_location" {
  type        = string
  default     = "eastus"
  description = "Default location"
}

variable "resource_group_name_prefix" {
  type        = string
  default     = "rg"
  description = "Prefix of the resource groups"
}

variable "key_vault_name_prefix" {
  type        = string
  default     = "kv"
  description = "Prefix of the azure key vault"
}

variable "web_app_name_prefix" {
  type        = string
  default     = "app"
  description = "Prefix of azure web app"
}

variable "app_service_plan_name_prefix" {
  type        = string
  default     = "apps"
  description = "Prefix of azure app service plan"
}

variable "default_environment" {
  type        = string
  default     = "prod"
  description = "Default environment"
}

variable "my-secret" {
  type        = string
  default     = "my-secret-value"
  description = "Default environment"
}
```

Já podemos criar os arquivo *main.tf.* Vamos por partes!

Inicialmente vamos definir os seguintes itens:

- [*azurerm\_client\_config*](https://registry.terraform.io/providers/hashicorp/Azurerm/latest/docs/data-sources/client%5Fconfig?ref=azurebrasil.cloud)*;*
- *current\_user\_id.*

```
data "azurerm_client_config" "current" {}

locals {
  current_user_id = data.azurerm_client_config.current.object_id
}
```

Para delimitar logicamente os recursos de nuvem, devemos criar um [*resource group.* ](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-portal?ref=azurebrasil.cloud)

```

resource "azurerm_resource_group" "rg" {
  location = var.default_location
  name     = "${var.resource_group_name_prefix}-app-${var.default_environment}-${var.default_location}"
}
```

O padrão de nomenclatura utilizado nesse post será o seguinte:

```
<prefix>-<feature>-<envrironment>-<location>
```

Por exemplo, para o grupo de recursos:

```
rg-app-prod-eastus
```

Com o *resource group* criado, podemos criar o [Azure Key Vault.](https://learn.microsoft.com/en-us/azure/key-vault/general/basic-concepts?ref=azurebrasil.cloud)

```

resource "azurerm_key_vault" "vault" {
  name                       = "${var.key_vault_name_prefix}-app-${var.default_environment}-${var.default_location}"
  location                   = azurerm_resource_group.rg.location
  resource_group_name        = azurerm_resource_group.rg.name
  tenant_id                  = data.azurerm_client_config.current.tenant_id
  sku_name                   = "standard"
  soft_delete_retention_days = 7

  access_policy {
    tenant_id = data.azurerm_client_config.current.tenant_id
    object_id = local.current_user_id
    secret_permissions =  ["Get", "List", "Set", "Delete"]
  }
}
```

Observe que adicionamos [*access policies*](https://learn.microsoft.com/en-us/azure/key-vault/general/assign-access-policy?tabs=azure-portal&ref=azurebrasil.cloud) para o *local.current\_user\_id (usuário logado no terminal. Ex: az login).* Desse forma, quando as chaves forem criadas, teremos a permissões necessárias para acessá-las.

Vamos criar um [*secre*](https://learn.microsoft.com/en-us/azure/key-vault/secrets/quick-create-portal?ref=azurebrasil.cloud)[*t*](https://learn.microsoft.com/en-us/azure/key-vault/secrets/quick-create-portal?ref=azurebrasil.cloud) dentro do Azure Key Vault definido anteriormente.

```

resource "azurerm_key_vault_secret" "secret" {
name         = "my-secret"
value        = var.my-secret
key_vault_id = azurerm_key_vault.vault.id
}

```

Nesse ponto, nossa infraestrutura como código já possui um segredo definido dentro do Azure Key Vault. Podemos criar outro recurso de nuvem que utilizará esse segredo, sem nunca expor seu valor!

Nesse caso, vamos criar um [](https://learn.microsoft.com/en-us/azure/app-service/overview?ref=azurebrasil.cloud)[Azure App Service Plan](https://learn.microsoft.com/en-us/azure/app-service/overview-hosting-plans?ref=azurebrasil.cloud) e um [App Service](https://learn.microsoft.com/en-us/azure/app-service/overview?ref=azurebrasil.cloud), colocando o segredo como uma [configuração](https://learn.microsoft.com/en-us/azure/app-service/configure-common?tabs=portal&ref=azurebrasil.cloud) no aplicativo web, chamado "*MY\_SECRET*"

```

resource "azurerm_service_plan" "appserviceplan" {
  name                = "${var.app_service_plan_name_prefix}-app-${var.default_environment}-${var.default_location}"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  os_type             = "Linux"
  sku_name            = "B1"
}

```

```

resource "azurerm_linux_web_app" "webapp" {
  name                  = "${var.web_app_name_prefix}-app-${var.default_environment}-${var.default_location}"
  location              = azurerm_resource_group.rg.location
  resource_group_name   = azurerm_resource_group.rg.name
  service_plan_id       = azurerm_service_plan.appserviceplan.id
  https_only            = true
  site_config {
    minimum_tls_version = "1.2"
  }
  app_settings = {
    "MY_SECRET" = azurerm_key_vault_secret.secret.value
  }
}
```

Com os arquivos prontos, podemos inicializar o projeto Terraform por meio do comando [*init*](https://developer.hashicorp.com/terraform/cli/commands/init?ref=azurebrasil.cloud)*.* 

```
terraform init
```

Vamos executar o comando [*plan*](https://developer.hashicorp.com/terraform/cli/commands/plan?ref=azurebrasil.cloud)*,* com a intençãode mapear todas as modificações que serão feitas no Azure. No nosso caso, como não temos nada previamente criado, serão provisionados os 5 recursos definidos anteriormente.

```
terraform plan -out main.tfplan

```

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2024/01/Screen-Shot-2024-01-03-at-14.51.45.png)

Vamos criar nossa infraestrutura por meio do comando [*apply*](https://developer.hashicorp.com/terraform/cli/commands/apply?ref=azurebrasil.cloud)*.*

````
 terraform apply "main.tfplan"

```

Após a execução, podemos ver que tudo foi criado de forma correta!

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2024/01/Screen-Shot-2024-01-03-at-15.09.39.png)

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2024/01/Screen-Shot-2024-01-03-at-15.09.45.png)

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2024/01/Screen-Shot-2024-01-03-at-15.10.04.png)

É fechamos aqui o post! Só não vamos esquecer de deletar tudo o que foi criado.

```
 terraform apply -destroy

```

Você já pode baixar o projeto por esse [link](https://github.com/TallesValiatti/MediatRValidationPipeline?ref=azurebrasil.cloud), e não esquece de me seguir no [LinkedIn](https://www.linkedin.com/in/tallesvaliatti/?ref=azurebrasil.cloud)!

[GitHub - TallesValiatti/TerraformAzureKeyVaultContribute to TallesValiatti/TerraformAzureKeyVault development by creating an account on GitHub.![](https://github.githubassets.com/assets/pinned-octocat-093da3e6fa40.svg)GitHubTallesValiatti![](https://opengraph.githubassets.com/e9b7df23971e0da1e2175892ad92eab0bef1da09497bab70146d67ac48597eb3/TallesValiatti/TerraformAzureKeyVault)](https://github.com/TallesValiatti/TerraformAzureKeyVault?ref=azurebrasil.cloud)

Até a próxima, abraços!