<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[awsugsp - Medium]]></title>
        <description><![CDATA[Artigos de pessoas da comunidade AWS no Brasil para pessoas da comunidade AWS Brasil. - Medium]]></description>
        <link>https://medium.com/awsugsp?source=rss----3a90e420e1---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>awsugsp - Medium</title>
            <link>https://medium.com/awsugsp?source=rss----3a90e420e1---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:03:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/awsugsp" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Nem todas as pessoas que possuem carta de motorista sabem dirigir]]></title>
            <link>https://medium.com/awsugsp/nem-todas-as-pessoas-que-possuem-carta-de-motorista-sabem-dirigir-52238e5802c8?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/52238e5802c8</guid>
            <category><![CDATA[certification]]></category>
            <category><![CDATA[community]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Marcelo Palladino]]></dc:creator>
            <pubDate>Mon, 16 Mar 2020 11:48:29 GMT</pubDate>
            <atom:updated>2020-03-16T11:47:54.140Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qPULScV945ggVayO.jpeg" /></figure><p>Recentemente eu tirei minha sexta certificação AWS, a <a href="https://aws.amazon.com/certification/certified-devops-engineer-professional/"><strong>AWS Certified DevOps Engineer — Professional</strong></a><strong>. </strong>Neste texto vou compartilhar um pouco dos meus pensamentos acerca de certificações em geral, participação em comunidades e como isso tem me ajudado, meu caminho e roteiro de estudos até esta certificação e minhas impressões sobre o exame.</p><h3>Sobre certificações</h3><blockquote>A certificação sozinha não quer dizer muita coisa.</blockquote><p>Deixe-me defender meu ponto usando um exemplo: O exame para <a href="https://aws.amazon.com/pt/certification/certified-solutions-architect-professional/">AWS Certified Solutions Architect — Professional</a> contém uma série de questões sobre AWS Organizations e Service Control Policies (SCP). Sabe quantas vezes eu tive que lidar com AWS Organizations no último ano? Nenhuma!</p><p>Estudei, fiz alguns laboratórios, fiz o exame e me certifiquei.</p><p>O que isso significa? Conheço o serviço, sei para ele serve, os problemas que pode resolver, mas…</p><blockquote>Qualquer pessoa que trabalhe e tenha experiência prática operando este serviço no dia a dia vai saber mais o que eu. Tendo certificado ou não!</blockquote><p>Sendo assim, com isso bem claro, restam duas razões que me motivam a continuar investindo parte do meu tempo para me preparar para certificações:</p><ul><li><strong>O percurso para a certificação.</strong> Para mim, ajuda a focar e criar uma rotina disciplinada de estudos, leitura e execução de laboratórios para realmente aprender ferramentas novas e fixar conceitos.</li><li><strong>O óbvio fato de estar certificado</strong> e como isso pode ajudar pessoas a considerarem meu perfil em oportunidades de trabalho. É claro que sem <strong>aproveitar o percurso para aprender</strong>, isso também não se sustenta por muito tempo.</li></ul><h3>Comunidades e o AWS User Group São Paulo</h3><p>Em 2017 o AWS User Group São Paulo criou a iniciativa <a href="http://awshub.com.br/99challenge.html">99 Challenge</a>. O objetivo era atingir a marca de 99 certificações AWS até o final daquele ano, selecionando pessoas da comunidade que receberiam o treinamento e vouchers para se prepararem e realizarem os exames gratuitamente.</p><p>Tornando curta uma estória que é longa, a iniciativa não foi até o final (por questões envolvendo viabilização financeira, patrocínio e engajamento), mas houve alguns pontos positivos que valem ser ditos:</p><ul><li><strong>Acesso ao curso da </strong><a href="https://acloud.guru/"><strong>A Cloud Guru</strong></a><strong> de forma totalmente gratuito</strong>: A comunidade conseguiu junto ao time do A Cloud Guru criar uma organização para ter 99 licenças para o curso preparatório para o exame AWS Certified Solution Architect — Associate. No meu caso específico foi a chance que tive de conhecer a plataforma e os outros cursos do A Cloud Guru.</li><li><strong>Rotina para discussão entre os participantes que estavam se preparando para o mesmo exame</strong>: Esta foi a melhor parte. Era gostoso e produtivo conversar com as pessoas que estavam se preparando. Funcionava como uma espécie de grupo de estudos, mas com pessoas que conheciam demais sobre o assunto, que estavam alí para se ajudar.</li></ul><p>Dada minha participação ativa no <a href="https://www.meetup.com/pt-BR/awsusergroupsp/">AWS User Group São Paulo</a>, constantemente estou envolvido em discussões sobre a validade ou não de participar de comunidades, as reais intenções das pessoas que estão organizando, pessoas centralizadoras, egos inflados e coisas do gênero.</p><blockquote>Pense nisso: as comunidades espelham as sociedades onde existem.</blockquote><p>Sem entrar nos méritos dessas questões, o que posso dizer é que <strong>no meu caso</strong> o saldo tem sido mais positivo do que negativo. Nos últimos anos tenho me dedicado mais ao AWS UG SP e lá o ambiente é <strong>democrático</strong>, amigável e seguro. Muitas pessoas fazem suas primeiras apresentações no grupo, outras querem puxar iniciativas (e puxam), algumas estão em começo de carreira e querem bater papo, enquanto há profissionais super experientes que querem ajudar…</p><p>Se você não conhece, fica aí a dica:</p><p><a href="https://www.meetup.com/pt-BR/awsusergroupsp/">AWS User Group São Paulo (São Paulo, Brasil)</a></p><figure><img alt="Foto com aproximadamente 11 pessoas no meetup de fevereiro de 2020 do AWS UG SP." src="https://cdn-images-1.medium.com/max/600/0*RCNfkwuuSBWLsjUs.jpeg" /><figcaption>Meus grandes amigos <a href="https://medium.com/u/b53070565a87">Vanessa Santos</a> e <a href="https://medium.com/u/f0a2ae971d29">Fabio Balancin</a> tocando o encontro de Fevereiro de 2020 do AWS User Group São Paulo.</figcaption></figure><h3>Caminho e roteiro de estudos para esta certificação</h3><p>Eu tenho um grande amigo que se preparou para um exame por duas semanas apenas lendo os Whitepapers (e passou). Sim, eu o admiro, mas acho que invejo mais do que admiro! hahaha</p><p>Brincadeiras à parte, eu não funciono assim. Preciso de recursos que me ajudem a “enxergar” conceitos e usar os serviços criando cenários reais. Abaixo eu compartilho os recursos que utilizei durante minha preparação para este exame.</p><h4>Iniciando</h4><p>O primeiro documento que li foi o <a href="https://d1.awsstatic.com/training-and-certification/docs-devops-pro/AWS%20Certified%20DevOps%20Engineer%20Professional_Exam%20Guide_v1.5_FINAL%20(2).pdf">guia do exame</a>. Este documento descreve o que será avaliado, o tipo de conhecimento esperado e, principalmente, os Whitepapers recomendados.</p><p><strong>Tudo bem se você esquecer de todo o resto do que leu até aqui, mas lembre-se disso se estiver se preparando para sua próxima certificação AWS:</strong></p><blockquote>Leia os Whitepapers <em>recomendados com atenção!</em></blockquote><h4>Linux Academy</h4><p>Utilizei o curso <a href="https://linuxacademy.com/cp/modules/view/id/206">AWS Certified DevOps Engineer — Professional Level</a> da Linux Academy.</p><p>O curso está bem atualizado e o conteúdo bate muito com o que caiu no exame. Muito mesmo! Os laboratórios deixam um pouco a desejar, mas são um bom ponto de partida para a maioria dos serviços.</p><h4>QWIKLABS</h4><p>Esta plataforma fornece credenciais temporárias para que você possa aprender usando ambientes reais . Há laboratórios individuais de 30 minutos e cursos de vários dias. Eu comprei 50 <a href="https://www.qwiklabs.com/payments/new">créditos</a> avulsos e fui “gastando” naquilo que julguei ser mais útil para mim.</p><ul><li><a href="https://www.qwiklabs.com/quests/8?catalog_rank=%7B%22rank%22%3A8%2C%22num_filters%22%3A0%2C%22has_search%22%3Atrue%7D&amp;search_id=4857628">Deployment &amp; Management</a></li><li><a href="https://www.qwiklabs.com/focuses/8697?catalog_rank=%7B%22rank%22%3A23%2C%22num_filters%22%3A0%2C%22has_search%22%3Atrue%7D&amp;parent=catalog&amp;search_id=4857647">Introduction to AWS OpsWorks</a></li><li><a href="https://www.qwiklabs.com/focuses/10247?catalog_rank=%7B%22rank%22%3A24%2C%22num_filters%22%3A0%2C%22has_search%22%3Atrue%7D&amp;parent=catalog&amp;search_id=4857647">Introduction to AWS Service Catalog</a></li><li><a href="https://www.qwiklabs.com/focuses/10413?catalog_rank=%7B%22rank%22%3A29%2C%22num_filters%22%3A0%2C%22has_search%22%3Atrue%7D&amp;parent=catalog&amp;search_id=4857647">Auditing Your Security with AWS Trusted Advisor</a></li><li><a href="https://www.qwiklabs.com/focuses/7864?catalog_rank=%7B%22rank%22%3A79%2C%22num_filters%22%3A0%2C%22has_search%22%3Atrue%7D&amp;parent=catalog&amp;search_id=4857673">Scale Your Security Vulnerability Testing with Amazon Inspector</a></li></ul><h4>Simulados</h4><p>Fiz três simulados (e reprovei nos três):</p><ul><li>Linux Academy</li><li>A Cloud Guru</li><li>Simulado com 20 questões da AWS</li></ul><p>Simulados longos como os da Linux Academy e do A Cloud Guru são ótimos. Eu separei um tempo para eles e os fiz como se fosse no dia do exame. Isso me ajudou a aprender a gerenciar o tempo, o que é muito importante neste tipo de exame, além de mostrar os pontos em que eu deveria focar mais os estudos.</p><p>O simulado da AWS é propositalmente (eu acho) mais difícil que o exame real.</p><p>Sobre meus resultados nos simulados, é claro que o desejável seria passar. Mas como quase nunca acontece comigo, parei de me preocupar com isso e passei a me preocupar em interpretar melhor os resultados.</p><h3>Impressões sobre o exame</h3><p>Minha impressão geral sobre o exame é que se trata de um <strong>exame difícil</strong> e que cobra que você tenha <strong>“sujado as mãos”</strong> fuçando nos serviços, simulando cenários de DevOps, deploys, monitoramento e resposta a incidentes.</p><h4>Dicas gerais</h4><ul><li>Em caso de dúvida, elimine opções claramente incorretas. Em muitas questões foi possível eliminar opções incorretas até ficar com apenas duas possíveis.</li><li>Esteja preparado para questões sobre <strong>disaster recovery</strong>, <strong>tolerância a falhas</strong> e <strong>alta disponibilidade</strong>. Este tema sozinho equivale a 15.7% do conteúdo do exame. No nível “professional”, não importa por qual das duas você vai começar, isso vai ser cobrado de qualquer forma.</li></ul><h4>O que caiu com destaque</h4><ul><li>Ferramentas para desenvolvedores da AWS: <a href="https://console.aws.amazon.com/codesuite/codecommit/start?region=us-east-1">CodeCommit</a>, <a href="https://console.aws.amazon.com/codesuite/codebuild/start?region=us-east-1">CodeBuild</a>, <a href="https://console.aws.amazon.com/codesuite/codedeploy/start?region=us-east-1">CodeDeploy </a>e <a href="https://console.aws.amazon.com/codesuite/codepipeline/start?region=us-east-1">CodePipeline</a></li><li>CloudWatch Logs, CloudWatch Agent, Metrics, Events e Alarms</li><li>EC2 Autoscaling e <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html">lifecycle hooks</a></li><li><a href="https://docs.amazonaws.cn/en_us/AWSCloudFormation/latest/UserGuide/aws-attribute-updatepolicy.html">CloudFormation Update Policies</a> (especialmente AutoScalingRollingUpdate)</li></ul><h4>Outras coisas que consigo me lembrar</h4><ul><li>Boas práticas de git flow e configuração do CodeCommit</li><li><a href="https://console.aws.amazon.com/elasticbeanstalk/home?region=us-east-1#">AWS Elastic Beanstalk</a> (certifique-se de estudar bem as possibilidades de personalização usando arquivos “<a href="https://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/ebextensions.html">.ebextensions</a>”)</li><li>Estratégias de deploy (Blue/Green, Canary Release, In-place, etc…)</li><li>CloudFormation <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-helper-scripts-reference.html">helper scripts</a></li><li>AWS Systems Manager</li><li><a href="https://aws.amazon.com/pt/ecs/">ECS</a> (especialmente <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">cenários de deploy</a>)</li></ul><h4>O que era esperado por mim e não caiu</h4><ul><li>Questões envolvendo detalhes de modelagem no DynamoDB (partionkeys, sortkeys, dynamodb throughput)</li><li>OpsWorks</li><li>Questões envolvendo cenários de versionamento de API no API Gateway</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52238e5802c8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/nem-todas-as-pessoas-que-possuem-carta-de-motorista-sabem-dirigir-52238e5802c8">Nem todas as pessoas que possuem carta de motorista sabem dirigir</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AWS User Group São Paulo — Orientações sobre os Meetups]]></title>
            <link>https://medium.com/awsugsp/aws-user-group-s%C3%A3o-paulo-orienta%C3%A7%C3%B5es-sobre-os-meetups-62e77639f527?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/62e77639f527</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[community]]></category>
            <category><![CDATA[user-group]]></category>
            <category><![CDATA[meetup]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Sat, 14 Mar 2020 22:41:06 GMT</pubDate>
            <atom:updated>2020-03-14T22:56:41.392Z</atom:updated>
            <content:encoded><![CDATA[<h3>AWS User Group São Paulo — Orientações sobre os Meetups</h3><figure><img alt="Foto com aproximadamente 100 pessoas assistindo uma apresentação no AWS User Group São Paulo" src="https://cdn-images-1.medium.com/max/600/0*Uk-GWw3xkC5S62VV.jpeg" /></figure><p>O AWS User Group São Paulo é uma comunidade que organiza encontros <strong>públicos e presenciais</strong>. Nossa intenção, mais do que qualquer outra, é promover um ambiente amigável, <strong>seguro e acolhedor</strong> para que todas as pessoas possam aproveitar os encontros para <strong>criar e ampliar redes de contatos</strong>, além de <strong>disseminar conhecimento</strong>.</p><p>Entendemos que os encontros presenciais fazem parte da dinâmica de ensino e aprendizado de/para e entre as pessoas. <strong>Amamos tecnologia, trabalhamos duro e nos divertimos com isso</strong>. Entendemos que o aprendizado nos eventos das comunidades é muito enriquecedor, uma vez que não se olha apenas o aspecto técnico das soluções, mas também o aspecto humano trazido por outras pessoas ao solucionar seus desafios.</p><p>Mantendo a crença na continuidade desta troca rica de conhecimento, pensando na saúde e segurança dos membros da comunidade, <strong>alteraremos temporariamente os encontros presenciais exclusivamente para plataformas digitais</strong>.</p><p>Desta forma as próximas edições, iniciando em 24 de março, serão transmitidas digitalmente com link que será disponibilizado nos eventos publicados na plataforma meetup.</p><p>Seguiremos as orientações do Ministério da Saúde e da OMS para prevenção ao COVID-19 e permaneceremos atentos sobre novas atualizações.</p><h3>Alternativas</h3><p>Como todo o resto que ocorre no AWS User Group São Paulo, <strong>democracia </strong>é um <strong>princípio </strong>básico. Estamos pensando/trabalhando com algumas possibilidades e queremos saber a opinião das pessoas que fazem parte da comunidade.</p><p>A pesquisa abaixo possui três perguntas, não vai tomar mais do 5 minutos do seu tempo e <strong>vai nos ajudar a dar os próximos passos</strong>:</p><p><a href="http://bit.ly/awsugsp-covid-19">http://bit.ly/awsugsp-covid-19</a></p><h3>Links externos com orientações oficiais</h3><p><a href="https://www.saude.gov.br/saude-de-a-z/coronavirus#prevencao">https://www.saude.gov.br/saude-de-a-z/coronavirus#prevencao</a></p><p><a href="http://plataforma.saude.gov.br/novocoronavirus/">http://plataforma.saude.gov.br/novocoronavirus/</a></p><p>Cuidem-se bem, continuamos juntos digitalmente e, em breve, nos encontros presenciais novamente!</p><p>AWS User Group São Paulo</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62e77639f527" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/aws-user-group-s%C3%A3o-paulo-orienta%C3%A7%C3%B5es-sobre-os-meetups-62e77639f527">AWS User Group São Paulo — Orientações sobre os Meetups</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Provisionando uma instância do Microsoft SQL Server sob um container Docker]]></title>
            <link>https://medium.com/awsugsp/provisionando-uma-inst%C3%A2ncia-do-microsoft-sql-server-sob-um-container-docker-6a6fb5779865?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/6a6fb5779865</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[cloudbr]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[containers]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 01:13:42 GMT</pubDate>
            <atom:updated>2017-08-14T14:59:27.255Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s-YgL1NW7evYyCBWI-7w8Q.png" /></figure><p>Este artigo abordará como configurar e executar um serviço do SGBD Microsoft SQL no sistema operacional Linux sob um container Docker, utilizar a persistência de volumes de dados sob o container, bem como, explorar a execução de binários como o sqlcmd para estabelecer uma sessão com o serviço do SQL Server e realizar o processo de backup e restore de uma base de dados.<br> <br> A imagem de container Docker disponibilizada pela Microsoft que será utilizada é: microsoft/mssql-server-linux</p><p>Para este artigo utilizaremos o Docker Hub para realizar o pull da imagem acima mencionada.</p><p>A seguir temos os requisito mínimos para poder utilizar a imagem de container Docker disponibilizada pela Microsoft:</p><ul><li>Docker Engine 1.8 ou superior</li><li>Mínimo de 4 GB de espaço em disco</li><li>Mínimo de 4 GB de RAM</li><li>Configurar uma senha forte para a conta de administrador do serviço do SQL Server, senha essa contendo pelo menos 8 caracteres utilizando letras maiúsculas e minúsculas, números e/ou símbolos não alfanuméricos.</li></ul><p>Para este artigo utilizamos a distribuição Debian 9, e a instalação do Docker pode ser realizada de maneira simples através da etapas abaixo:</p><p>– Instale os pacotes que serão dependências no restante do processo de instalação do Docker Engine:</p><pre><em>sudo apt install -y curl apt-transport-https \ software-properties-common ca-certificates</em></pre><p>– Adicione a chave do repositório:</p><pre><em>curl -fsSL </em><a href="https://yum.dockerproject.org/gpg"><em>https://yum.dockerproject.org/gpg</em></a><em> | sudo apt-key add –</em></pre><p>– Adicione o repositório ao sistema:</p><pre><em>sudo add-apt-repository “deb </em><a href="https://apt.dockerproject.org/repo/"><em>https://apt.dockerproject.org/repo/</em></a><em> \ debian-$(lsb_release -cs) \ testing”</em></pre><p>– Atualize o banco de dados de referência de pacotes do sistema:</p><pre><em>sudo apt-get update -y</em></pre><p>– Instale o pacote do Docker Engine:</p><pre><em>sudo apt-get install -y docker-engine</em></pre><p>– Execute os <em>daemons </em>do Docker e ative o serviço na inicialização do sistema:</p><pre><em>sudo systemctl start docker<br>sudo systemctl enable docker</em></pre><p>– Adicione o atual usuário logado no grupo de usuário Docker. Essa ação fará com que não seja necessária a utilização do comando sudo para utilização docker.</p><pre><em>sudo gpasswd -a “${USER}” docker</em></pre><p>– Reinicie o sistema para testar a inicialização do serviço do Docker:</p><pre><em>sudo reboot</em></pre><p>– Liste os containers criados (em execução e não em execução):</p><pre><em>docker ps -a</em></pre><p>Obviamente a listagem não retornará nada pois não existem container criados.</p><p>– Crie e execute um container utilizando uma imagem de teste chamada hello-run</p><pre><em>docker run hello-world</em></pre><p>Esta ação fará com que o engine do Docker realize o pull da imagem diretamente do Docker Hub.</p><p>Após a execução do conteiner ele exibirá algumas mensagens, dentro elas: Hello from Docker !</p><p>Você poderá verificar que o host possui um container que não esta em execução, pois o container criado e que entrou em execução apenas exibiu algumas mensagens relacionadas a teste e em seguida teve a execução finalizada.</p><pre><em>docker ps -a</em></pre><p>Da mesma forma que existe um container que não está em execução, temos uma imagem que sofreu o download para o host, imagem essa utiliza de base para execução do nosso container de teste:</p><pre><em>docker images</em></pre><p>Vamos realizar o pull da imagem de container do SQL Server e utiliza-la para criar e executar o container que proverá um serviço de banco de dados da Microsoft sob o host atual.</p><p>Entretanto, antes disso iremos criar uma estrutura de diretórios que permitirá termos persistência dos dados do container, especificamente, do diretório <em>/var/opt/mssql</em> que no caso é o diretório dentro da estrutura do container que armazenará os <em>datafiles </em>dos bancos de dados do SQL Server.</p><p>É muito importantes a configuração da persistência, pois ao finalizar o container por padrão os dados serão perdidos, e em muitas situações a perda dos dados gerados durante a execução do container não é aceitável. Entretanto, tudo dependerá da finalidade do container, afinal, podemos executar um container, gerar informações nele, mas tais informações poderem ser descartadas ou as mesmas já terem sido armazenadas em outro host ou container que utiliza persistência de dados.</p><p>Portanto, crie a seguinte estrutura de diretórios:</p><pre><em>mkdir /data/containers/SQLServer01/mssql -p</em></pre><p>Em seguida execute o container, que será nomeado como <em>SQLServer01</em>.</p><pre><em>docker run –name SQLServer01 -e ‘ACCEPT_EULA=Y’ \ -e ‘SA_PASSWORD=#AdminSQLServer2017’ \ -p 1433:1433 -v /data/containers/SQLServer01/mssql:/var/opt/mssql \<br>-d microsoft/mssql-server-linux</em></pre><p>Aguarde o pull da imagem para que o container seja criado e entre em execução</p><p>O comando acima pode ser entendido da seguinte maneira:</p><p><strong>run </strong>— esta opção realiza três ações: pull da imagem, criação do container e em seguida execução do container criado.</p><p><strong>-e</strong> — permite a criação de variáveis de ambiente sob o ambiente de execução do container. <br>No caso acima, foram criadas duas variáveis de ambiente: <strong>ACCEPT_EULA </strong>recebendo o valor Y e <strong>SA_PASSWORD</strong> recebendo o valor #AdminSQLServer2017 (que será a senha da conta System <em>Administrator </em>do SQL Server). Deste modo, durante a execução do binário existente na imagem que sofreu o pull, este binário irá verificar a existências destas variáveis e utilizar os valores setados nelas.<br> A variável ACCEPT_EULA permite que definir se os termos da licença de uso serão aceitos.</p><p><strong>-p</strong> — permite realizar o mapeamento de portas. No caso acima, qualquer conexão a porta 1433 ( valor numérico a esquerda dos : ) será redirecionada para a porta 1433 ( valor numérico a direita dos : ) em listening no container.</p><p><strong>-d</strong> — executará o container em modo background.</p><p><strong>-</strong>v — anexará um volume externo a um volume dentro do container, no caso, teremos o mapeamento do diretório /data/containers/SQLServer01/mssql existente no host para o diretório /var/opt/mssql existente no container.<br> Portanto ação de criação, exclusão e alteração ocorrida em /var/opt/mssql dentro do container também ocorrerá em /data/containers/SQLServer01/mssql (que encontra-se acessível no host que executa o container).</p><p><strong>–name</strong> — Define o nome que o container terá ao ser criado.</p><p>Em seguida verifique se o container está em execução:</p><pre><em>docker ps</em></pre><p>Caso o container não seja listado, então execute novamente o comando docker run sem a opção -d</p><p>Para podermos visualizar no console qualquer mensagem de erro durante a inicialização dos binários do container.<br> Um erro muito comum é a falta de memória no host, lembrando que a recomendação mínima são 4 GB.</p><p>Verificada a existência de algum erro (por exemplo, quantidade de memória insuficiente), abra outro terminal e pare o container com o comando:</p><pre><em>docker stop SQLServer01</em></pre><p>Para executar novamente o container, basta executar:</p><pre><em>docker start SQLServer01</em></pre><p>Verifique novamente se o container está em execução:</p><pre><em>docker ps</em></pre><p>Com o container em execução iremos estabelecer uma sessão de usuário com o serviço em execução sob o Container.</p><p>Dentro das das vantagens clássicas de container temos isolamento, portabilidade e flexibilidade, e graças a isso podemos não apenas executar binários e bibliotecas existentes em uma imagem na forma de um container que atuará como serviço, mas também podemos simplesmente realizar a chamada a outros binários existentes no container já em execução, por exemplo, um binário que represente uma ferramenta de linha de comando que faz parte da solução empacotada dentro da imagem.</p><p>Iremos iniciar o binário bastante conhecido por DBA que trabalham com SQL Server, o sqlcmd para estabelecermos uma sessão de usuário com o serviço do SQL Server.</p><pre><em>docker exec -it SQLServer01 /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P #AdminSQLServer2017</em></pre><p>A opção <strong>exec </strong>realiza a chamada a binários existentes dentro de um container em execução, ou seja, sem precisar criar um novo container apenas para executar um binário já existente na imagem que foi utilizada de base para a criação do container anterior.</p><p>Já as opções <strong>-it</strong> permitem que durante a execução do binário <em>sqlcmd </em>seja possível estabelecer a interação entre entre o shell e o binário em execução no momento.</p><p>Após a execução do binário sqlcmd serão exibido o prompt</p><pre><em>1&gt;</em></pre><p>Execute a instrução SQL select a seguir acompanhada da instrução GO:</p><pre><em>SELECT Name from sys.Databases;</em></pre><pre><em>GO</em></pre><p>Serão exibidos os <em>databases </em>padrão do SQL Server, no caso:</p><p>Realizaremos a seguir algumas operações simples em SQL:</p><ul><li>Criação de um database;</li><li>Abertura do database;</li><li>Criação de uma tabela;</li><li>Inserção de registros nesta tabela;</li><li>Consulta de registros;</li></ul><pre><em>create database empresa; go use empresa; go create table cliente (codigo integer, nome varchar(80), primary key(codigo)); go insert into cliente values (1,”Linus Torvalds”); go insert into cliente values (2,”Dennis Ritchie”); go select * from cliente; go</em></pre><pre><em>exit</em></pre><p>Com a sessão finalizada com a instrução exit, iremos parar o container e inicia-lo novamente para comprovar que a persistência de dados está sendo realizada corretamente.</p><pre><em>docker stop SQLServer01</em></pre><p>Verifique se o container não encontra-se mais em execução:</p><pre><em>docker ps</em></pre><p>Liste os arquivos e diretórios criados no nosso diretório utilizado para persistência de dados do container:</p><pre><em>ls -l /data/containers/SQLServer01/mssql/data</em></pre><p>Podemos constar que os <em>datafiles </em>do nosso <em>database</em> empresa, bem como, os <em>datafiles </em>dos bancos de dados default do SQL Server foram criados efetivamente no diretório de persistência.</p><p>Inicie o container novamente e verifique que o binário do serviço do SQL Server em execução sob o container irá obter acesso aos <em>datafiles</em>:</p><pre><em>docker run SQLServer01</em></pre><p>Execute o binário do cliente <em>sqlcmd </em>novamente:</p><pre><em>docker exec -it SQLServer01 /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P #AdminSQLServer2017</em></pre><p>Liste os <em>databases </em>existentes:</p><pre><em>SELECT Name from sys.Databases;<br> go</em></pre><p>Executando backup completo do <em>database </em>empresa:</p><pre><em>docker exec -it SQLServer01 /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P #AdminSQLServer2017 -Q “BACKUP DATABASE [empresa] to disk = ‘/var/opt/mssql/backup-empresa.sql’”</em></pre><p>Devido o mapeamento de volume de dados no container, podemos copiar o arquivo backup-empresa.sql (existentente em /data/containers/SQLServer01/mssql) para outro local.</p><p>Restaurando o backup completo do database empresa:</p><pre><em>docker exec -it SQLServer01 /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P #AdminSQLServer2017 -Q “RESTORE DATABASE [empresa] from disk = ‘/var/opt/mssql/backup-empresa.sql’ WITH REPLACE”</em></pre><p>Este é um exemplo simples de backup e <em>restore</em>, entretanto, vale salientar que existem outras opção relacionadas ao backup, como por exemplo, backup do log de transações, entre outra. O objetivo do artigo foi apenas demonstrar a chamada de binários existentes no container não apenas para prover um serviço de banco dados, mas também utilizar ferramentas como <em>sqlcmd </em>existente na árvore do <em>filesystem </em>do container.</p><p>No próximo artigo estaremos abordando balanceamento de carga sob um <em>Cluster Docker Swarm</em>, bem como, a instalação e configuração do <em>Openshift</em>.</p><p><em>Originally published at </em><a href="https://waldemardibiazijr.wordpress.com/2017/07/04/provisionando-uma-instancia-do-microsoft-sql-server-sob-um-container-docker/"><em>waldemardibiazijr.wordpress.com</em></a><em> by Waldemar Dibiazi Jr.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a6fb5779865" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/provisionando-uma-inst%C3%A2ncia-do-microsoft-sql-server-sob-um-container-docker-6a6fb5779865">Provisionando uma instância do Microsoft SQL Server sob um container Docker</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Auto Scaling Lifecycle Hooks]]></title>
            <link>https://medium.com/awsugsp/auto-scaling-lifecycle-hooks-420211ce2852?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/420211ce2852</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[digital]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 01:13:21 GMT</pubDate>
            <atom:updated>2017-07-28T15:59:55.897Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*ogVIk5jDQgpOIEHa7odlEQ.jpeg" /></figure><p><strong>A</strong> alguns anos venho percebo que existem pouco conteúdo de AWS em português, mas alguns temas simplesmente não se acha absolutamente nada. Por isso estou escrevendo sobre Auto Scaling Lifecycle Hooks</p><blockquote>Auto Scaling lifecycle hooks permite que sejam realizadas ações personalizadas quando o Auto Scaling inicia ou termina alguma instancia. Por exemplo, pode-se configurar ou instalar algo quando uma nova instancia é iniciada, ou fazer backup dos arquivos de log antes que uma instancia seja terminada.</blockquote><p>Dito isso, vamos começar com os trabalhos. A ideia desse post é dar opções para utilizar essa função da forma que mais for útil em seu ambiente.</p><p>Para essas configurações, recomendo criar uma instancia simples com Amazon Linux na mesma região a ser configurado <em>lifecycle hooks</em> na AWS para servir de base de apoio (o qual chamaremos de “base_server” nesse post). Essa instancia precisará possuir ROLE com permissão manipulação de funções de autoscaling, SNS e Lambda.</p><p><em>Obs.: fique atento ao copiar um comando com caracteres quebrados, pois o “-” duplos normalmente sai quebrado.</em></p><p>Para essas configurações, precisamos ter o nome do AutoScaling que receberá essas configurações. Nesse caso, estou partindo de um principio que o nome dele é “autoscaling_group”. Mas estarão sendo representados por variáveis:</p><p>Logado no base_server, execute os comandos abaixo:</p><blockquote>LC_HOOK_LAUNCHING=”lab-lifecycle-hook”<br>AS_NAME=”autoscaling_group”<br>REGIAO_AWS=$(curl -s <a href="http://instance-data/latest/dynamic/instance-identity/document">http://instance-data/latest/dynamic/instance-identity/document</a> | grep region | awk -F’”’ ‘{print $4}’)<br>aws — region $REGIAO_AWS autoscaling put-lifecycle-hook — lifecycle-hook-name $LIFECYCLE_HOOK_NAME_LAUNCHING — auto-scaling-group-name AUTOSCALING_NAME — lifecycle-transition autoscaling:EC2_INSTANCE_LAUNCHING</blockquote><p>Depois de criar o <em>lifecycle hook</em>, toda instancia iniciada nesse <em>AutoScaling </em>ficará com o status de <strong><em>Pending:Wait</em></strong> até que alguém mude o status dela ou passe 60min por conta do time-out.<br>Nesse caso, no script de user-data de inicialização da instancia, após realizar tudo que for necessário para sua inicialização, colocaremos uma notificação para o <em>Lifecycle Hooks</em> liberar a instancia para que ela fique com o status de <strong><em>InService</em></strong>.</p><p>Segue um exemplo simples de script de update de SO e instalação e configuração do Apache. Esse script deve ficar no UserData da instancia que esta sendo iniciado pelo AutoScaling</p><blockquote>#!/bin/bash<br>LC_HOOK_LAUNCHING=”devops-pro-hook”<br>AS_NAME=”autoscaling_group”<br>HOSTNAME=$(curl <a href="http://instance-data/latest/meta-data/local-hostname">http://instance-data/latest/meta-data/local-hostname</a>)<br>REGIAO_AWS=$(curl -s <a href="http://instance-data/latest/dynamic/instance-identity/document">http://instance-data/latest/dynamic/instance-identity/document</a> | grep region | awk -F’”’ ‘{print $4}’)<br>INSTANCE_ID=$(curl <a href="http://instance-data/latest/meta-data/instance-id/">http://instance-data/latest/meta-data/instance-id/</a>)<br>yum update -y &amp;&amp; \<br>yum install -y httpd &amp;&amp; \<br>service httpd start &amp;&amp; \<br>chkconfig httpd on &amp;&amp; \<br>echo “&lt;h1&gt;Bem vindo ao seu servidor WEB&lt;/h1&gt; &lt;h2&gt;Instance-id $INSTANCE_ID&lt;/h2&gt; &lt;h2&gt;hostname $HOSTNAME&lt;/h2&gt;” &gt; /var/www/html/index.html &amp;&amp; \<br>chmod 644 /var/www/html/index.html &amp;&amp; \<br>chown root:root /var/www/html/index.html &amp;&amp; \<br>aws autoscaling complete-lifecycle-action — lifecycle-action-result CONTINUE — instance-id $INSTANCE_ID — lifecycle-hook-name $LC_HOOK_LAUNCHING — auto-scaling-group-name $AS_NAME — region $REGIAO_AWS || \<br>aws autoscaling complete-lifecycle-action — lifecycle-action-result ABANDON — instance-id $INSTANCE_ID — lifecycle-hook-name $LC_HOOK_LAUNCHING — auto-scaling-group-name $AS_NAME — region $REGIAO_AWS</blockquote><p>Nesse caso, o script tenta instalar o Apache e configurar uma pagina WEB inicial, caso tudo ocorra bem, será enviado um <em>result </em>ao <em>lifecycle </em>de <strong>CONTINUE </strong>para ele deixar a instancia como <em>InService</em>. <br>Caso ocorra algo errado, será enviado um comando <strong>ABANDON</strong>, o que irá fazer com que a instancia seja terminada.</p><p>Esse procedimento é muito utilizado para ambientes com deploy mais elaborado e demorado, fazendo com que a instancia só entre em produção e seja apresentada ao <strong>ELB </strong>após o termino (<em>com sucesso</em>) do deploy, mitigando os riscos de uma instancia entrar em produção antes de estar 100% pronta.</p><p>Para esse LyfeCycle, utilizaremos, alem do <em>AutoScaling</em>, <em>SNS </em>e <em>Lambda </em>para manipular a instancia após durante o processo de <em>terminate </em>do <em>AutoScaling</em></p><p><strong>Primeiro, vamos criando um tópico de SNS</strong></p><blockquote>REGIAO_AWS=$(curl -s <a href="http://instance-data/latest/dynamic/instance-identity/document">http://instance-data/latest/dynamic/instance-identity/document</a> | grep region | awk -F’”’ ‘{print $4}’)<br>SNS_NAME=”sns-autoscaling”<br>SNS_ARN=$(aws — profile mandic sns — region $REGIAO_AWS create-topic — name $SNS_NAME — output text | tr -d ‘\r’)</blockquote><p>Após essa criação, se atente a guardar o valor da variável $SNS_ARN que utilizaremos na sequência.</p><p>Agora criaremos uma função Lambda que irá realizar um <em>snapshot </em>da instancia antes de ela ser finalizada.</p><p><strong>Antes, precisamos criar a role a ser usada pelo SNS.</strong></p><blockquote>echo “{<br> \”Version\”: \”2012–10–17\”,<br> \”Statement\”: [ {<br> \”Sid\”: \”\”,<br> \”Effect\”: \”Allow\”,<br> \”Principal\”: {<br> \”Service\”: \”autoscaling.amazonaws.com\”<br> },<br> \”Action\”: \”sts:AssumeRole\”<br> } ]<br>}” &gt; SNS-Role-Trust-Policy.json</blockquote><blockquote>echo “{<br> \”Version\”: \”2012–10–17\”,<br> \”Statement\”: [ {<br> \”Action\”: \”sns:*\”,<br> \”Effect\”: \”Allow\”,<br> \”Resource\”: \”$SNS_ARN\”<br> }<br> ]<br>}” &gt; SNS-Role-Inline-Policy.json</blockquote><blockquote>SNS_PUBLISHER_ROLE=”sns_publisher_role”<br>SNS_POLICY_NAME=”sns_publisher_policy”<br>SNS_ROLE_ARN=$(aws iam — region $REGIAO_AWS create-role — role-name $SNS_PUBLISHER_ROLE — assume-role-policy-document file://SNS-Role-Trust-Policy.json — query “Role.Arn” — output text)<br>aws iam — region $REGIAO_AWS put-role-policy — role-name $SNS_PUBLISHER_ROLE — policy-name $SNS_POLICY_NAME — policy-document file://SNS-Role-Inline-Policy.json</blockquote><p><strong>Agora precisamos criar a role e policy que o Lambda irá utilizar.</strong></p><blockquote>echo “{<br> \”Version\”: \”2012–10–17\”,<br> \”Statement\”: [ {<br> \”Sid\”: \”\”,<br> \”Effect\”: \”Allow\”,<br> \”Principal\”: {<br> \”Service\”: \”lambda.amazonaws.com\”<br> },<br> \”Action\”: \”sts:AssumeRole\”<br> } ]<br>}” &gt; LAMBDA-Role-Trust-Policy.json</blockquote><blockquote>echo “{<br> \”Version\”: \”2012–10–17\”,<br> \”Statement\”: [ {<br> \”Effect\”: \”Allow\”,<br> \”Resource\”: \”*\”,<br> \”Action\”: [<br> \”ec2:*\”,<br> \”autoscaling:*\”<br> ]<br> },<br> {<br> \”Action\”: [<br> \”logs:CreateLogGroup\”,<br> \”logs:CreateLogStream\”,<br> \”logs:PutLogEvents\”<br> ],<br> \”Resource\”: \”arn:aws:logs:*:*:*\”,<br> \”Effect\”: \”Allow\”<br> } ]<br>}” &gt; LAMBDA-Role-Inline-Policy.json</blockquote><blockquote>LAMBDA_PUBLISHER_ROLE=”lambda_publisher_role”<br>LAMBDA_POLICY_NAME=”lambda_publisher_policy”<br>LAMBDA_ROLE_ARN=$(aws iam — region $REGIAO_AWS create-role — role-name $LAMBDA_PUBLISHER_ROLE — assume-role-policy-document file://LAMBDA-Role-Trust-Policy.json — query “Role.Arn” — output text)<br>aws iam — region $REGIAO_AWS put-role-policy — role-name $LAMBDA_PUBLISHER_ROLE — policy-name $LAMBDA_POLICY_NAME — policy-document file://LAMBDA-Role-Inline-Policy.json</blockquote><p><strong>Agora precisamos criar a função Lambda responsável pelo snapshot:</strong></p><blockquote>LAMBDA_FUNCION_JS=”LAMBDA_function.js”<br>echo “exports.handler = function(event, context) {<br> <br> var AWS = require(‘aws-sdk’);<br> var ec2 = new AWS.EC2();<br> var as = new AWS.AutoScaling();</blockquote><blockquote>// Log the request<br> console.log(\”INFO: request Recieved.\nDetails\”);<br> var message = JSON.parse(event.Records[0].Sns.Message);<br> <br> //console.log(\”DEBUG: SNS message contents. \nMessage:\n\”);<br> //console.log(\”DEBUG: Extracted Message Data\nData:\n\”);</blockquote><blockquote>// Pull out metadata<br> var instanceId = message.EC2InstanceId;<br> var createImageParams = {<br> InstanceId: instanceId,<br> Name: \”AMI LastSnapshot (\” + instanceId + \”) Time(\” + new Date().getTime() + \”)\”,<br> Description: \”AMI LastSnapshot — \” + instanceId ,<br> NoReboot: true,<br> DryRun: false<br> };<br> ec2.createImage(createImageParams, function(err, data) {<br> if (err) {<br> console.log(\”Failure creating image request for Instance: \” + instanceId);<br> console.log(err, err.stack);<br> }<br> else {<br> var imageId = data.ImageId;<br> console.log(\”Success creating image request for Instance: \” + instanceId + \”. Image: \” + imageId);<br> }<br> });<br> var lifecycleParams = {<br> \”AutoScalingGroupName\” : message.AutoScalingGroupName,<br> \”LifecycleHookName\” : message.LifecycleHookName,<br> \”LifecycleActionToken\” : message.LifecycleActionToken,<br> \”LifecycleActionResult\” : \”CONTINUE\”<br> };<br> console.log(\”Finalizando instancia — \” + lifecycleParams.LifecycleActionToken);<br> completeLifecycleAction(lifecycleParams);<br> function completeLifecycleAction(lifecycleParams, callback) {<br> as.completeLifecycleAction(lifecycleParams, function(err, data){<br> console.log(\”Parametros — \” + lifecycleParams );<br> if (err) {<br> console.log(\”CompleteLifecycleAction lifecycle completion failed.\nDetails:\n\”, err);<br> } else {<br> console.log(\”CompleteLifecycleAction Successful.\nReported:\n\”, data);<br> }<br> });<br> }<br>};” &gt; $LAMBDA_FUNCION_JS</blockquote><blockquote>zip ${LAMBDA_FUNCION_JS}.zip $LAMBDA_FUNCION_JS<br>LAMBDA_FUNCION_NAME=”lambda-sns-function”</blockquote><blockquote>LAMBDA_ARN=$(aws — region $REGIAO_AWS lambda create-function — function-name $LAMBDA_FUNCION_NAME — zip-file fileb://${LAMBDA_FUNCION_JS}.zip — runtime nodejs6.10 — role $LAMBDA_ROLE_ARN — handler ${LAMBDA_FUNCION_NAME}-1–0.handler — timeout 30 | grep FunctionArn | awk -F’”’ ‘{print $4}’)</blockquote><p><strong>Criar subscription no tópico SNS para a função Lambda e dar permissão</strong></p><blockquote>aws sns — region $REGIAO_AWS subscribe — protocol lambda — topic-arn $SNS_ARN — notification-endpoint $LAMBDA_ARN<br>aws lambda — region $REGIAO_AWS add-permission — function-name $LAMBDA_FUNCION_NAME — statement-id 1 — action “lambda:InvokeFunction” — principal sns.amazonaws.com — source-arn $SNS_ARN</blockquote><p><strong>E para finalizar, configurar o <em>Lifecycle Hook</em> das instancias para entrarem em <em>Terminating:Wait</em> antes de ser terminada:</strong></p><blockquote>LC_HOOK_TERMINATING=”lab-lifecycle-hook-end”<br>AS_NAME=”autoscaling_group”<br>REGIAO_AWS=$(curl -s <a href="http://instance-data/latest/dynamic/instance-identity/document">http://instance-data/latest/dynamic/instance-identity/document</a> | grep region | awk -F’”’ ‘{print $4}’)<br>SNS_ROLE_ARN=$(echo $SNS_ROLE_ARN | tr -d ‘\r’)<br>aws — region $REGIAO_AWS autoscaling put-lifecycle-hook — lifecycle-hook-name $LC_HOOK_TERMINATING — auto-scaling-group-name $AS_NAME — notification-target-arn $SNS_ARN — role-arn $SNS_ROLE_ARN — lifecycle-transition autoscaling:EC2_INSTANCE_TERMINATING</blockquote><p>Pronto, com essas configurações, todos as novas instancias entrarão em <em>Pending:Wait</em> e permanecerão até o termino da execução, no boot,do script que está no <em>UserData </em>das instancias, só após ficaram como <em>InService</em>.<br>Enquanto isso, quando uma instancia for ser terminada pelo processo do AutoScaling, a mesma entrará no status de <em>Terminating:Wait</em>, será realizado um ultimo Snapshot da instancia e só depois ela passará para o status de <em>Terminated</em>.</p><p>Resumindo, todo o ciclo de vida esta sendo contemplado nesse exemplo, lembrando que este é apenas um exemplo, podendo ser modificado a ordem,execuções ou funções descritas nesse post sem problemas.</p><p>Espero ter ajudado um pouco com essa experiência.</p><p>Até a próxima.</p><p><em>Originally published at </em><a href="https://medium.com/@wembleycarvalho/auto-scaling-lifecycle-hooks-eaf4e67f6d36"><em>medium.com</em></a><em> on July 19, 2017.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=420211ce2852" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/auto-scaling-lifecycle-hooks-420211ce2852">Auto Scaling Lifecycle Hooks</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fazendo Deploy para AWS com BitBucket]]></title>
            <link>https://medium.com/awsugsp/fazendo-deploy-para-aws-com-bitbucket-b2f4d844573e?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/b2f4d844573e</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[bitbucket]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 01:13:02 GMT</pubDate>
            <atom:updated>2017-08-02T18:11:04.880Z</atom:updated>
            <content:encoded><![CDATA[<p>Final de 2015 a Atlassian anunciou integração com o CodeDeploy da AWS. Porém o post da AWS (<a href="https://aws.amazon.com/blogs/apn/announcing-atlassian-bitbucket-support-for-aws-codedeploy/">https://aws.amazon.com/blogs/apn/announcing-atlassian-bitbucket-support-for-aws-codedeploy/</a>) não é dos mais amigáveis, então resolvi fazer uma passo-a-passo com print dos dois lados.</p><p>Vou assumir, que você já possui uma conta AWS e um BitBucket. Se você está no Free Tier (<a href="https://aws.amazon.com/free/">https://aws.amazon.com/free/</a>) esse artigo não vai gerar custo para você.</p><p>Pronto vamos lá:</p><p>1 . Na conta AWS, criar o Bucket que será usado para o deploy. O BitBucket, vai enviar o código para o Bucket e notificará o CodeDeploy. No nosso caso o nome será <strong><em>bitbucketfranciscoed</em></strong>. Estou criando em Virgínia sem nenhuma configuração adicionar. Next, Next e Finish.</p><p>2 . No BitBucket, ativar a integração com o CodeDeploy, para isso vá na página inicial do seu usuário <a href="https://bitbucket.org/seu_nome_de_usuario.">https://bitbucket.org/seu_nome_de_usuario.</a> Você verá uma página semelhante a abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*EEeqUkncAVyo9U9CkRvQ-Q.png" /></figure><p>Clique em Settings, role a tela e procure a opção <em>Find Integrations</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*v9eKiy6YeUZAnN8Wqbja4A.png" /></figure><p>Escolha <em>AWS CodeDeploy for BitBucket</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Oj-9p6oVP5J8g1v7rQTLvA.png" /></figure><p>Conceda o acesso necessário para a integração:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*M-eUf9t_EQ6XSp5JcuSZrw.png" /></figure><p>3 . Com a integração ativada, vá até o menu <em>Settings</em> do seu repositório e verifique se a integração está habilitada e clique, deixe esta tela aberta pois precisaremos das informações que estão presentes nela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*ZwkIJzaySMzcNct1iZQVlA.png" /></figure><p>4 . De volta a AWS vamos no menu IAM e adicionar uma policy para o BitBucket poder se comunicar com o Bucket e com o CodeDeploy. O BitBucket sugere o seguinte:</p><pre>{<br> &quot;Version&quot;: &quot;2012-10-17&quot;,<br> &quot;Statement&quot;: [{<br> &quot;Effect&quot;: &quot;Allow&quot;,<br> &quot;Action&quot;: [&quot;s3:ListAllMyBuckets&quot;, &quot;s3:PutObject&quot;],<br> &quot;Resource&quot;: &quot;arn:aws:s3:::*&quot;<br> }, {<br> &quot;Effect&quot;: &quot;Allow&quot;,<br> &quot;Action&quot;: [&quot;codedeploy:*&quot;],<br> &quot;Resource&quot;: &quot;*&quot;<br> }]<br>}</pre><p>Para esse artigo isso atende. Porém na sua conta de produção, você deve conceder acesso apenas ao Bucket criado para esse propósito, bem como apenas o acesso necessário ao CodeDeploy.<br>Escolha um nome amigável para a sua policy e salve.</p><p>5 . Agora vamos criar uma role para o BitBucket se conectar na sua conta e poder fazer o deploy. No IAM cria uma role do tipo <strong>Role for cross-account access </strong>e selecione <strong>Provide access between your AWS account and a 3rd party AWS account:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*ufC4T1vWINzPAaI7yJUXxw.png" /></figure><p>6 . Você verá uma tela semelhante a abaixo, preencha com os dados do BitBucket na tela do Item 3, selecione a policy criada no Item 4, coloque um nome amigável e salve:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*PR5953vrQaQ1dt4XD-v6QQ.png" /></figure><p>7 . Após criar a role, acesse-a e copie o arn que terá um formato semelhante a este: arn:aws:iam::111111111111:role/nome_da_role</p><p>8 . Agora precisamos criar a role do CodeDeploy, semelhante ao passo 5, porém é uma Service Role</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*ecZYbqYwRxec9jqPqouxMQ.png" /></figure><p>Por padrão a AWS já nos traz uma policy para essa role, basta selecioná-la. ATENÇÃO: não esqueça de marcar a policy, pois ele deixará você avançar sem policy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*30vrhpcS7-POsqlwroxvag.png" /></figure><p>Finalize a criação e coloque um nome amigável.</p><p>9 . Já que estamos aqui nas Roles, já vamos criar a que será usada para a(s) instância(s) que estarão com o CodeDeploy ativo. Vamos criar uma Service Role (semelhante ao passo anterior) para EC2 e selecionar a policy AmazonS3ReadOnlyAccess. Lembrando que no seu ambiente de produção você deve criar uma policy que libera o acesso, somente ao Bucket que você deseja utilizar.</p><p>10 . Pronto, com as roles criadas, vamos agora criar o CodeDeploy. Caso ao clicar em criar aparecer essa tela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*KL1i-Gm83Hasm_mytzX4mw.png" /></figure><p>Escolha Custom deployment e continue. Na próxima tela, teremos as informações relativas ao seu deploy, algumas merecem atenção. Primeiro a identificação, são campos obrigatórios e depois selecionaremos esse nome no BitBucket:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*-0ncuaXvRD4Pe9o-cP1CuA.png" /></figure><p>Escolha o seu tipo de Deployment</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*RJGZrM0P4NEm56CL7lWtfg.png" /></figure><p>Na configuração do ambiente, você pode escolher um Auto Scaling group, instâncias EC2 ou instâncias on-premises (esse item gera custo). Para o nosso exemplo vamos escolher instância EC2 (criaremos ela mais adiante). Vamos definir algumas tags, assim somente as instâncias que as possuírem receberão o deploy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*oQKi2szmFYlslf2LZNAACg.png" /></figure><p>Escolha a Service Role criada no item 8.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*-Qr1GM7JGxGksjpDH2CKlQ.png" /></figure><p>Opcional: Caso você possua um Load Balancer, poderá selecionar ele. Assim durante o deploy o LB será instruído a não passar tráfego para a instância que está recebendo o deploy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*z5KL4Vg5Z2CqntBs23HZHQ.png" /></figure><p>11 . De volta ao BitBucket, você deve ter parado nesta tela. Cole a arn do passo 7</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*kRDLjIA8yyw06YpgaHRujQ.png" /></figure><p>Escolha a aplicação do CodeDeploy e o Bucket criado e finalize a configuração do BitBucket. Ainda voltaremos nele, mas será para subir arquivos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*DWmB-AwYbomfSpnB4qOO5w.png" /></figure><p>12 . Última etapa da configuração, precisamos criar a nossa instância EC2. Pode criar a instância normalmente, mas alguns itens devem ser observados. Primeiro para a instância poder ter acesso ao bucket S3, você deve habilitar a role criada no item 9.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*IqUL7y-Vn3iPhYRSk9XGsw.png" /></figure><p>Para o nosso teste você deve ter o Apache instalado e o CodeDeploy. Você pode fazer manualmente ou usar um script de bootstrap (ou outra maneira de sua preferência). Caso queira usar um script cole em User data, o script abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*GBuA3UINasdm71ru35wJvg.png" /></figure><pre>#!/bin/bash</pre><pre>#PACOTES LINUX<br>yum -y update<br>yum install -y httpd24 <br>service httpd start<br>chkconfig httpd on</pre><pre>yum install -y ruby<br>cd /home/ec2-user<br>curl -O <a href="https://aws-codedeploy-us-east-1.s3.amazonaws.com/latest/install">https://aws-codedeploy-us-east-1.s3.amazonaws.com/latest/install</a><br>chmod +x ./install<br>./install auto</pre><p>IMPORTANTE: Tags, lembra que definimos que somente servidor com as tags configuradas receberiam os arquivos, agora é a hora de configurá-las:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*YPev4F08jV860mqJqRDCkQ.png" /></figure><p>Termine de lançar a máquina e não esqueça de liberar a porta 80 no Security Group.</p><p>13 . Enquanto a máquina é iniciada adicione um arquivo index.html no seu repositório com o conteúdo que você desejar. E adicione também um arquivo chamado appspec.yml com o conteúdo abaixo:</p><pre>version: 0.0<br>os: linux<br>files:<br> - source: index.html<br> destination: /var/www/html</pre><p>Esse arquivo dá as instruções ao CodeDeploy do que deve ser feito. No nosso exemplo estamos apenas passando as seguintes instruções:</p><pre>version: 0.0 -&gt; Versão do appspec, até o momento só o valor 0.0 é suportado</pre><pre>os: linux -&gt; sistema operacional utilizado</pre><pre>files: -&gt; arquivos que devem ser copiados<br> - source: index.html -&gt; Caminho de origem no BitBucket<br> destination: /var/www/html -&gt; Caminho de destino no servidor</pre><p>Mais informações em: <a href="http://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html">http://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html</a></p><p>14 . Se você acessar o seu servidor deve ver uma tela semelhante a essa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*LHyrSfJXe945KzMyLcGEeg.png" /></figure><p>15 . Para finalizar vá até a sua branch no BitBucket e selecione <em>Deploy to AWS</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*kRX-eo9BU64u6_sYqh-ljA.png" /></figure><p>Aparecerá essa tela, confirme o deploy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*_1Pp6Isaid9Xwxz9JeS5VA.png" /></figure><p>Pronto em alguns instantes o arquivo index.html novo estará no servidor e você poderá acessar o servidor novamente e verificar.</p><p>Espero ter ajudado. Caso tenha alguma dúvida, escreve aqui em baixo. Caso esteja testando, não esqueça de remover os recursos criados.</p><p><em>Originally published at </em><a href="https://medium.com/@franciscoed/6b211412eb7c"><em>medium.com</em></a><em> by </em><a href="https://medium.com/u/5f2b29884f04"><em>Francisco Edilton</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2f4d844573e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/fazendo-deploy-para-aws-com-bitbucket-b2f4d844573e">Fazendo Deploy para AWS com BitBucket</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Logs + Athena + Quicksight]]></title>
            <link>https://medium.com/awsugsp/logs-athena-quicksight-da8de47388e2?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/da8de47388e2</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 01:12:39 GMT</pubDate>
            <atom:updated>2017-08-04T20:28:04.307Z</atom:updated>
            <content:encoded><![CDATA[<p>Não importa se você é dev, ops, sec e outra sigla qualquer. Você precisa extrair informações de logs. <br>Existem diversas ferramentas no mercado que podem te ajudar, você faz a carga dos seus logs e <em>voila </em>diversos gráficos e sugestões podem surgir. Existem algumas mais caras como <a href="https://www.splunk.com/">Splunk</a> e <a href="https://www.sumologic.com/">Sumologic</a>. E outras mais acessíveis como <a href="https://www.loggly.com/">Loggly</a> e <a href="https://logz.io/">Logz.io</a>. Algumas possuem um free tier, mas mesmo assim, se você não estiver disposto a abrir a carteira, você vai ficar muito limitado.</p><p>Pensando nisso, olhei as ferramentas da AWS e pensei como poderia analisar logs rapidamente, gastando pouco e gerando a informação necessária.</p><p>Motivação: Eu tinha o seguinte problema: uma aplicação estava instável e apresentava alguns erros 500 e eu precisava descobrir quem era o “culpado” pelo erros.</p><p>Vamos lá:</p><p>Essa aplicação estava atrás de um Elastic Load Balancer. Então em primeiro lugar, precisamos ativar o Log do ELB.</p><p>Clique no seu Load Balancer e desça até a opção de atributos</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*cerO1Z2g4yrhQ3r8IwXg9A.png" /></figure><p>E ative conforma a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*R-hQb8jFkTjGJe8RfRcTwg.png" /></figure><p>A partir de agora a cada 5 minutos teremos alguns arquivos no bucket escolhido. Você pode direcionar para o mesmo bucket os logs de um ou mais ELB.</p><p>O Athena é um serviço de consulta (baseado no Apache Presto), capaz de acessar arquivos direto do S3 usando SQL padrão. Ele cobra por TB scaneado. Neste caso o volume de dados é pequeno então isso não gera uma preocupação. Caso você tenha um volume grande, considere comprimir os arquivos pois isso vai te gerar uma economia.</p><p>No console vamos ao Athena:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*YnJmFq5RBWwwzSN0_CUpqQ.png" /></figure><p>E podemos criar a nossa tabela de consulta. Para a nossa alegria, existe um tutorial simples que cria exatamente o que precisamos para o ELB</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*RibmgjOSAXRNMBmJ8Bnt4A.png" /></figure><p>Basta seguir o passo a passo, sem criar particionamento. Apenas fique atendo para o passo 3. Escolha o DB, o nome da tabela e a localização do Data Set, que deve ser o mesmo Bucket dos logs do ELB.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Kx3WXJLJM13iCZIK0KKVvQ.png" /></figure><p>Agora no Athena já podemos fazer algumas consultas aos nossos logs:</p><p>Vamos rodar um exemplo, basta clicar em new query e colar o seguinte trecho:</p><pre>SELECT url, count(*) as contador<br>FROM elb_logs<br>WHERE elb_response_code=&#39;500&#39;<br>GROUP BY url<br>ORDER BY contador DESC<br>LIMIT 10;</pre><p>Sua tela ficará assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*98A3HB4KhR5LyLGHqCLDGw.png" /></figure><p>E temos o seguinte resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*o7D0KFap7xqU6yYBeS1RJA.png" /></figure><p>Neste exemplo, já achamos quem é o principal culpado pelos erros 500. E fica fácil começar a resolver.</p><p>Porém a abordagem de consultas SQL não é muito amigável e apresentar um resultado em gráfico normalmente produz um impacto maior.</p><p>A AWS possui uma ferramenta de análise chamada QuickSight, feita para o público de BI e Analytics. Com suporte a diversas fontes de dados, entre elas o Athena, ele vai nos atender bem neste caso.</p><p>O primeiro usuário é FREE para até 1 GB de espaço, no meu exemplo temos mais do que isso. Porém não vou carregar os dados para dentro do QuickSight, o Athena será consultado diretamente. Naturalmente perderemos em performance, mas teremos sempre os dados atualizados para rodar as nossas consultas.</p><p>Clique em New Analysis e posteriormente em new DataSet</p><p>Dentro de um novo DataSet do tipo Athena</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*qJzfGHW0JAX_zp5-seu-kg.png" /></figure><p>Vamos escolher a nossa fonte de dados:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*OrY7XC9MjFYwiLhQ1yGFaQ.png" /></figure><p>Nossa tabela. Aqui já podemos editar os nossos dados, mas não faremos. Isso será feito em uma próxima etapa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*-otf94RgSc6ejQneSMBIyQ.png" /></figure><p>O QuickSight nos dá a opção de importarmos os dados ou consultarmos direto do Athena, que será a nossa escolha</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Xcun8C2iRoxIvsjW_O-z3Q.png" /></figure><p>Pronto, em seguida temos a seguinte tela e podemos começar a trabalhar nosso dados:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*lGDuNCfMyhZD7YDO3QFkPg.png" /></figure><p>1 . Clique uma vez elb_response_code e depois clique (novamente) na seta a direita e seleciona a opção Add filter to this field</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*349C6yMUno9Ot9i-l3bjrw.png" /></figure><p>2 . Na filtragem, desmarque a opção ALL e selecione apenas apenas erro 500</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*MaOo0yAtt2P2zyHh5WGa4w.png" /></figure><p>3 . Aplique e feche.</p><p>4 . Volte para a função Visualize e escolha o gráfico de pizza:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*vH363a_3WFw5CIPpexs39A.png" /></figure><p>5 . Arraste a url para os dois campos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*UiJyIueT9yCZZ4tUWtAkUw.png" /></figure><p>6 . E teremos o seguinte gráfico:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Djq3pcDFRi0HAIg9m61JVQ.png" /></figure><p>Que nos dá uma noção maior ainda, do problema que essa URL está gerando. Entre outras idéias que podemos levantar. Mas o interessante é que isso tudo está sendo consultado em tempo real no S3.</p><p>Ou seja, sempre que o Load Balancer enviar novos logs teremos os dados atualizados.</p><p>Conclusão:</p><p>Gastando pouco é possível gerar muita informação relevante a partir dos seus logs e com um fator interessante, serverless. Ou seja, sem se preocupar com infra, software ou manutenção.</p><p>Tem mais idéias para logs ou dúvidas, escreve aqui em baixo.</p><p><em>Originally published at </em><a href="https://medium.com/@franciscoed/38b8cc280d93"><em>medium.com</em></a><em> by </em><a href="http://twitter.com/francisco">@francisc</a>o<em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da8de47388e2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/logs-athena-quicksight-da8de47388e2">Logs + Athena + Quicksight</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hospedagem de Sites Estáticos Na AWS Com s3, API Gateway e Lambda]]></title>
            <link>https://medium.com/awsugsp/hospedagem-de-sites-est%C3%A1ticos-na-aws-com-s3-api-gateway-e-lambda-ef5ccdcc3311?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/ef5ccdcc3311</guid>
            <category><![CDATA[aws-s3]]></category>
            <category><![CDATA[aws-lambda]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[cloudbr]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 01:12:15 GMT</pubDate>
            <atom:updated>2017-08-10T14:22:17.640Z</atom:updated>
            <content:encoded><![CDATA[<p>Tradicionalmente hospedagem de websites são feitas em servidores que necessitam atenção à escalabilidade e disponibilidade, além dos custos com manutenção. Com o s3 é possível hospedar websites com baixo custo e livre destas preocupações.</p><h3>Introdução</h3><p>A hospedagem de sites corporativos tradicionalmente utiliza um servidor físico ou virtual, dedicado ou compartilhado, e algum software que irá servir os recursos do site. Tanto servidor quanto software são recursos que precisam ser monitorados e atualizados, sem falar no risco de indisponibilidade.</p><p>Para o site corporativo da <a href="https://tdsis.com.br/">TDSiS</a> utilizamos uma abordagem serverless utilizando recursos e serviços da AWS (S3, API Gateway, Lambda) que não precisam de servidores e conseguem com baixo custo ter alta disponibilidade e escalabilidade.</p><h3>Por que usar o s3 para hospedar websites estáticos?</h3><blockquote><em>“</em><a href="https://aws.amazon.com/pt/s3/details"><em>O Amazon s3</em></a><em> armazena dados como objetos dentro de recursos denominados “buckets”. O bucket permite armazenar quantos objetos você quiser, bem como gravar, ler e excluir objetos.”</em></blockquote><p>Porém o uso do s3 pode ir muito além de um simples serviço de storage de objetos. Podemos utilizá-lo para hospedagem de websites estáticos e como integrá-lo com outras ferramentas da AWS como API Gateway e Lambda.</p><p>Utilizando o s3 com esta finalidade é possível obter diversos ganhos e facilidades que não existem ou seriam mais trabalhosos de realizar no modelo tradicional de webhosting:</p><ul><li><a href="https://aws.amazon.com/pt/s3/sla/">Altíssima disponibilidade (99,99% uptime)</a></li><li>Escalabilidade</li><li>Possibilidade de integração com Cloudfront para certificados e cache</li><li>Controle de acesso (autorização de acesso por ips, por exemplo)</li><li>Regras de redirecionamento por objetos</li><li>Réplica entre regiões (redução de latência)</li><li>Versionamento de arquivos</li><li>Pague de acordo com o uso</li></ul><p>Caso o website necessite de algum processamento em back-end, como por exemplo formulário de contato, é possível fazê-lo utilizando API Gateway e Lambda. Nos casos em que as páginas do website são montadas por scripts php (Wordpress e Joomla por exemplo), python ou afins, o uso do s3 para hospedá-lo não é uma opção viável, até porque não são websites estáticos.</p><h3>Hands On</h3><p>Seguindo os passos abaixo, vamos criar um simples bucket hospedando um website estático que contém o arquivo index.html como entry point.</p><ol><li>Acessar a página do S3 no console da AWS</li><li>Clicar em create bucket</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bAmZKfFg2aEPhGBx.png" /></figure><p>3. Na tela de Name and region devemos definir o nome do bucket (nome de bucket é único em toda a AWS) e região. Clicar em next</p><ul><li>Se o website em questão precisar de um CNAME no DNS que aponte para o bucket, o nome do seu bucket deve ser o nome do domínio. Ex.: meu-website.com.br</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/0*8QemZjRPQ79-hakS.png" /></figure><p>4. Em Set properties podemos habilitar o log de ações efetuadas no bucket, versionamento de objetos, e tags. Neste tutorial vamos deixar todas desabilitadas como é padrão. Clicar em next</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/0*_uOwdZpf5Hp_IWVh.png" /></figure><p>5. Em Set permissions vamos definir que esse bucket poderá ter acesso livre de leitura. Para isso devemos escolher a opção Grant read access to this bucket em Manage public permissions. Clicar em next</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/704/0*OF7pmdiZCm58CUYV.png" /></figure><p>6. Em Review não precisamos alterar nada, apenas clicar em Create Bucket.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/0*sFAQSeDTtSojxSDu.png" /></figure><p>7. Agora que já temos um bucket criado com acesso público de leitura. Agora precisamos definir que esse bucket será utilizado para hospedar o website estático. Para isso, ir em Properties e clicar na caixa Static website hosting</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KpOlUegj6dYMtoBb.png" /></figure><p>8. Nesta página podemos definir o arquivo Index (homepage do website), o arquivo da página de erro (caso aconteça algum erro o s3 irá redirecionar o usuário para essa página) e regras de redirecionamento. Para o nosso caso, vamos escolher a opção padrão <em>Use this bucket to host a website</em>, e nas opções definir os valores como a imagem a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GMOXJVmBhJc6XUFE.png" /></figure><p>9. Criar o arquivo index.html localmente no formato abaixo:</p><pre>&lt;html&gt;<br> &lt;head&gt;<br>  &lt;title&gt;Meu Website&lt;/title&gt;<br> &lt;/head&gt;<br> &lt;body&gt;<br>  &lt;h1&gt;Hello AWS!&lt;/h1&gt;<br> &lt;/body&gt;<br> &lt;script type=&quot;text/javascript&quot;&gt;<br>  alert(&quot;javascript works!&quot;);<br> &lt;/script&gt;<br>&lt;/html&gt;</pre><p>10. Para enviar o index.html para o s3, clicar em upload</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/534/0*XkdQ92mV_R0jUM-h.png" /></figure><p>11. Escolher o arquivo index.html e clicar em Next</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/564/0*eNXc5aowtoBsYh6B.png" /></figure><p>12. Em Select files precisamos informar que esse arquivo tem permissão pública de leitura. Para isso escolhemos a opção <em>Grant public read access to this object(s)</em> em Manage public permissions. Clicar em upload.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/560/0*rAnQ_HR9AfrKkGZC.png" /></figure><p>13. Agora basta entrar em meu-website.s3-website-us-east-1.amazonaws.com.</p><p>Para simular os custos com hospedagem estática no S3, vamos utilizar a <a href="http://calculator.s3.amazonaws.com/index.html">calculadora</a> fornecida pela AWS. Utilizaremos como base um site que gera 10 mil GETs e 3 gigabytes de transferência por mês. De acordo com a calculadora o gasto seria em média de U$$ 0.22. Perceba que a cobrança pesa mais na quantidade de dados transferidos para fora da AWS. Então, quando criar o website estático, estimar bem a quantidade de dados que serão trafegados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/486/0*BtX0iNwsEBHiXjFO.png" /></figure><p>Utilizando uma máquina na DigitalOcean ou com o AWS Lightsail, o gasto seria de no mínimo U$$ 5.00 mensais. Com uma máquina EC2 o gasto seria de U$$ 4.00 à U$$ 8.00 para máquinas nano, micro ou small</p><p>Vimos a simplicidade de usar o s3 para hospedar um website estático, porém na maioria das vezes precisamos de algum processamento que somente com javascript e html não é possível. Um exemplo seria fornecer aos visitantes do website um formulário de contato. Vamos construir uma função de back-end, que recebe o formulário de contato utilizando Lambda e API Gateway.</p><h3>API Gateway</h3><blockquote><em>“</em><a href="https://aws.amazon.com/pt/api-gateway/"><em>O Amazon API Gateway</em></a><em> é um serviço totalmente gerenciado que permite que desenvolvedores criem, publiquem, mantenham, monitorem e protejam APIs em qualquer escala.”</em></blockquote><p>Puramente, o API Gateway expõe uma interface de serviços, atuando como ponte entre o serviço e seu destino (Lambda, chamada HTTP, Mocks, etc).</p><h3>Lambda</h3><blockquote><a href="https://aws.amazon.com/pt/lambda/"><em>“Execute códigos sem pensar sobre os servidores.”</em></a></blockquote><p>O AWS Lambda permite a execução de códigos em algumas linguagens sem precisar se preocupar com máquinas, provisionamento e disponibilidade.</p><h3>Continuando o Hands On</h3><p>Inicialmente vamos criar uma função Lambda em NodeJS que irá receber um formulário de contato (por simplicidade não vamos fazer o Lambda enviar emails, mas é possível usando SNS). Caso não esteja confortável com NodeJS, o AWS Lambda dá suporte para Java, C# e Python.</p><ol><li>No console da AWS clicar em Lambda, e no console do Lambda clicar em New Function (caso você não tenha nenhuma função, a AWS já abrirá o guia para criação)</li><li>Em blueprint selecionaremos a opção Blank Function</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/0*3TX_pHSHdYp5ua6A.png" /></figure><p>3. Em Configure triggers apenas clicar em Next</p><p>4. Em Configure function, vamos nomear a função, e criar as roles. Clicar em Next</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*p5YepS9bNAADCons.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pG-zW--M-wChW3Xs.png" /></figure><p>5. Em Review apenas clicar em Create Function.</p><p>6. Agora, vamos editar o código. Por ser em NodeJS, a AWS permite edição no próprio console. Clicar em Save após edição do código</p><ul><li>O código apenas imprime os parâmetros que o API Gateway enviará ao Lambda, e retorna status code 200 ou 400, com uma mensagem de sucesso ou erro.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/0*giZ1Ts-ipJTYvgnJ.png" /></figure><pre>exports.handler = (event, context, callback) =&gt; {<br>    let body = JSON.parse(event.body);<br>    let from = body.from;<br>    let subject = body.subject;<br>    let message = body.message;<br>    console.log(`Mensagem de ${from}`);<br>    console.log(`Assunto: ${subject}`);<br>    console.log(`Mensagem: ${message}`);<br>    let response = {};<br>    if(message &amp;&amp; message.length &gt; 0){<br>        response = {<br>            &quot;headers&quot;: {&quot;Access-Control-Allow-Origin&quot;: &quot;*&quot;},<br>            &quot;body&quot;: JSON.stringify({&quot;resultado&quot;: &quot;Mensagem enviada com sucesso&quot;}),<br>            &quot;statusCode&quot;: 200<br>        }<br>    }else{<br>        response = {<br>            &quot;headers&quot;: {&quot;Access-Control-Allow-Origin&quot;: &quot;*&quot;},<br>            &quot;body&quot;: JSON.stringify({&quot;resultado&quot;: &quot;Por favor, escreva sua mensagem&quot;}),<br>            &quot;statusCode&quot;: 400<br>        }<br>    }<br>    callback(null, response);<br>};</pre><p>7. Agora criaremos o endpoint para envio do formulário. Basta acessar o API Gateway. Clicar em Create API</p><p>8. Em Create new API configurar conforme imagem abaixo. Clicar em Create API</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/0*1VFkE9w32W9siYUW.png" /></figure><p>9. Em MinhaAPI, criaremos o Resource <em>/formulario</em>. Basta clicar em Actions &gt; Create Resource. Também precisamos habilitar o CORS, para aceitar nossas chamadas via javascript.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/0*7pu1HBhIPx6Fol3e.png" /></figure><p>10. Também criaremos o método POST para o resource <em>/formulario</em>. Ir em Actions &gt; Create Method. Clicar em save</p><ul><li>No Integration type escolhemos a opção Lambda Function</li><li>Deixamos a opção Use Lambda Proxy integration marcada. Assim o API Gateway irá redirecionar todo o contexto de Request para o Lambda</li><li>No Lambda Funcion escolhemos a função que foi criada anteriormente</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/699/0*QSdhIqmOOudwGrF0.png" /></figure><p>11. Habilitar o CORS em Action &gt; Enable CORS</p><p>12. Enfim, faremos o deploy da API, clicando em Action &gt; Deploy API. Vamos chamar a stage de v1. Após o Deploy, você poderá ver a url que a AWS criou para a API.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/618/0*0Pvm4UGrmyVCOb2X.png" /></figure><p>Agora o API Gateway Já está integrado com o Lambda. Quando um client chamar o POST <a href="https://{endereco-api}/formulario"><em>https://</em><strong><em>{endereco-api}</em></strong><em>/formulario</em></a> o API Gateway fará a ponte entre o Lambda e o client.</p><p>Por último, vamos criar o formulário que chamará a API e subir para o S3, como foi feito anteriormente. O index.html ficará assim:</p><pre>&lt;html&gt;<br>&lt;head&gt;<br> &lt;title&gt;Meu Website&lt;/title&gt;<br> &lt;script src=”<a href="http://code.jquery.com/jquery-3.2.1.min.js">http://code.jquery.com/jquery-3.2.1.min.js</a>&quot;&gt;&lt;/script&gt;<br>&lt;/head&gt;<br>&lt;body&gt;<br> &lt;h1&gt;Hello AWS!&lt;/h1&gt;<br> &lt;form id=”contactForm” action=”#” method=”post”&gt;<br> &lt;div&gt;<br> &lt;label for=”from”&gt;Seu nome:&lt;/label&gt;<br> &lt;input type=”text” name=”from” value=””&gt;<br> &lt;/div&gt;<br> &lt;div&gt;<br> &lt;label for=”subject”&gt;Assunto:&lt;/label&gt;<br> &lt;input type=”text” name=”subject” value=””&gt;<br> &lt;/div&gt;<br> &lt;div&gt;<br> &lt;label for=”message”&gt;Mensagem:&lt;/label&gt;<br> &lt;textarea name=”message” rows=”8&quot; cols=”80&quot;&gt;&lt;/textarea&gt;<br> &lt;/div&gt;<br> &lt;button type=”submit” name=”button”&gt;Enviar&lt;/button&gt;<br> &lt;/form&gt;<br> &lt;div id=”formResult”&gt;<br> &lt;/div&gt;<br>&lt;/body&gt;<br>&lt;script type=”text/javascript”&gt;<br> $(‘#contactForm’).submit(function(event) {<br> event.preventDefault();<br> var url = ‘<a href="https://suaapi.execute-api.us-east-1.amazonaws.com/v1/formulario&#39;">https://suaapi.execute-api.us-east-1.amazonaws.com/v1/formulario&#39;</a>;<br> var formData = $(this);<br> var from = formData.find(‘input[name=from]’).val();<br> var subject = formData.find(‘input[name=subject]’).val();<br> var message = formData.find(‘textarea[name=message]’).val();<br> var request = {<br> from: from,<br> subject: subject,<br> message: message<br> }<br> $.ajax({<br> type: “POST”,<br> url: url,<br> data: JSON.stringify(request),<br> headers: {<br> ‘Content-Type’:’application/json’<br> },<br> success: function(response){<br> $(‘#formResult’).html(response.resultado);<br> },<br> error: function(err){<br> var response = JSON.parse(err.responseText);<br> $(‘#formResult’).html(response.resultado);<br> }<br> });<br> });<br>&lt;/script&gt;<br>&lt;/html&gt;</pre><p>Como resultado final a página web chama o POST <em>/formulario</em> e o API Gateway invoca o Lambda que processa o formulário. Podemos observar os efeitos nas imagens abaixo</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/0*gRtKdjDpkF9mq-nT.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/899/0*VLts72Rw4e56GWsy.png" /></figure><p>O uso do Lambda é cobrado por tempo de execução, em lotes de 100ms. Ou seja, se a execução durar 180 milissegundos, esta será taxada como 200 milissegundos. A AWS fornece um free tier mensal de para o Lambda de 1 milhão de execuções (considerando 100 milissegundos com 384 MegaBytes de memória alocada.</p><p>Com auxílio da calculadora da AWS, o custo de 10 mil execuções com duração de 300 milissegundos e 256 MegaBytes de memória fica dentro do free tier (não expira após 12 meses).</p><p>O API Gateway tem custo de U$$ 3.50 por milhão de chamadas e mais a transferência de dados. Para 10 mil chamadas, e um 1 GigaBytes de transferência, o custo total seria de U$$ 3.59 mensais.</p><h3>Total de custos:</h3><p>Recurso Preço (U$$) s3 0.22 Api Gateway 3.59 Lambda 0.00 <strong>Total</strong> <strong>3.81</strong></p><p>Os custos do S3, com o API Gateway e o Lambda somam um total de U$$ 3.81, o que ainda é mais barato do que uma máquina no LightSail ou na DigitalOcean, ou até mesmo uma EC2 nano.</p><h3>Conclusão:</h3><p>Utilizando o S3 conseguimos facilmente e com baixo custo hospedar um website estático, livre da preocupação com máquinas, provisionamento, disponibilidade e manutenção.</p><p>Além do baixo custo, da garantia de disponibilidade, e da facilidade de manutenção, existem outras vantagens, por exemplo: é possível expandir funcionalidades do website utilizando funções Lambda e API Gateway; com o Cloudfront gerenciar certificados ssl, controlar cache de arquivos, etc; controlar acessos com simples configurações no S3 e versionar arquivos.</p><p>A abordagem serverless oferece inúmeras ferramentas que simplificam e tratam muitas preocupações que temos seguindo os modelos tradicionais, mas também apresentam novos desafios quando utilizamos esta abordagem, e devemos saber orquestrar muito bem as ferramentas para obter o máximo de aproveitamento.</p><p>Escrito por: Filipe Santana</p><p><em>Originally published at </em><a href="https://blog.tds.is/dev/hospedagem-website-com-s3.html"><em>blog.tds.is</em></a><em> on August 8, 2017.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef5ccdcc3311" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/hospedagem-de-sites-est%C3%A1ticos-na-aws-com-s3-api-gateway-e-lambda-ef5ccdcc3311">Hospedagem de Sites Estáticos Na AWS Com s3, API Gateway e Lambda</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Portainer — Orquestrando containers em um Cluster Docker Swarm]]></title>
            <link>https://medium.com/awsugsp/portainer-orquestrando-containers-em-um-cluster-docker-swarm-3ab32ee68152?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/3ab32ee68152</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[swarm]]></category>
            <category><![CDATA[cloudbr]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 01:11:01 GMT</pubDate>
            <atom:updated>2017-08-16T16:36:30.350Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/410/1*0vqvZFJ2MWvSDEMMUcFnNw.png" /></figure><p>Assim como hosts de virtualização baseados em tecnologias como Linux KVM, VMWare vSphere, Microsoft Hyper-V, etc, hosts que hospedam containers também demandam ambientes que ofereçam alta disponibilidade, afinal, a grande densidade que servidores apresentam nos dias atuais, com dezenas de máquinas virtuais em média em cada host, e de centenas as milhares de containers em média certamente leva a necessidade da implantação de Clusters Fail Over.</p><p>Cluster não só dão a possibilidade fazer com que estes hosts atuem de forma conjunta e coordenada, como proveem recursos de alta disponibilidade e balanceamento de carga.</p><p>Este artigo irá demonstrar que o processo de escalabilidade dentro do ambiente de cluster sob Docker Swarm é muito simples, bem como, a alta disponibilidade de containers também será proporcionada neste mesmo ambiente.</p><p>No final deste artigo veremos também a instalação, configuração e operações básica sob a ferramenta de orquestração<strong> Portainer, </strong>ferramenta essa que permitirá realizar diversas operações em nosso Cluster através de uma interface web muito intuitiva, com dashboards bem elaborados e com baixo consumo de recurso sob o host que estiver sendo executada.</p><p>Resumidamente, neste artigo estaremos:</p><ul><li>Instalando e configurando o Docker em três hosts com Debian 9;</li><li>Configurando um Cluster com Docker SWARM;</li><li>Criando um serviço que utilizará uma imagem do Apache e operará sob o cluster Docker;</li><li>Testando o mecanismo de load balance;</li><li>Realizar a escalação de instâncias do container do Apache;</li><li>Ativando um instância como serviço da solução de orquestração <strong>Portainer</strong>;</li><li>Realizando operações básicas sob a interface Web do Portainer.</li><li>Configurando autenticação para o portal do orquestrador Portainer</li></ul><p><strong>Iremos denominar cada um dos três hosts que irão compor o Cluster de:</strong></p><ul><li>containerhost01–192.168.1.11</li><li>containerhost02–192.168.1.12</li><li>containerhost03–192.168.1.13</li></ul><p><strong>Instalando e configurando o Docker em três hosts com Debian 9</strong></p><p>Os passos a seguir deverão ser executados nos três servidores:</p><p><strong>– Instale os pacotes que serão dependências no restante do processo de instalação do Docker Engine:</strong></p><pre><em>sudo apt install -y curl apt-transport-https \ software-properties-common ca-certificates</em></pre><p><strong>– Adicione a chave do repositório:</strong></p><pre><em>curl -fsSL </em><a href="https://yum.dockerproject.org/gpg"><em>https://yum.dockerproject.org/gpg</em></a><em> | sudo apt-key add –</em></pre><p><strong>– Adicione o repositório ao sistema:</strong></p><pre><em>sudo add-apt-repository “deb </em><a href="https://apt.dockerproject.org/repo/"><em>https://apt.dockerproject.org/repo/</em></a><em> \ debian-$(lsb_release -cs) \ testing”</em></pre><p><strong>– Atualize o banco de dados de referência de pacotes do sistema:</strong></p><pre><em>sudo apt-get update -y</em></pre><p><strong>– Instale o pacote do Docker Engine:</strong></p><pre><em>sudo apt-get install -y docker-engine</em></pre><p><strong>– Execute os daemons do Docker e ative o serviço na inicialização do sistema:</strong></p><pre><em>sudo systemctl start docker<br>sudo systemctl enable docker</em></pre><p><strong>– Adicione o atual usuário logado no grupo de usuário Docker. Essa ação fará com que não seja necessária a utilização do comando sudo para utilização docker.</strong></p><pre><em>sudo gpasswd -a “${USER}” docker</em></pre><p><strong>– Reinicie o sistema para testar a inicialização do serviço do Docker:</strong></p><pre><em>sudo reboot</em></pre><p><strong>– Liste os containers criados (em execução e não em execução):</strong></p><pre><em>docker ps -a</em></pre><p>Obviamente a listagem não retornará nada pois não existem container criados.</p><p><strong>Configurando um Cluster com Docker SWARM</strong></p><p>Docker swarm é um gerenciador e orquestrador de cluster Docker, possibilitando que você tenha de ter vários Docker engines (hosts com Docker Engine em execução) atuando de forma conjunta para servir os contêineres com alta disponibilidade e escalabilidade.</p><p>O Docker Swarm realizar balanceamento de carga, descoberta automática de novos serviços, escalar o ambiente em momento de alta demanda e resolver automaticamente caso de falhas em serviços em contêineres.</p><p>Em uma configuração básica, você inicializa seus container utilizando o comando docker run (que automaticamente faz o pull da imagem em servidor de repositório de imagens (denominado registry), cria o container e dispara a execução deste container).</p><p>Quando estamos utilizando uma configuração de Cluster através do Docker Swarm a execução dos containers utilizará a abordagem denominada serviços.</p><p>Um Cluster Docker Swarm possui dois tipos de elementos: Manager e Worker.</p><p>Um nó é uma instância de um Docker Engine em execução em um host que esteja participando do cluster Swarm.</p><p>Iniciado um serviço de container no cluster swarm, torna-se necessária a definição de um serviço para um nó do tipo manager.</p><p>Quando um nó é definido como manager, este torna-se responsável por disparar unidades de trabalho denominadas tasks (tarefas).</p><p>Portanto o sysadmin irá definir e solicitar novas tarefas a partir de um dos nós que atue como manager no cluster, e esta tarefas são disparadas para nós do tipo worker, mas dependendo da carga atual do Cluster, nós do tipo manager também executarão tarefas solicitadas.</p><p>Nós do tipo manager possuem a responsabilidade da orquestração e gerenciamento do cluster, onde caso exista mais de um manager no cluster, ocorrerá um processo de eleição que selecionará automaticamente o líder manager que conduzirá as orquestração das tarefas. Este processo é semelhante ao que temos em redes Microsoft baseadas nos protocolos SMB/CIFS, onde um local browser e master browser são eleitos para por exemplo, armazenar a lista de hosts e recursos da rede para que esta seja utilizada no processo de resolução.</p><p><strong>Definindo o nó manager no Cluster Swarm</strong></p><p>Neste artigo teremos 3 nós, sendo 1 manager e dois workers, portanto, execute o comando a seguir no <strong>containerhost01</strong></p><pre><em>docker swarm init –advertise-addr 192.168.1.11:2377</em></pre><p>Será exibida a informação na primeira linha que Docker Engine deste host passou a atuar no modo swarm, especificamente como modo manager.</p><p>Foi exibido o comando docker swarm join associado ao token gerado e o endereço IP do manager, por exemplo:</p><p><em>docker swarm join \</em></p><p><em>–token SWMTKN-1–41eozb4h6ucm58pwv6zxvllhggniv6kbo92hyyhja9z07whmtb-62q0t8pc373ff576xlbxp8bjj \</em></p><p><em>192.168.1.10:2377</em></p><p>Deste modo, copie e cole o comando exibido no shell do containerhost01 nos outros dois hosts (containerhost01 e containerhost02).</p><p>Após a execução do comando docker swarm join, em ambos os nós deverá ser exibida a frase:</p><p><em>This node joined a swarm as a worker.</em></p><p><strong>Criando uma rede para utilização no serviço que será implementado no Cluster</strong></p><p>A criação de uma rede para utilização no serviço que implantaremos no Cluster é importante, pois através desta rede conseguiremos disponibilizar a funcionalidade de balanceamento de carga, sem necessitar configurar um balanceador externo, por exemplo, baseado no NGINX ou HAProxy.</p><p>Através desta rede será interligado os serviços que irão operar no ambiente do Cluster.</p><p>Existem diversas possibilidade de criar redes no Docker, e no caso, utilizaremos um tipo de rede chamada overlay, onde é possível anexar vários serviços de contêineres na mesma rede.</p><p>Por padrão, o serviço de descoberta interno do swarm entrega um endereço IP (VIP) e uma entrada DNS (também por um serviço interno) para cada contêiner na mesma rede.</p><p>Para utilizar redes overlay no seu cluster é necessário que cada nó do swarm tenha regras no Firewall autorizando a conectividade nas portas 7946 e 4789 (ambas nos protocolos TCP e UDP).</p><p>Informe o comando abaixo no host containerhost01 para criar a rede com o nome de ClusterNet e em seguida listar as atuais redes criadas para confirma a existência da nova rede:</p><pre><em>docker network create -d overlay –subnet 10.0.10.0/24 ClusterNet<br>docker network ls</em></pre><p>Execute o comando <em>docker network ls</em> nos outros dois hosts (containerhost02 e containerhost03) e veja que as redes não foram criadas nos nós, pois comente no momento do criação do serviço do Cluster que utilizará esta rede para dispararmos as tarefas, é que a rede será criada. No caso, entende-se tarefa como a inicialização de um ou mais container nos hosts (nós) do Cluster.</p><p><strong>Criando um serviço que utilizará uma imagem do Apache e operará sob o cluster Docker</strong></p><p>As instâncias que iremos inicializar neste novo serviço são de um Web Server baseado no Apache. Entretanto, ao invés de realizarmos o pull de uma imagem oficial do projeto Apache, iremos utilizar uma imagem que foi adaptada para que a página padrão do Apache mostre o ID do container.</p><p>Deste modo, durante os testes de load balance poderemos ver que a página exibida no momento da conexão está em execução em um determinado container (alocado sobre um determinado nó do Cluster), isso graças a exposição do container ID na página padrão do Apache.</p><pre><em>docker service create –name webservice1 –network ClusterNet –replicas 3 -p 5001:80 francois/apache-hostname<br>docker service ls</em></pre><p>O primeiro comando acima criou uma serviço no Cluster chamado<strong> webservice1 </strong>utilizando a rede do tipo overlay chamada ClusterNet (criada anteriormente). Este serviço inicializou três réplicas de um container baseado na imagem francois/apache-hostname, bem como, foi estabelecido um mapeamento da porta TCP 5001 (em listening em cada nó do Cluster) para a porta 80 (em listening em cada container alocado no Cluster, no caso, 3 réplicas).</p><p>Se realizarmos uma conexão na porta 5001 do nós 192.168.1.10, 192.168.1.11 e 192.168.1.12 o docker engine já realizou os redirecionamento para a rede overlay, o que permitirá que, independente de qual host (nós) seja estabelecida a conexão, a conexão com a porta 80 do Apache em execução em cada container será direcionada de forma balanceada.</p><p>O segundo comando (<em>docker service ls</em>) permitiu verificar que o serviço foi criado.</p><p>Execute nos três nós o comando:</p><pre><em>docker ps</em></pre><p>Será possível observar que no total existirão três containers (réplicas) em execução, o que bem provavelmente ocorrerá de forma balanceada, ou seja, um container em execução em cada nó.</p><p><strong>Testando o mecanismo de load balance</strong></p><p>Em um outro terminal Linux ou Mac OS X que não seja dos hosts (nós), iremos criar um BASH Shell Script muito simples que irá ficar testando o balanceamento de carga durante a conexão em nosso três nós, onde será possível observar que a medida que alternamos a conexão entre os três nós, o Container ID exibida na página do Apache indicará o container que atendendo nosso conexão no momento.</p><p>Caso não tenha a ferramenta curl instale ela pois será utilizada no script abaixo.</p><p><strong>Crie um arquivo chamado testLB.sh da seguinte forma:</strong></p><pre><em>cat &lt;&lt; EOF &gt; testLB.sh</em></pre><pre><em>#!/bin/sh<br> hosts=”192.168.1.10 192.168.1.11 192.168.1.12″<br> nHosts=`echo $hosts |wc -w`<br> i=1<br> clear<br> while [ 1 ]; do<br> if [ $i -eq 4 ]; then<br> i=1 fi h=`echo $hosts |cut -f$i -d” “` echo “Web Server: $h”</em></pre><pre><em>curl –connect-timeout 3 </em><a href="http://:5001/$h"><em>http://$h:5001</em></a></pre><pre><em>sleep 3 clear ((i++))</em></pre><pre><em>done<br>EOF</em></pre><p><strong>Atribua a permissão de execução ao script e execute-o:</strong></p><pre><em>chmod +x testLB.sh<br>./testLB.sh</em></pre><p>Poderemos ir acompanhando as conexões em cada Web Server em execução em cada container, bem como, verificar que o balanceamento de carga estará sendo realizado.</p><p><strong>Realizar a escalação de instâncias do container do Apache</strong></p><p>Este sem dúvidas é um recursos mais interessantes, pois com ele, podemos escalar rapidamente mais ou menos instâncias em nosso Cluster com grande facilidade, inclusive, veremos que através da ferramenta Portainer poderemos realizar isso de forma totalmente gráfica.</p><p>Execute no nó manager do Cluster (containerhost01) os comandos:</p><pre><em>docker service scale webservice1=10 docker service ps</em></pre><p>O primeiro está realizando a mudança do número de réplicas para 10 no serviço chamado web (que representa dentro do Cluster Swarm os containers Apache em execução em cada nó). Lembrando que, quando criamos o serviço ele possuía 3 instâncias.</p><p>O segundo comando mostra o atual status dos serviços em execução, e também permite acompanhar quantas réplicas estão definidas para o serviço e quantas já estão em execução. Portanto, se o segundo comando mostrar 8/10, significa que o serviço possui definida 10 instâncias para entrar em execução de forma distribuída no Cluster, mas que até o momento somente 8 estão em execução, demonstrando assim que 2 tasks (tarefas) enviadas pelo manager para o nós do Cluster ainda estão em andamento.</p><p><strong>Execute nos três nós o comando:</strong></p><pre><em>docker ps</em></pre><p>Será possível observar que no total existirão dez containers (réplicas) em execução de forma balanceada, podendo por exemplo, ter 4 containers em um nó, 3 container em outro e mais 3 container em outro nó.</p><p><strong>Execute no nó manager do Cluster (containerhost01) os comandos:</strong></p><pre><em>docker service scale webservice1=6<br>docker service ps</em></pre><p>Assim estaremos escalando o serviço para 6 instâncias, tornando assim a distribuição possivelmente de 2 containers por nó.<br> É possível definir restrições (constraints) diversas nos serviços de Cluster, podendo por exemplo, iniciar uma instância em particular somente em hosts (nós) com discos SSD, tudo isso de forma automática.</p><p><strong>Ativando um instância como serviço da solução de orquestração Portainer</strong></p><p>Independente de estarmos inicializando uma instância (container) da imagem portainer como serviço, um aspecto importante para uso de container ou serviço de containers é a persistência de dados.</p><p>Iremos criar um diretório que irá armazenar os dados do container, de modo, que quando o container for finalizado e iniciar novamente, o orquestrador portainer possa ler os dados da configurações já realizadas.</p><p><strong>Crie um diretório para persistência dos dados:</strong></p><pre><em>mkdir -p /data/orquestrador</em></pre><p><strong>Criando</strong> <strong>um serviço para utilizar o orquestrador container</strong></p><p>A grande vantagem de inicializar um container utilizando o recurso serviço do Docker Swarm é que podemos contar com a alta disponibilidade do container, deste modo, supondo que tenhamos um Cluster de 6 nós, sendo que 3 deles atuam no modo manager. Deste modo, caso um nó que atua no modo manager fique indisponível, o Docker Swarm irá alocar outro container em um dos outros dois nós que estão em modo manager.</p><p>Para que o Docker Swarm possa alocar um container no Cluster, e tal alocação ocorra apenas em nós que são manager no Cluster, iremos utilizar um recurso de constraint, que permitirá definir tal regra.</p><p><strong>Execute o comando abaixo no nó manager (containerhost01):</strong></p><pre><em>docker service create –name orquestrador -p 9000:9000 –constraint ‘node.role == manager’ –mount type=bind,src=/data/orquestrador,dst=/data –mount type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock portainer/portainer –no-auth -H unix:///var/run/docker.sock</em></pre><p>O serviço criado tem o nome orquestrador, bem como, o host manager na qual o container for iniciado irá publicar (expor a porta 9000), de modo que, toda conexão na porta 9000 do host será redirecionada para porta 9000 em listening no container.</p><p>O parâmetro –constraint informa que o container somente será iniciado caso o atributo role possua o valor manager, o que justamente faz com o que a instância do container inicie apenas em nós do tipo manager no Cluster.</p><p>O parâmetro <em>–mount type=bind,src=/data/orquestrador,dst=/data</em> fará com que o diretório local (existente no nó manager ond e o container será iniciado) seja montado (mapeado) no diretório /data dentro do container, permitindo assim que todos os dados gravados ou lidos no diretório /data do container na verdade são dados existentes no diretório /data/orquestrador. Deste modo, o container terá persistência dos dados no momento que ele for finalizado.</p><p>O parâmetro –no-auth é particular dos binários do container portainer, e faz com que o orquestrador não exija usuário e senha em uma primeira execução, o que é interessante para apenas começarmos a explorar um pouco a ferramenta, mas iremos no final do artigo configurar a autenticação no orquestrador.</p><p>O parâmetro -H faz com que o Orquestrador consiga estabelecer uma conexão não TCP/IP (via unix sockets) com o host manager que o container estiver sendo executado, pois assim, o Portainer conseguirá comunicar-se com a API do Docker sem utilizar conexões TCP/IP.</p><p>Entretanto é possível realizarmos conexões a outros hosts com Docker Engine, onde precisaremos configurar o serviço nestes hosts para expor a API serviço. Assim o Portainer poderá ter outros endpoints adicionados para que sejam gerenciados também, mas isso é um assunto para outro artigo.</p><p><strong>Para verificar se o serviço iniciou, e para isso, o container deve ter entrado em execução, informe o comando a seguir:</strong></p><pre><em>docker service logs orquestrador</em></pre><p>Deverá ser exibida a informação a seguir:</p><p><em>Starting Portainer on :9000</em></p><p><strong>Verifique no nó manager que o serviço está em execução, bem como, que o container está em execução no mesmo nó:</strong></p><pre><em>docker service ls<br>docker ps</em></pre><p><strong>Acesse o endereço a seguir:</strong></p><blockquote><a href="http://192.168.1.11:9000/"><em>http://192.168.1.11:9000</em></a></blockquote><p>A imagem a seguir mostra um Dashboard com boa organização e informações muito úteis do nó manager.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/0*ByPYM6ZtzrXkQkQs." /></figure><p>Na seção container temos os dois containers referente ao Apache, que foram iniciados neste nó devido o serviço que foi criado (webservice1) ter sido escalado para 6 instâncias. Juntamente destes dois containers temos o container referente ao orquestrador container</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/0*44Idg6UhrNlThla5." /></figure><p>A imagem abaixo expõem de forma clara que o Cluster possui um nó com papel de Manager e outros dois com papel de worker.</p><p>Observação: esta imagem foi capturada de um dos labs que realizei, onde os nós estão com endereço IP diferente do apresentado no escopo inicial do artigo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/0*mPwF6-VTTBkDmVBb." /></figure><p>Realizando operações básicas sobre containers</p><p>Na seção containers, clique no nome de um dos dois containers como começam com web</p><p>O Portainer permite realizar diversas operações em sua interface web, operações como por exemplo:<br> Iniciar, Parar, Finalizar de maneira forçada, etc.</p><p>Além destas operações visíveis na imagem abaixo, podemos obter métricas de monitoramento referente ao consumo de CPU, Memória, etc e claro, abrir um console diretamente no container (equivalente ao comando: <strong>docker attach nome_do_container</strong>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/0*IdSWOMMZo-RdHpnS." /></figure><p><strong>Verificando o consumo de CPU, Memória, Rede e Processos em Execução no Container</strong></p><p>Clique na opção Stats</p><p>Esta opção apresenta um excelente dashboard com gráficos bem elaborados indicando informações referente ao consumo de CPU, Memória, Rede e os processos em execução no container.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/908/0*w8tTXsWUrjkBV-XA." /></figure><p><strong>Estabelecendo um terminal com o container em execução</strong></p><p>Volte para a página anterior e clique na opção <strong>Console</strong>, e em seguida no botão <strong>Connect</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/906/0*lQBpkKXS3Cajeqhc." /></figure><p>A imagem abaixo demonstra um recurso muito interessante que traz praticidade para estabelecer um terminal com o container.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/0*qy_W_igMcCe791OG." /></figure><p>No terminal estabelecido com o container podemos por exemplo, podemos verificar a comunicação entre os containers.</p><p>Como cada serviço recebe um nome próprio e cada container das réplicas recebe um endereço IP específico, por exemplo, criamos um serviço chamado webservice1, portanto, se eu executar o comando a seguir quatro vezes:</p><pre><em>ping tasks.webservice1 -c 1</em></pre><p>Teremos a resolução de nomes retornando em cada momento o endereço IP e FQDN de cada container dentro deste serviço.</p><p>A image que estamos utilizando em nosso serviço webservice1 não possui a ferramenta dig e nslookup, mas caso tivessem, poderíamos utilizar o comando para obter todos os endereços IP e FQDNS atrelados ao service, graças ao serviço interno de DNS que durante o estabelecimento do serviço sob a rede overlay (que torna transparente a comunicação de cada container independente do nó que esteja), o processo de mapeamento DNS no Docker Swarm é realizado automaticamente.</p><pre><em>nslookup tasks.webservice1</em></pre><p><strong>Configurando autenticação para o portal do orquestrador Portainer</strong></p><p>Iremos remover o serviço que inicializa o container do orquestrador no Cluster, e recriaremos ele com novo parâmetro (–admin-password).</p><p><strong>Portanto, remova o serviço orquestrador:</strong></p><pre><em>docker service rm orquestrador</em></pre><p>Isso obviamente fará com o que o container em execução no nó containerhost01 seja finalizado.</p><p>Como provavelmente os seus nós utilizam alguma distribuição minimalista, então certamente a ferramenta htpasswd não está instalada.</p><p>Para evitar de instalar pacotes adicionais no host, iremos executar o binário htpasswd proveniente de uma imagem que contém binários e bibliotecas do Apache. Esta sem dúvidas é uma abordagem interessante, pois depois de utilizada a ferramenta o container será removido (devido a opção –rm), e depois iremos remover a imagem.</p><pre><em>docker run –rm httpd:2.4-alpine htpasswd -nbB admin LinusTorvalds | cut -d “:” -f 2<br>docker rmi httpd:2.4-alpine -f</em></pre><p>Supondo que o hash gerado seja:</p><p>$2y$05$2AIY9Z//ED3aoyRM/aEy7O9q946bEuMe2tiJRTyciv7fKXGV8whbS</p><p><strong>Copie o hash gerado pois será utilizado com valor de parâmetro a seguir:</strong></p><p>docker service create –name orquestrador -p 9000:9000 –constraint ‘node.role == manager’ –mount type=bind,src=/data/orquestrador,dst=/data –mount type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock portainer/portainer \<br> –admin-password ‘$2y$05$2AIY9Z//ED3aoyRM/aEy7O9q946bEuMe2tiJRTyciv7fKXGV8whbS’ \<br> -H unix:///var/run/docker.sock</p><p><strong>Acesse o endereço </strong><a href="https://192.168.1.11:9000/"><strong>https://192.168.1.11:9000</strong></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/0*bFevlqm4dN08ZI9N." /></figure><p>Nos próximos artigos falaremos sobre outros orquestradores interessantes como UCP, Rancher, Tuntum, bem como, sobre Docker-machine e Docker-Compose.</p><p><em>Originally published at </em><a href="https://waldemardibiazijr.wordpress.com/2017/07/08/portainer-orquestrando-containers-em-um-cluster-docker-swarm/"><em>waldemardibiazijr.wordpress.com</em></a><em> by W</em>aldemar Dibiazi Jr<em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ab32ee68152" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/portainer-orquestrando-containers-em-um-cluster-docker-swarm-3ab32ee68152">Portainer — Orquestrando containers em um Cluster Docker Swarm</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cloud First]]></title>
            <link>https://medium.com/awsugsp/cloud-first-5c94e256838f?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/5c94e256838f</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloudbr]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 01:10:28 GMT</pubDate>
            <atom:updated>2017-08-18T20:29:01.335Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*gtlaHJiju3h4hvzif3-wvA@2x.jpeg" /></figure><blockquote>“Por que não ir para a Cloud?”</blockquote><p>O que a alguns anos atrás era apenas uma modinha, ambiente de teste para pequenas empresas e laboratório de Startups, está passando a ser a preferência de empresas de todos os portes.</p><p>Venho escutando cada vez mais esse termo nos últimos tempos e até arrisco a dizer que esse movimento está, de uma certa forma, sintonizado com as crises que o mundo vem enfrentando.</p><p>Não é à toa que esse movimento ocorre em conjunto com outras disrupturas de conceitos, tais como o surgimento do Uber, Netflix, Spotify, AirBnB e outros. Deixamos de ser donos e passamos a ser consumidores de recursos, uma vez que comprar sempre leva tempo e corremos o risco de mudarmos de ideia em pouco tempo, e tecnologia e sua infraestrutura não é diferente e a Cloud nos proporciona exatamente isso.</p><p>O fato de subir toda uma infraestrutura com servidores, banco de dados, load-balance, rede, firewall e CDN, em alguns minutos e a partir de uma simples chamada de API que executará um script JSON previamente criado, customizado, homologado e em qualquer região do mundo se diferencia de qualquer Data center ou CPD convencional. Essa chamada de API pode ser feita de varias formas possíveis, essa semana mesmo um dos projetos que estou participando é de fazer uma chamada de API para criação de um site em WordPress via comando de voz utilizando o AmazonEcho, ou seja, um simples comando de voz para um dispositivo cria uma nova instancia EC2 (servidor) na AWS e faz o deploy da versão mais nova do WordPress e customiza a tela de instalação em menos de 1 minuto.</p><p>Outro diferencial com relação a Cloud é a elasticidade e pagamento sob demanda, onde sua infra pode crescer para o tamanho necessário e pelo tempo que for preciso, executar as operações necessárias e depois ser desligada, uma vez que se paga apenas pelo que se utiliza. Podemos aumentar em 10x, por exemplo, às vésperas da BlackFriday e voltar ao “normal” no sábado. Ou seja, não precisamos mais redimensionar o ambiente pelo pico, o ambiente sempre terá a infra necessária, desde que seja planejado.</p><p>Soluções simples e que muitas empresas gastam muitos recursos para manter, como Backup. Até mesmo porquê todos sempre pensam em Backup, mas são haras as empresas que se preocupam com o restore.</p><p>Lidar com fitas de backup é muito complicado:</p><ul><li>Elas tem prazo de validade (que ninguém se importa);</li><li>Precisam de equipamentos específicos para cada tipo de fita;</li><li>Poucos fazem teste de Restore com elas;</li><li>São lentas;</li><li>Precisam de local apropriado para armazenagem;</li></ul><p>Imagina uma empresa que precisa manter, por complience, dados de clientes por 5 anos, quem garante que os dados estão bem armazenados de verdade?</p><blockquote>Jogue a primeira pedra quem nunca teve problema com restore!</blockquote><p>Existem soluções específicas para esse tipo de backup, como o Amazon Storage Gateway, que se encarrega de transferir seus backups feitos on-premises para o Amazon Glacier (serviço de armazenamento da dados em nuvem de custo extremamente baixo para arquivamento e backups de dados de longa duração)</p><p>Esses são apenas alguns conceitos que fazem o diferencial da Cloud e que deixam cada vez mais as empresas focadas no negócio e não mais em TI.</p><blockquote>A área de T.I. deve ser um facilitador para o negócio e nunca um obstáculo!</blockquote><p>Cloud deixou de ser uma opção e passou a ser um caminho sem volta e a cada dia passamos a usar mais recursos dela..</p><p><em>Originally published at </em><a href="https://medium.com/@wembleycarvalho/cloud-first-b1b955e9c512"><em>medium.com</em></a><em> by @WembleyCarvalho.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5c94e256838f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/cloud-first-5c94e256838f">Cloud First</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entregando mensagens em formato ‘raw’ com AWS SNS]]></title>
            <link>https://medium.com/awsugsp/entregando-mensagens-em-formato-raw-com-aws-sns-5fc23c0a1527?source=rss----3a90e420e1---4</link>
            <guid isPermaLink="false">https://medium.com/p/5fc23c0a1527</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloudbr]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[AWS User Group São Paulo]]></dc:creator>
            <pubDate>Fri, 28 Feb 2020 01:09:54 GMT</pubDate>
            <atom:updated>2017-08-21T17:33:24.831Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*gtT5Q_rRRV1VbHTj.png" /></figure><p>Atualmente tenho trabalhado bastante com sistemas distribuídos e a dupla <a href="https://aws.amazon.com/pt/sns/">AWS SNS</a> /<a href="https://aws.amazon.com/pt/sqs/">SQS</a> aparece em muitos deles. A finalidade óbvia é desacoplar diferentes serviços e jogar ‘nas costas’ da AWS parte da escalabilidade/confiabilidade. As mensagens que são trocadas entre os serviços são as mais diversas possíveis, como se pode imaginar, e algumas vezes o tamanho do que é transmitido (payload) importa muito. Neste artigo vou mostrar uma opção que tenho usado para tornar menores as mensagens entregues pelo SNS.</p><p><strong>Sobre o que se trata este artigo?</strong> Trata-se de explorar sobre uma propriedade específica de assinatura de um tópico SNS.</p><p><strong>IMPORTANTE: </strong>Os exemplos que vou mostrar daqui para frente utilizam a stack do <a href="https://aws.amazon.com/pt/cloudformation/">AWS CloudFormation</a> abaixo. Ela cria um tópico SNS, uma fila SQS e uma fila para DLQ.</p><pre>AWSTemplateFormatVersion: &#39;2010-09-09&#39;<br>Description: &#39;Stack para brincar com SNS, SQS&#39;<br>Resources:<br> SampleDLQ:<br> Type: AWS::SQS::Queue<br> Properties:<br> DelaySeconds: &#39;0&#39;<br> VisibilityTimeout: &#39;10&#39;<br> MessageRetentionPeriod: &#39;1209600&#39;<br> SampleQueue:<br> Type: AWS::SQS::Queue<br> Properties:<br> DelaySeconds: &#39;0&#39;<br> VisibilityTimeout: &#39;5&#39;<br> RedrivePolicy:<br> deadLetterTargetArn: !GetAtt [SampleDLQ, Arn]<br> maxReceiveCount: &#39;3&#39;<br> SampleSNSTopic:<br> Type: AWS::SNS::Topic<br> Properties:<br> Subscription:<br> - Endpoint: !GetAtt [SampleQueue, Arn]<br> Protocol: sqs<br> SampleQueuePolicy:<br> Type: AWS::SQS::QueuePolicy<br> Properties:<br> PolicyDocument:<br> Version: &#39;2012-10-17&#39;<br> Id: SampleQueuePolicy<br> Statement:<br> - Sid: Allow-SendMessage-To-SampleQueue-From-SNS-Topic<br> Effect: Allow<br> Principal: &#39;*&#39;<br> Action:<br> - sqs:SendMessage<br> Resource: &#39;*&#39;<br> Condition:<br> ArnEquals:<br> aws:SourceArn: !Ref &#39;SampleSNSTopic&#39;<br> Queues:<br> - !Ref &#39;SampleQueue&#39;</pre><p>Usar SNS/SQS normalmente implica em ter produtores e consumidores de dados. No exemplo deste artigo o produtor (uma aplicação console simples) publica a seguinte mensagem no tópico SNS:</p><pre>{<br> &quot;Prop1&quot;:&quot;Value for property 1&quot;,<br> &quot;Prop2&quot;:false,<br> &quot;Prop3&quot;:1000<br>}</pre><p>Considerando a stack criada, a notificação da fila SQS vai gerar a mensagem a ser consumida conforme mostra o trecho abaixo.</p><pre>{<br> &quot;Type&quot; : &quot;Notification&quot;,<br> &quot;MessageId&quot; : &quot;400eb8e3-f4de-5fdd-b3a8-eaf01ccdafc5&quot;,<br> &quot;TopicArn&quot; : &quot;arn:aws:sns:us-east-1:821038529621:SetSubscriptionAttrSamples-SampleSNSTopic-1DDY6BVXEJAHF&quot;,<br> <strong>&quot;Message&quot; : &quot;{\&quot;Prop1\&quot;:\&quot;Value for property 1\&quot;,\&quot;Prop2\&quot;:false,\&quot;Prop3\&quot;:1000}&quot;</strong>,<br> &quot;Timestamp&quot; : &quot;2017-08-20T19:41:07.849Z&quot;,<br> &quot;SignatureVersion&quot; : &quot;1&quot;,<br> &quot;Signature&quot; : &quot;iHDQO8T0JvX4BeBDscxWSRJw9Le026r3AvAjVZqUg2QZM4oVHZSX88dEXVO+dq5bQeFqjJkuAhRXw0k1D87blq/25cNkA6n4PBM8WcDC25KYhwOgRZOcRKiGZhF3tqSIXt6HnhPGD1jDYoSZlVagXhyRaTWcTLgFkGuM0cNhYt+VnNRYaIPqiN82dQx7JlR7+DGak6XXMn5WDgTvfxsxeEtvGAuWy9pIN2Vfn8j2qnguphcMpdu8ekjH/RtXeU3/iC6H/G74GOj3zueBL/BqQZ7pZpp8HdcYjT8Se3VFEsXECFNGPMLzVWLg40OTaJP1J9MhkOXPRALff0jyKakViA==&quot;,<br> &quot;SigningCertURL&quot; : &quot;https://sns.us-east-1.amazonaws.com/SimpleNotificationService-433026a4050d206028891664da859041.pem&quot;,<br> &quot;UnsubscribeURL&quot; : &quot;https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-1:821038529621:SetSubscriptionAttrSamples-SampleSNSTopic-1DDY6BVXEJAHF:d8aef064-ddcb-4794-83a4-df155576c3f1&quot;<br>}</pre><p>Note que além da mensagem recebida (deixei em negrito no código), temos uma série de informações úteis. O id da mensagem, data e hora e assim por diante. O tamanho total desta mensagem na fila SQS é <strong>1KB.</strong></p><p>É possível configurar uma determinada assinatura do SNS para que a mensagem seja entregue em modo raw. Para tanto, nos detalhes do tópico SNS na assinatura específica, escolha <strong>‘Edit subscription attributes’</strong> e marque a opção <strong>Raw message delivery</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Za_U-A8WsHc8x0NdsA0njA.png" /><figcaption>indicando que a mensagem deve ser entregue à fila SQS em formato raw</figcaption></figure><p>Com a assinatura configurada desta forma, temos que a mensagem entregue terá <strong>59 bytes</strong> e o aspecto abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*NqDTlpt7UBMroWMPtNESog.png" /><figcaption>Mensagem na fila SQS em formato raw</figcaption></figure><p>Para fazer a mesma configuração via <a href="https://aws.amazon.com/pt/cli/?sc_channel=PS&amp;sc_campaign=acquisition_BR&amp;sc_publisher=google&amp;sc_medium=english_command_line_b&amp;sc_content=aws_cli_e&amp;sc_detail=aws%20cli&amp;sc_category=command_line&amp;sc_segment=210944225162&amp;sc_matchtype=e&amp;sc_Country=BR&amp;s_kwcid=AL!4422!3!210944225162!e!!g!!aws%20cli&amp;ef_id=V4O@jQAAAUx0MJKm:20170820205113:s">AWS CLI</a>, basta saber o arn da assinatura SNS que você deseja configurar.</p><pre>aws sns set-subscription-attributes --attribute-name RawMessageDelivery --attribute-value true --subscription-arn arn-assinatura-vai-aqui</pre><p>O ideal seria conseguir fazer esta configuração via CloudFormation, não é verdade? Bem, eu ainda não encontrei uma forma de fazer isso. Caso você tenha esbarrado nisso e saiba como saber, dê um toque aí nos comentários. Vai ser muito bem vindo. :) Vi umas soluções utilizando ‘custom resources’, mas pelo menos em princípio me parece bem estranho. Não se trata de um recurso customizado…</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*86mfhyYKBxTZVOpPhixjVw.png" /><figcaption><a href="https://github.com/mfpalladino/medium/tree/master/using%20set-subscription-attributes">Fontes utilizados neste artigo</a></figcaption></figure><p><em>Originally published at </em><a href="https://medium.com/@mfpalladino/entregando-mensagens-em-formato-raw-com-aws-sns-7e5e37da50de"><em>medium.com</em></a><em> by </em><a href="https://medium.com/u/c264ccd6d7e9"><em>Marcelo Palladino</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fc23c0a1527" width="1" height="1" alt=""><hr><p><a href="https://medium.com/awsugsp/entregando-mensagens-em-formato-raw-com-aws-sns-5fc23c0a1527">Entregando mensagens em formato ‘raw’ com AWS SNS</a> was originally published in <a href="https://medium.com/awsugsp">awsugsp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>