CLImbaprenda AWS CLI digitando Praticar de graça

📄Entenda o JSON e YAML

São os dois jeitos de escrever dados em texto que a AWS entende. JSON usa chaves e colchetes ({"nome": "ana"}) e é o que a CLI devolve quando você pergunta algo. YAML guarda a mesma informação usando indentação em vez de chaves — mais fácil de ler e de comentar. Não são linguagens de programação: são formulários preenchidos.

Pra que serve

Quase tudo que é mais complexo que uma flag chega à AWS como arquivo: política de IAM, template de CloudFormation, definição de tarefa do ECS. Saber ler e escrever esses arquivos é o que separa "copiei do tutorial" de "entendi o que estou mandando" — e é o que te deixa achar o erro quando a AWS reclama de uma vírgula.

Onde se usa no mundo real

A AWS recusa sua política com "invalid JSON": falta uma vírgula entre dois blocos, ou sobra uma na última linha (JSON não aceita vírgula sobrando).
Você precisa dar acesso de leitura a um bucket: a permissão é um JSON com Effect, Action e Resource — e é você quem escreve.
Um template de CloudFormation em YAML não sobe porque uma linha ficou com tabulação em vez de espaços: no YAML a indentação É a estrutura.

Vocabulário

JSON: dados entre { } (objeto, pares chave:valor) e [ ] (lista). Todo texto vai entre aspas duplas.
YAML: os mesmos dados com indentação no lugar das chaves. Item de lista começa com -. Aceita comentário com #; JSON não aceita.
Chave e valor: o par nome: conteúdo. "Chave" aqui não tem nada a ver com chave de acesso — é só o nome do campo.
file://: prefixo que manda a CLI ler o arquivo do seu disco em vez de tratar o texto como valor. Esquecer dele é o erro nº 1 de quem passa política.
Validar: conferir se o arquivo está bem formado ANTES de mandar pra AWS — economiza a viagem e a mensagem de erro obscura.

💰 Como cobra: Formato de arquivo não custa nada. O que custa é o recurso que o arquivo cria: um template de CloudFormation é grátis, as 12 máquinas que ele sobe não.

Comandos que você aprende nesta trilha

Cada um deles roda de verdade no terminal do CLImb, com a mesma saída e as mesmas mensagens de erro que a AWS devolve.

`aws glue create-database`

aws glue create-database

aws glue create-database --database-input '{"Name":"dados_loja"}'

`aws glue get-databases`

aws glue get-databases

aws glue get-databases

`aws iam create-role`

criar papel (role)

aws iam create-role --role-name <nome>
--assume-role-policy-document file://<trust.json>

`aws s3 mb`

make bucket (criar bucket)

aws s3 mb s3://<nome-do-bucket>

`aws s3api put-bucket-policy`

aws s3api put-bucket-policy

aws s3api put-bucket-policy --bucket <nome> --policy file://<arquivo.json>

`aws cloudformation validate-template`

aws cloudformation validate-template

aws cloudformation validate-template --template-body <template>

`aws cloudformation create-stack`

aws cloudformation create-stack

aws cloudformation create-stack --stack-name <nome> --template-body <template>

`aws s3 ls`

listar buckets ou objetos

aws s3 ls                          lista todos os seus buckets
aws s3 ls s3://<bucket>            lista os objetos do bucket
aws s3 ls s3://<bucket>/<prefixo>  lista objetos com aquele prefixo

O que você pratica (13 atividades)

Cada atividade é um pedido de trabalho, do jeito que ele chega no dia a dia — você resolve digitando os comandos, não escolhendo alternativa.

Abra a caixa-preta

Daqui a pouco você vai criar uma role com --assume-role-policy-document file://trust.json e provavelmente vai copiar isso sem saber o que tem dentro. Não hoje: abra o trust.json e veja. (uma trust policy responde uma pergunta só: quem pode vestir esta role? Ela não fala de bucket nem de tabela — isso é a policy de permissão, que é outro arquivo)

Chave, valor, objeto e lista

Abra a politica-publica.json — é ela que deixa um site do S3 visível pra internet. Repare em quatro coisas: { } é um objeto (um conjunto de pares nome/valor), [ ] é uma lista, o nome vem sempre entre aspas duplas, e o par é separado por :. (o "Principal": "*" ali dentro é o que significa “qualquer um da internet” — um caractere que já vazou muito bucket por aí)

A vírgula que derruba tudo

Existe uma politica-quebrada.json aí que a AWS recusa. Abra e procure o defeito. (é o erro mais comum de todos: vírgula sobrando antes do fecha-chaves. JavaScript aceita, YAML nem tem vírgula, mas JSON não perdoa — e a mensagem que a AWS devolve costuma apontar a linha errada, o que faz muita gente procurar no lugar errado)

O mesmo dado, sem chaves nem aspas

Abra o site-s3.yaml. É a mesma ideia do JSON — nome e valor — mas em YAML: sem { }, sem aspas obrigatórias, e a lista vira - no começo da linha. (YAML existe porque template de infraestrutura é escrito e lido por gente. Todo YAML válido pode virar JSON e vice-versa — muda a roupa, não o conteúdo)

Indentação é sintaxe, não enfeite

Abra o infra.yaml, que descreve três recursos de uma vez. Repare que o que diz “isto está dentro daquilo” é só o espaço no começo da linha — não há chave nenhuma fechando bloco. (por isso YAML quebra com TAB: o formato exige espaços. E um espaço a mais muda de qual recurso a propriedade é — o arquivo continua válido e faz outra coisa, que é o pior tipo de bug)

Aspas: onde quase todo mundo trava

Agora escreva JSON direto no comando, sem arquivo. Crie o catálogo catalogo_formatos passando --database-input com o JSON entre aspas simples. (não importa o que o Glue faz agora — o que importa é a regra: o JSON usa aspas DUPLAS por dentro, então o pacote todo vai entre aspas SIMPLES por fora. Se você trocar e usar duplas nas duas pontas, o shell come as de dentro e a AWS responde Invalid JSON received. Pode testar o erro depois)

Pescar um campo no meio do despejo

Liste os catálogos com aws glue get-databases e repare no tanto de JSON que volta pra dizer um nome. Agora peça só o que interessa com --query: os nomes da lista. (--query é JMESPath, uma linguagem de caminho dentro do JSON. DatabaseList[].Name quer dizer: entre na lista e traga o campo Name de cada item. É o que transforma a saída da AWS em algo que dá pra usar num script)

Do arquivo ao comando

Fecha o ciclo: leia o tarefa-web.json (a receita de um contêiner) e repare que ele começa com [ — é uma lista de contêineres, não um objeto solto. Depois confira o maquina-estados.json, que é um objeto com passos aninhados. (saber se o arquivo é lista ou objeto é o que decide se a AWS aceita: passar objeto onde ela espera lista dá erro de tipo, não de sintaxe — o JSON está “certo” e mesmo assim não serve)

Escreva o seu

Você já leu o trust.json pronto. Agora escreva o seu: um trust-ec2.json que autoriza o serviço ec2.amazonaws.com a vestir a role — o pronto autoriza o Lambda. Depois confira com cat que saiu o que você queria. (o > joga a saída do echo dentro do arquivo, criando ou substituindo. O JSON inteiro vai entre aspas simples — mesma regra da atividade das aspas)

A AWS lê o que você escreveu

Fecha o ciclo: crie a role papel-formatos usando o seu arquivo, com --assume-role-policy-document file://trust-ec2.json. (file:// não tem mágica: é só “leia deste arquivo do disco”. Se o JSON estiver quebrado, é aqui que a AWS reclama — por isso se confere com cat antes de usar)

Conserte a política quebrada

Lembra da politica-quebrada.json, com a vírgula sobrando? Escreva a versão correta em politica-corrigida.json e aplique no bucket site-formatos, que você cria antes. (repare que o Resource tem que apontar pro SEU bucket — arn:aws:s3:::site-formatos/*. Política apontando pro bucket errado é aceita sem reclamar e não faz nada)

Um YAML linha a linha

YAML tem várias linhas e o echo escreve uma de cada vez — então se monta com >>, que acrescenta em vez de substituir. Monte o infra-minha.yaml descrevendo um bucket chamado bucket-que-escrevi e valide com o CloudFormation. (o primeiro > cria o arquivo; do segundo em diante é >>. Se errar e usar > de novo no meio, você apaga tudo o que já tinha escrito)

Suba a infraestrutura que você escreveu

Último passo, e o que junta tudo: suba a stack stack-formatos a partir do seu template e confirme que o bucket nasceu com o nome que você digitou. (é isto que Infraestrutura como Código significa na prática — você descreveu um recurso num arquivo de texto e a nuvem obedeceu. Daqui pra frente é o mesmo princípio, só com templates maiores)

Continue por aqui

Ler explica. Digitar fixa. No CLImb você roda os comandos de verdade num terminal AWS simulado — o estado persiste entre eles, como na nuvem real.

Esta trilha é inteiramente gratuita — não precisa pagar nem dar cartão.

Praticar de graça

Todas as lições · Praticar no terminal · Sobre