DEV Community

Cover image for Como Provisionar Infraestrutura AWS MediaConvert com Terraform
Marcos Vilela
Marcos Vilela

Posted on

Como Provisionar Infraestrutura AWS MediaConvert com Terraform

#aws #mediaconvert #terraform #deploy

Introdução

Recentemente, trabalhei em um projeto que envolvia o processamento de vídeos em escala na nuvem. Precisávamos de uma solução robusta para converter vídeos automaticamente, e o AWS MediaConvert se mostrou perfeito para isso. No entanto, configurar toda a infraestrutura necessária – filas, roles IAM, templates de job e logs – pode ser complexo. Decidi usar Terraform para automatizar tudo, criando uma infraestrutura como código que pudesse ser reutilizada em diferentes ambientes.

Neste artigo, vou compartilhar minha experiência implementando essa infraestrutura. Vou explicar passo a passo como provisionar os recursos essenciais do MediaConvert usando Terraform, desde a configuração inicial até o deploy. O foco é em uma abordagem prática, com exemplos de código e dicas para evitar armadilhas comuns.

Por Que Terraform para Infraestrutura de MediaConvert?

Antes de mergulhar no código, vamos entender o contexto. O AWS MediaConvert é um serviço gerenciado para transcodificação de vídeos. Ele suporta formatos variados e pode processar jobs em paralelo usando filas. Para integrá-lo com uma aplicação, como uma função Lambda que detecta uploads de vídeos no S3, precisamos de:

  • Uma fila MediaConvert para gerenciar jobs.
  • Um role IAM com permissões para acessar buckets S3 e escrever logs no CloudWatch.
  • Um template de job que define as configurações de transcodificação (resolução, bitrate, etc.).
  • Logs para monitoramento e debugging.

Fazer isso manualmente via console AWS é possível, mas propenso a erros e difícil de versionar. Com Terraform, tudo fica declarativo, versionado no Git e replicável em ambientes como staging e produção.

Estrutura do Projeto

Organizei o projeto da seguinte forma:

infra/terraform/
├── main.tf                        # Recursos principais
├── variables.tf                   # Declarações de variáveis
├── outputs.tf                     # Outputs para integração
├── version.tf                     # Configuração do provider
├── mediaconvert-template.json     # Template de job
└── envs/
    ├── staging/
    │   └── variables.tfvars
    └── prod/
        └── variables.tfvars
Enter fullscreen mode Exit fullscreen mode

Essa estrutura permite gerenciar múltiplos ambientes com arquivos de variáveis específicos. O template JSON define as configurações de vídeo, como resolução 720p, codec H.264 e bitrate variável.

Pré-requisitos

Antes de começar, certifique-se de ter:

  • Terraform instalado.
  • AWS CLI configurado com credenciais válidas.
  • Buckets S3 existentes para input e output de vídeos (o Terraform não cria buckets, apenas configura permissões).

Para configurar o backend S3 do Terraform (para armazenar o estado remotamente), edite o version.tf:

terraform {
  backend "s3" {
    bucket = "meu-bucket-tfstate"
    key    = "infra/mediaconvert.tfstate"
    region = "us-east-1"
  }

  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 4.40.0, <= 5.55.0"
    }
  }

  required_version = ">= 1.6.0"
}
Enter fullscreen mode Exit fullscreen mode

Definindo as Variáveis

No variables.tf, declarei todas as variáveis necessárias. Isso inclui região AWS, nomes de buckets, status da fila e configurações de aceleração. Por exemplo:

variable "aws_region" {
  description = "AWS region where resources will be created"
  type        = string
  default     = "us-east-1"
}

variable "s3_input_bucket" {
  description = "S3 bucket name for input videos"
  type        = string
}

variable "queue_status" {
  description = "MediaConvert queue status (ACTIVE or PAUSED)"
  type        = string
  default     = "ACTIVE"
}
Enter fullscreen mode Exit fullscreen mode

Para staging, criei um arquivo envs/staging/variables.tfvars com valores específicos:

aws_region   = "us-east-1"
environment  = "staging"
project_name = "mediaconvert-infra"

s3_input_bucket  = "meu-bucket-staging-input"
s3_output_bucket = "meu-bucket-staging-output"
queue_status     = "ACTIVE"
Enter fullscreen mode Exit fullscreen mode

Isso permite customizar por ambiente sem alterar o código principal.

Provisionando os Recursos Principais

No main.tf, comecei configurando o provider AWS com tags padrão:

provider "aws" {
  region = var.aws_region

  default_tags {
    Project     = "MediaConvert Infra"
    Environment = var.environment
    ManagedBy   = "Terraform"
  }
}
Enter fullscreen mode Exit fullscreen mode

Em seguida, criei o role IAM para o MediaConvert. Esse role precisa de permissões para ler do bucket de input, escrever no de output e publicar logs. Usei policy documents para definir as permissões granularmente:

data "aws_iam_policy_document" "mediaconvert_assume_role" {
  statement {
    actions = ["sts:AssumeRole"]
    principals {
      type        = "Service"
      identifiers = ["mediaconvert.amazonaws.com"]
    }
  }
}

resource "aws_iam_role" "mediaconvert_role" {
  name               = "${var.project_name}-role-${var.environment}"
  assume_role_policy = data.aws_iam_policy_document.mediaconvert_assume_role.json
  description        = "Service role for AWS MediaConvert"
}
Enter fullscreen mode Exit fullscreen mode

Anexei políticas para acesso S3 e operações MediaConvert. Para a fila, foi simples:

resource "aws_media_convert_queue" "main" {
  name   = "${var.project_name}-queue-${var.environment}"
  status = var.queue_status
}
Enter fullscreen mode Exit fullscreen mode

O template de job foi o mais desafiador, pois o provider Terraform não suporta nativamente. Usei um null_resource com local-exec para criar via AWS CLI:

resource "null_resource" "mediaconvert_job_template" {
  provisioner "local-exec" {
    command = "aws mediaconvert create-job-template --name ${var.project_name}-job-template-${var.environment} --settings file://${var.job_template_json_path}"
  }

  depends_on = [aws_media_convert_queue.main]
}
Enter fullscreen mode Exit fullscreen mode

Isso garante que o template seja criado após a fila. Por fim, adicionei um log group no CloudWatch para monitoramento.

Outputs para Integração

No outputs.tf, exportei os ARNs e nomes necessários para que a função Lambda possa criar jobs:

output "mediaconvert_queue_arn" {
  description = "ARN of the MediaConvert queue"
  value       = aws_media_convert_queue.main.arn
}

output "mediaconvert_role_arn" {
  description = "ARN of the MediaConvert IAM role"
  value       = aws_iam_role.mediaconvert_role.arn
}
Enter fullscreen mode Exit fullscreen mode

Isso facilita a integração com outros componentes da aplicação.

Deploy e Validação

Para aplicar em staging:

cd infra/terraform
terraform init
terraform plan -var-file=envs/staging/variables.tfvars
terraform apply -var-file=envs/staging/variables.tfvars
Enter fullscreen mode Exit fullscreen mode

Sempre valide com terraform plan antes de aplicar. Para produção, use o arquivo prod/variables.tfvars e considere adicionar aprovação manual nos workflows de CI/CD.

Lições Aprendidas

Durante a implementação, aprendi que:

  • Buckets S3 devem existir antes do Terraform; caso contrário, as políticas IAM falham.
  • O template JSON precisa ser validado manualmente, pois erros só aparecem no runtime.
  • Use workspaces Terraform para isolar ambientes e evitar conflitos de estado.

Essa abordagem tornou o deploy previsível e escalável. Se você está trabalhando com processamento de mídia na AWS, recomendo fortemente o Terraform para gerenciar essa infraestrutura.

Conclusão

Provisionar infraestrutura MediaConvert com Terraform não só automatiza o processo como também o torna versionável e replicável. Comecei com scripts manuais e migrei para IaC, o que reduziu erros e acelerou deploys. Se você tiver dúvidas ou quiser ver o código completo, confira o repositório no GitHub. Estou curioso para ouvir suas experiências com MediaConvert!

Top comments (0)