Infraestrutura como código

Gorjeta

Este conteúdo é um excerto do eBook, Architecting Cloud Native .NET Applications for Azure, disponível no .NET Docs ou como um PDF transferível gratuito que pode ser lido offline.

Descarregar PDF

Os sistemas nativos da nuvem adotam microsserviços, contêineres e design moderno de sistemas para alcançar velocidade e agilidade. Eles fornecem estágios automatizados de compilação e liberação para garantir um código consistente e de qualidade. Mas isso é apenas parte da história. Como você provisiona os ambientes de nuvem nos quais esses sistemas são executados?

Os aplicativos modernos nativos da nuvem adotam a prática amplamente aceita de infraestrutura como código, ou IaC. Com o IaC, você automatiza o provisionamento da plataforma. Você essencialmente aplica práticas de engenharia de software, como testes e controle de versão, às suas práticas de DevOps. Sua infraestrutura e implantações são automatizadas, consistentes e repetíveis. Assim como a entrega contínua automatizou o modelo tradicional de implantações manuais, o Infrastructure as Code (IaC) está evoluindo na forma como os ambientes de aplicativos são gerenciados.

Ferramentas como o Azure Resource Manager (ARM), o Terraform e a CLI (Interface de Linha de Comando) do Azure permitem que você crie scripts declarativos para a infraestrutura de nuvem necessária.

Modelos do Azure Resource Manager

ARM significa Azure Resource Manager (Gerenciador de Recursos do Azure). É um mecanismo de provisionamento de API que é incorporado ao Azure e exposto como um serviço de API. O ARM permite implantar, atualizar, excluir e gerenciar os recursos contidos no grupo de recursos do Azure em uma única operação coordenada. Você fornece ao mecanismo um modelo baseado em JSON que especifica os recursos necessários e sua configuração. O ARM orquestra automaticamente a implantação na ordem correta, respeitando as dependências. O motor garante idempotência. Se já existir um recurso desejado com a mesma configuração, o provisionamento será ignorado.

Os modelos do Azure Resource Manager são uma linguagem baseada em JSON para definir vários recursos no Azure. O esquema básico se parece com a Figura 10-14.

{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "",
  "apiProfile": "",
  "parameters": {  },
  "variables": {  },
  "functions": [  ],
  "resources": [  ],
  "outputs": {  }
}

Figura 10-14 - O esquema para um modelo do Resource Manager

Dentro deste modelo, pode-se definir um contêiner de armazenamento dentro da seção de recursos da seguinte forma:

"resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "name": "[variables('storageAccountName')]",
      "location": "[parameters('location')]",
      "apiVersion": "2018-07-01",
      "sku": {
        "name": "[parameters('storageAccountType')]"
      },
      "kind": "StorageV2",
      "properties": {}
    }
  ],

Figura 10-15 - Um exemplo de uma conta de armazenamento definida em um modelo do Resource Manager

Um modelo ARM pode ser parametrizado com ambiente dinâmico e informações de configuração. Isso permite que ele seja reutilizado para definir diferentes ambientes, como desenvolvimento, controle de qualidade ou produção. Normalmente, o modelo cria todos os recursos dentro de um único grupo de recursos do Azure. É possível definir vários grupos de recursos em um único modelo do Gerenciador de Recursos, se necessário. Você pode excluir todos os recursos em um ambiente excluindo o próprio grupo de recursos. A análise de custos também pode ser executada no nível do grupo de recursos, permitindo uma contabilidade rápida de quanto cada ambiente está custando.

Há muitos exemplos de modelos ARM disponíveis no projeto Modelos de Início Rápido do Azure no GitHub. Eles podem ajudar a acelerar a criação de um novo modelo ou modificar um existente.

Os modelos do Resource Manager podem ser executados de várias maneiras. Talvez a maneira mais simples seja simplesmente colá-los no portal do Azure. Para implantações experimentais, esse método pode ser rápido. Eles também podem ser executados como parte de um processo de compilação ou lançamento no Azure DevOps. Há tarefas que aproveitarão as conexões no Azure para executar os modelos. As alterações nos modelos do Resource Manager são aplicadas de forma incremental, o que significa que para adicionar um novo recurso é necessário apenas adicioná-lo ao modelo. As ferramentas irão reconciliar as diferenças entre os recursos atuais e os definidos no modelo. Os recursos serão então criados ou alterados para que correspondam ao que está definido no modelo.

Terraform

As aplicações nativas da nuvem são muitas vezes construídas para serem cloud agnostic. Ser assim significa que o aplicativo não está fortemente acoplado a um fornecedor de nuvem específico e pode ser implantado em qualquer nuvem pública.

O Terraform é uma ferramenta de modelagem comercial que pode provisionar aplicativos nativos da nuvem em todos os principais players de nuvem: Azure, Google Cloud Platform, AWS e AliCloud. Em vez de usar JSON como a linguagem de definição de modelo, ele usa a HCL (Hashicorp Configuration Language) um pouco mais concisa.

Um exemplo de arquivo Terraform que faz o mesmo que o modelo anterior do Resource Manager (Figura 10-15) é mostrado na Figura 10-16:

provider "azurerm" {
  version = "=1.28.0"
}

resource "azurerm_resource_group" "testrg" {
  name     = "production"
  location = "West US"
}

resource "azurerm_storage_account" "testsa" {
  name                     = "${var.storageAccountName}"
  resource_group_name      = "${azurerm_resource_group.testrg.name}"
  location                 = "${var.region}"
  account_tier             = "${var.tier}"
  account_replication_type = "${var.replicationType}"

}

Figura 10-16 - Um exemplo de um modelo do Resource Manager

Terraform também fornece mensagens de erro intuitivas para modelos de problemas. Há também uma tarefa de validação útil que pode ser usada na fase de compilação para detetar erros de modelo antecipadamente.

Assim como os modelos do Resource Manager, as ferramentas de linha de comando estão disponíveis para implantar modelos Terraform. Há também tarefas criadas pela comunidade no Azure Pipelines que podem validar e aplicar modelos Terraform.

Às vezes, os modelos Terraform e ARM geram valores significativos, como uma cadeia de conexão para um banco de dados recém-criado. Essas informações podem ser capturadas no pipeline de compilação e usadas em tarefas subsequentes.

Scripts e tarefas da CLI do Azure

Finalmente, você pode aproveitar a CLI do Azure para criar scripts declarativos de sua infraestrutura de nuvem. Os scripts da CLI do Azure podem ser criados, encontrados e compartilhados para provisionar e configurar praticamente qualquer recurso do Azure. A CLI é simples de usar com uma curva de aprendizagem suave. Os scripts são executados no PowerShell ou no Bash. Eles também são simples de depurar, especialmente quando comparados com modelos ARM.

Os scripts da CLI do Azure funcionam bem quando você precisa derrubar e reimplantar sua infraestrutura. Atualizar um ambiente existente pode ser complicado. Muitos comandos da CLI não são idempotentes. Isso significa que eles recriarão o recurso sempre que forem executados, mesmo que o recurso já exista. É sempre possível adicionar código que verifica a existência de cada recurso antes de criá-lo. Mas, fazendo isso, seu script pode ficar inchado e difícil de gerenciar.

Esses scripts também podem ser incorporados nos pipelines do Azure DevOps como Azure CLI tasks. A execução do pipeline invoca o script.

A Figura 10-17 mostra um trecho do YAML que lista a versão da CLI do Azure e os detalhes da assinatura. Observe como os comandos da CLI do Azure são incluídos em um script embutido.

- task: AzureCLI@2
  displayName: Azure CLI
  inputs:
    azureSubscription: <Name of the Azure Resource Manager service connection>
    scriptType: ps
    scriptLocation: inlineScript
    inlineScript: |
      az --version
      az account show

Figura 10-17 - Script da CLI do Azure

No artigo, What is Infrastructure as Code, o autor Sam Guckenheimer descreve como, "As equipes que implementam o IaC podem fornecer ambientes estáveis rapidamente e em escala. As equipes evitam a configuração manual de ambientes e impõem consistência representando o estado desejado de seus ambientes por meio de código. As implementações de infraestruturas com IaC são repetíveis e evitam problemas de runtime causados por desfasamento da configuração ou dependências em falta. As equipes de DevOps podem trabalhar em conjunto com um conjunto unificado de práticas e ferramentas para fornecer aplicativos e sua infraestrutura de suporte de forma rápida, confiável e em escala."

AnteriorSeguinte