<?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[Computando Arte - Medium]]></title>
        <description><![CDATA[Temas relacionados à Ciência da Computação, Matemática Aplicada, Estatística e Ciência de Dados em geral e em português. - Medium]]></description>
        <link>https://medium.com/computando-arte?source=rss----16b99e4b265c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Computando Arte - Medium</title>
            <link>https://medium.com/computando-arte?source=rss----16b99e4b265c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 03:05:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/computando-arte" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Dockerfile: Hardening e boas práticas]]></title>
            <link>https://medium.com/computando-arte/dockerfile-hardening-e-boas-pr%C3%A1ticas-24acaa25bf1e?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/24acaa25bf1e</guid>
            <category><![CDATA[computação]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Caio Volpato]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 23:00:21 GMT</pubDate>
            <atom:updated>2026-01-28T23:00:20.917Z</atom:updated>
            <content:encoded><![CDATA[<p>Dockerfile é tudo igual? Se a imagem está sendo buildada e a aplicação está rodando, posso mandar bala? Vamos ver nesse texto que não. Existem outras considerações a serem feitas, principalmente de segurança. Vamos nos debruçar para encontrar o Dockerfile mínimo contendo apenas o necessário para rodar nosso app em Python.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JWeRlueDNDLQOwdj" /><figcaption>Foto de S. Laiba Ali, <a href="https://unsplash.com/photos/blue-red-green-and-yellow-lego-blocks-zncK6BaaDgo">unsplash</a></figcaption></figure><h3>Nosso exemplo: API em Python com Flask</h3><p>Nesse texto vamos explorar bastante esse exemplo, que retorna um “Hello world” simples, e pra fazer uma graça um endpoint que retorna de volta o que foi enviado no caminho da url.</p><pre>from flask import Flask<br><br>app = Flask(__name__)<br><br>@app.route(&quot;/hello&quot;)<br>def hello_default():<br>    return hello(&quot;&quot;)<br><br>@app.route(&quot;/hello/&lt;string:hellomsg&gt;&quot;)<br>def hello(hellomsg: str) -&gt; str:<br>    res = &quot;hello world!&quot;<br>    if len(hellomsg) &gt; 0:<br>        res = hellomsg<br>    return res<br><br>if __name__ == &quot;__main__&quot;:<br>    app.run(host=&quot;0.0.0.0&quot;)</pre><p>app.py</p><p>Pra quem quiser brincar com eles, todos os códigos e arquivos utilizados nesse texto estão disponíveis no seguinte repositório <a href="https://gitlab.com/caioau/caioau.gitlab.io/-/tree/master/static/blog/dockerfile-hardening/exemplo?ref_type=heads">gitlab.com/caioau/caioau.gitlab.io</a></p><p>Junto do Dockerfile temos o nosso requirements.txt:</p><pre>Flask~=3.1.2<br>gunicorn~=23.0.0</pre><p>Para quem não está familiarizado com a notação <strong>~=</strong> estamos usando apontando para versão compatível, como as bibliotecas utilizam versionamento semântico (<a href="https://semver.org/lang/pt-BR/">semver.org</a>) vamos utilizar versões mais novas mas dentro do mesmo menor (minor), mas sem mudanças que quebrem as funcionalidades atuais. A linha Flask~=3.1.2 equivale a Flask&gt;=3.1.2,Flask==3.1.*</p><h3>Dockerfile v0</h3><p>Com o código-fonte do nosso app, podemos seguir com o Dockerfile.</p><p>A fim de ajudar no debug do app, vamos incluir o vim e curl nas imagens.</p><pre>FROM debian:bullseye<br><br>RUN apt-get update &amp;&amp; \<br>    apt-get install -y \<br>    python3-pip python3-dev \<br>    build-essential \<br>    curl \<br>    vim<br><br>RUN apt-get clean &amp;&amp; rm -rf /var/lib/apt/lists/*<br><br>WORKDIR /usr/src/app<br><br>COPY . /usr/src/app/<br><br>RUN pip3 install -r requirements.txt<br><br>RUN rm -rf ~/.cache/pip<br><br>EXPOSE 8000<br><br>CMD [ &quot;gunicorn&quot;, &quot;-w&quot;, &quot;2&quot;, &quot;-b&quot;, &quot;0.0.0.0:8000&quot;, &quot;--access-logfile&quot;, &quot;-&quot; , &quot;--error-logfile&quot;, &quot;-&quot;, &quot;app:app&quot; ]</pre><p>O que está acontecendo? Utilizando uma imagem base do Debian, instalamos o Python com outros pacotes que fazem a compilação (build-essential e python3-dev). E daí na próxima instrução deletamos o índice do apt-get.</p><p>Mudamos a pasta de trabalho (WORKDIR) e copiamos o código-fonte da aplicação lá, instalamos as dependências da aplicação e similarmente com os índices do apt-get deletamos o cache do pip.</p><p>Por fim, configuramos o comando que sobe a aplicação, utilizando o gunicorn como servidor web Python.</p><p>Quando colocamos para rodar a imagem, a aplicação funciona \o/</p><p>Porém, além de outros problemas de que vamos falar logo, o tamanho da imagem: 570MB, tá bom pra você quase 600 megabytes por um simples hello world?</p><p>Fica até o final, porque vai ter bolo vamos reduzir o tamanho dessa imagem para 10x menor.</p><p>Observação: Nesse texto, quando estivermos falando do tamanho da imagem, estamos nos referindo ao tamanho sem compressão, ou seja, o valor reportado por <em>docker image ls</em>, ao passo que o tamanho que aparece na página WEB no dockerhub ou outros registries é o tamanho com compressão. Por exemplo, uma imagem de 522 MB sem compressão resulta em 192 MB com compressão.</p><h3>Dissecando imagens com dive</h3><p>A nossa primeira dica é usar o dive para “dissecar” a imagem. Uma vez carregada, conseguimos acompanhar como estão os arquivos, então podemos ir “caminhando” a partir da camada inicial até a final como os arquivos foram sendo alterados e dessa forma conseguimos mais facilmente visualizar o que está acontecendo e identificar pontos de melhoria.</p><p>Para instalar, basta baixar o binário do github: <a href="https://github.com/wagoodman/dive">github.com/wagoodman/dive</a></p><p>Com ele instalado basta executar com o nome da imagem</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4sosQ8jduu2g6hd_nvTO-Q.gif" /></figure><p>Bora ver como o dive analisa nossa imagem? Carregando ele podemos o histórico das instruções do nosso Dockerfile, cada instrução gera uma camada e vamos caminhando nesse histórico. Como são muitos arquivos na imagem base, podemos mostrar apenas os arquivos modificados (pressionando Ctrl+U). Vamos retomar esse ponto importante, mas preste atenção na instrução COPY . . quais arquivos são copiados, além do código-fonte.</p><p>Com a imagem analisada percebemos dois erros: os índices do apt e o cache do pip não foram limpos, aumentando o tamanho da imagem final desnecessariamente. Isso aconteceu pois a deleção dos arquivos não está na mesma instrução (RUN) do que a criação deles, propagando para a próxima camada.</p><p>Repare no canto inferior esquerdo que a ferramenta dá algumas dicas de onde melhorar, para a imagem ficar mais eficiente.</p><h3>Use dockerignore</h3><p>O outro erro da nossa v0 foi que alguns arquivos sensíveis vazaram, em particular o arquivo .env com credenciais. Isso aconteceu pois quando copiamos os arquivos em COPY . . todos arquivos no contexto do docker são copiados.</p><p>Como resolver? Podemos colocar tudo o que podemos copiar no Docker dentro de uma pasta dedicada, mas teríamos que manter esse controle.</p><p>Uma solução mais robusta é utilizar o arquivo .dockerignore (<a href="https://docs.docker.com/build/concepts/context/#dockerignore-files">documentação</a>), que funciona de uma forma similar ao .gitignore, limitando a quais arquivos é permitido o acesso no contexto Docker.</p><pre># ignora tudo<br>*<br><br># permite codigos fonte<br>!/src<br>!*.py<br>!requirements.txt<br>!entrypoint.sh<br><br># especifico do python<br>**/__pycache__/<br>**/*.py[cod]<br># C extensions<br>*.so<br>**/.ipynb_checkpoints/</pre><p>.dockerignore</p><p>Acima temos um exemplo de dockerignore que resolve nosso problema, onde todos os arquivos são por padrão bloqueados, e então vamos criando exceções como arquivos de código-fonte.</p><h3>Dockerfile v1</h3><p>Com as lições aprendidas na versão anterior, bora arrumar os erros que encontramos?</p><pre>FROM debian:bullseye<br><br>RUN apt-get update &amp;&amp; \<br>    apt-get install -y --no-install-recommends \<br>    python3-pip python3-dev python3-venv \<br>    build-essential \<br>    curl \<br>    vim &amp;&amp; \<br>    apt-get clean &amp;&amp; rm -rf /var/lib/apt/lists/*<br><br>RUN useradd -u 1000 -U -m --shell /bin/bash python<br><br>USER python<br><br>WORKDIR /home/python/app<br><br>COPY --chown=python:python . /home/python/app<br><br>RUN python3 -m venv .venv &amp;&amp; . .venv/bin/activate &amp;&amp; \<br>    pip3 install --no-cache-dir -r requirements.txt<br><br>ENV PATH=&quot;/home/python/app/.venv/bin:$PATH&quot; # “ativa” o venv<br><br>EXPOSE 8000<br><br>CMD [ &quot;gunicorn&quot;, &quot;-w&quot;, &quot;2&quot;, &quot;-b&quot;, &quot;0.0.0.0:8000&quot;, &quot;--access-logfile&quot;, &quot;-&quot; , &quot;--error-logfile&quot;, &quot;-&quot;, &quot;app:app&quot; ]</pre><p>Dockerfile-v1</p><p>O que mudamos da versão anterior? Colocamos a deleção dos arquivos desnecessários na mesma instrução (no caso do pip install utilizamos a opção –no-cache-dir).</p><p>Também usamos um ambiente virtual (venv) para melhor lidar com as dependências Python.</p><p>E por fim, para não rodar como root, criamos um usuário não root e o utilizamos sempre que possível. Se atente que o pip install foi executado como não root.</p><p>E o tamanho? Apesar de só termos mexido no cache do pip e os índices, a nova imagem é tem 520MB , aproximadamente 50MB menor (~10%).</p><h3>User não root basta?</h3><p>Criamos um usuário não root e paramos de usar o root, mas isso basta? A resposta é não, pois caso a aplicação esteja comprometida, o ataque pode usar qualquer binário presente na imagem para realizar ações mal-intencionadas. Um excelente site explorando isso é o <a href="https://gtfobins.github.io/">GTFOBins</a> que mostra como fazer essas explorações para cada binário.</p><p>Outro argumento é o princípio do privilégio mínimo que dita que devemos apenas usar as permissões mínimas necessárias para o funcionamento dos nossos sistemas, caso contrário as permissões excedentes podem ser abusadas.</p><p>Bora para uma revisão rápida de permissão de arquivos no Linux? O octeto de permissão é definido pelas permissões (do mais significativo para menos) ler (Read), escrever (Write) e executar (eXecute). E temos esse octeto três vezes (da esquerda pra direita): Para o dono, para o grupo e para outros.</p><p>Bora para um exemplo:</p><ul><li>O dono vai poder ler (4), escrever (2) e executar (1) -&gt; 4 + 2 + 1 = 7</li><li>O grupo vai poder ler (4) e executar (1) -&gt; 4 + 1 = 5</li><li>Por fim outros vão poder apenas ler (4) -&gt; 4</li></ul><p>Resultado: Executando chmod 754 vai gerar o resultado que queremos.</p><p>Até aí tudo bem, mas além desses 3 dígitos tem um quarto dígito, normalmente omitido, à esquerda que define mais um octeto o Suid , Guid e o Sticky Bit. Se a gente setar o suid no nosso exemplo anterior, a permissão que tínhamos 754 vira 4754 (adicionando o 4 à esquerda).</p><p>E o que faz esse suid? Quando setado o arquivo quando executado não é executado por quem executa, mas por quem é dono do arquivo, que tipicamente é o root, ou seja, qualquer usuário “vira root” (o sudo funciona assim).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/0*0KrZ_8S_XzkDWUkR.jpg" /><figcaption><a href="https://www.commitstrip.com/en/2016/06/29/chmod-what/">commitstrip.com/en/2016/06/29/chmod-what</a></figcaption></figure><p>Bora mostrar na prática?</p><pre>FROM debian:bullseye<br><br>RUN cp /bin/bash /bin/bash-suid &amp;&amp; chmod u+s /bin/bash-suid<br><br>RUN useradd -u 1000 -U -m --shell /bin/bash python<br><br>USER python<br><br>WORKDIR /home/python/</pre><p>Dockerfile-setuid</p><p>No dockerfile acima criamos um novo bash chamado bash-uid, com a permissão suid, agora mesmo que estejamos rodando como um usuário não root, se invocado esse bash especial escalamos o privilégio para root.</p><p>Para desarmar essa possibilidade, suba o container com a opção <strong>no-new-privileges</strong> que efetivamente protege contra a escalação de privilégio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/926/0*hCjByh7WVwtC6pXY" /></figure><p>Repare que quando executamos o bash especial efetivamente se tornamos root, porém com a opção no-new-privileges habilitada resolvemos o problema.</p><p>Para outras boas práticas de segurança para containers docker consulte a excelente cartilha da OWASP (comunidade que publica diversas boas práticas de segurança para aplicações web): <a href="https://cheatsheetseries.owasp.org/cheatsheets/Docker_Security_Cheat_Sheet.html">OWASP Docker Security Cheat Sheet</a></p><h3>Dockerfile v2: introduzindo multistage</h3><p>Até então estamos instalando compiladores necessários para o pip install, utilizando o pacote build-essential, porém em tempo de execução os mesmos não são necessários, esse é o cenário que a funcionalidade do multi-stage do docker resolve.</p><p>O multi-stage acontece quando utilizamos a instrução FROM múltiplas vezes, criando estágios separados, tipicamente para o build e um estágio final utilizado em tempo de execução, dessa forma os artefatos resultantes do build são passados pro estágio final, e os compiladores e outras ferramentas do build são instalados apenas no estágio de build, resultando uma imagem final menor.</p><pre>FROM python:3.13 AS builder<br><br>RUN useradd -u 1000 -U -m --shell /bin/bash python<br><br>USER python<br><br>WORKDIR /home/python/app<br><br>COPY --chown=python:python . /home/python/app<br><br>RUN python3 -m venv .venv &amp;&amp; . .venv/bin/activate &amp;&amp; \<br>    pip3 install --no-cache-dir -r requirements.txt<br><br>FROM python:3.13-slim AS runtime<br><br>RUN useradd -u 1000 -U -m --shell /bin/bash python<br><br>USER python<br><br>WORKDIR /home/python/app<br><br>COPY --chown=python:python --from=builder /home/python/app/ /home/python/app/<br><br>ENV PATH=&quot;/home/python/app/.venv/bin:$PATH&quot;<br><br>EXPOSE 8000<br><br>CMD [ &quot;gunicorn&quot;, &quot;-w&quot;, &quot;2&quot;, &quot;-b&quot;, &quot;0.0.0.0:8000&quot;, &quot;--access-logfile&quot;, &quot;-&quot; , &quot;--error-logfile&quot;, &quot;-&quot;, &quot;app:app&quot; ]</pre><p>Dockerfile-v2</p><p>Dessa vez optamos por usar as imagens oficiais do python, então não precisamos instalar o python em si e os compiladores que precisamos em tempo de build. Agora o grande pulo do gato do multi-stage, as imagens de build e runtime são diferentes, a de build (python:3.13) têm 1.1GB e a de runtime (python:3.13-slim) aproximadamente 10% do seu tamanho com 120MB.</p><p>Outra mudança na imagem base, até então estávamos usando a release bullseye do Debian, mas consultando o <a href="https://endoflife.date/">endoflife.date</a> podemos ver que essa release perdeu suporte principal, agora com a imagem python a tag 3.13 aponta para a release corrente do stable do Debian. Além de usarmos a variante slim da imagem do debian, sempre que possível opte por essa opção.</p><p>Uma dica valiosa para sempre manter suas dependências atualizadas é utilizar o dependabot ou similares como o renovate, que periodicamente atualiza as dependências automaticamente abrindo um pull request com a atualização.</p><p>Como ficou o tamanho? Essa versão ficou com 130 MB, um quarto da nossa primeira versão.</p><h3>Fazendo nosso app em Golang</h3><p>Até agora estávamos usando Python no nosso app, porém para o próximo conceito de imagens distroless, usar uma linguagem compilada, em particular Go, pois ele permite a compilação estática, ou seja toda a aplicação fica “empacotada” em apenas um binário, sem precisar de outros arquivos/pacotes para que a nossa app funcione.</p><pre>package main<br><br>import (<br>    &quot;fmt&quot;<br>    &quot;io&quot;<br>    &quot;log&quot;<br>    &quot;net/http&quot;<br>    &quot;time&quot;<br>)<br><br>func rootHandler(w http.ResponseWriter, req *http.Request) {<br>    log.Printf(&quot;%v&quot;, req)<br>    fmt.Fprintf(w, &quot;hello world!\n&quot;)<br>}<br><br>func helloHandler(w http.ResponseWriter, req *http.Request) {<br>    log.Printf(&quot;%v&quot;, req)<br>    msg := req.PathValue(&quot;msg&quot;)<br>    fmt.Fprintf(w, &quot;%s&quot;, msg+&quot;\n&quot;)<br>}<br><br>func weatherHandler(w http.ResponseWriter, req *http.Request) {<br>    url := &quot;https://wttr.in/?T&amp;lang=pt-br&quot;<br>    ua := &quot;curl/8.5.0&quot;<br>    log.Println(&quot;making a GET request to url=&quot;, url, &quot;...&quot;)<br>    client := http.Client{ // set a request timeout<br>        Timeout: 20 * time.Second,<br>    }<br><br>    r, err := http.NewRequest(&quot;GET&quot;, url, nil)<br>    if err != nil {<br>        panic(err)<br>    }<br>    r.Header.Add(&quot;User-Agent&quot;, ua)<br><br>    resp, err := client.Do(r)<br>    if err != nil || resp.StatusCode != http.StatusOK {<br>        log.Println(&quot;making a GET request to url=&quot;, url, &quot;Failed! Returning a 500&quot;)<br>        log.Println(&quot;err=&quot;, err)<br>        w.WriteHeader(500)<br>        fmt.Fprintf(w, &quot;request failed!\n&quot;)<br>        return<br>    }<br>    defer resp.Body.Close()<br>    log.Println(&quot;making a GET request to url=&quot;, url, &quot;Done! Response code=&quot;, resp.Status)<br><br>    written, err := io.Copy(w, resp.Body)<br>    if err != nil {<br>        log.Printf(&quot;Error writing response after %d bytes: %v&quot;, written, err)<br>    }<br><br>}<br><br>func main() {<br>    apiPort := &quot;8000&quot;<br><br>    http.HandleFunc(&quot;/&quot;, rootHandler)<br>    http.HandleFunc(&quot;/weather/&quot;, weatherHandler)<br>    http.HandleFunc(&quot;/hello/{msg}&quot;, helloHandler)<br><br>    log.Println(&quot;Listening on port=&quot;, apiPort)<br><br>    panic(http.ListenAndServe(&quot;:&quot;+apiPort, nil))<br><br>}</pre><p>app.go</p><p>Nosso app continua igual à versão em Python, mas agora temos um endpoint a mais que faz um request externo para o site <a href="https://wttr.in/">wttr.in</a> obter a previsão do tempo.</p><p>E como fica o nosso Dockerfile? Como Golang é uma linguagem compilada vamos mostrar nesse exemplo a funcionalidade do multi-stage ao extremo: Criando um container com apenas o binário da nossa app.</p><pre>FROM golang:1.25 AS builder<br><br>RUN useradd -u 1000 -U -m --shell /bin/bash nonroot<br><br>USER nonroot<br><br>WORKDIR /home/nonroot/app<br><br>COPY --chown=nonroot:nonroot . /home/nonroot/app<br><br>RUN CGO_ENABLED=0 go build -ldflags=&quot;-s -w&quot; app<br><br>FROM scratch<br><br>COPY --from=builder /etc/passwd /etc/passwd <br># truque pra rodar nonroot no scratch<br><br>COPY --from=builder /home/nonroot/app/app /usr/local/bin/<br><br>USER nonroot<br>EXPOSE 8000<br><br>ENTRYPOINT [ &quot;app&quot; ]</pre><p>golang/Dockerfile-scratch</p><p>Como podemos ver, compilamos nosso app no estágio de build, usando uma imagem que contém os compiladores e outras ferramentas para gerar o nosso binário, e como estamos compilando estaticamente (usando opção CGO_ENABLED=0) apenas o nosso binário é necessário para a aplicação funcionar. E depois do estágio de build, o estágio final não está utilizando nenhuma imagem base (SCRATCH), ou seja, nossa imagem final vai conter apenas o binário do nosso app.</p><p>Para quem ficou curioso, essa imagem tem apenas 6 MB, ao passo que a imagem base de build (golang:1.25) tem 850MB.</p><p>Quem quiser se aprofundar em diminuir o tamanho do binário ainda mais dá pra usar o upx (<a href="https://github.com/upx/upx">github.com/upx/upx</a>) que faz compressão de executáveis, que reduziu o tamanho para ~2MB. Porém, acho que não vale a pena adotar essa abordagem, pois o Docker já faz essa compressão quando faz o download das imagens, então usar o upx só vai fazer seu app demorar mais para inicializar.</p><p>Se subirmos o container, vemos que os endpoints “hello world” funcionam, mas o endpoint de previsão de tempo não, com o erro: <em>“tls: failed to verify certificate: x509: certificate signed by unknown authority”</em>. Não temos a cadeia de certificados</p><p>Essa foi a nossa deixa para falarmos do conceito de imagens distroless.</p><p>Imagens distroless (<a href="https://github.com/GoogleContainerTools/distroless">github.com/GoogleContainerTools/distroless</a>) foram introduzidos pela Google, e a ideia é que as imagens base tem o mínimo necessário para rodar a aplicação, sem ter uma distribuição base como o debian por trás, ou seja não tem o apt para instalar pacotes ou shell, etc …</p><p>Quem tiver interesse no repositório oficial, tem exemplos para várias linguagens. O que é chato dessas imagens é que caso você precise adicionar algum pacote que a imagem base não tem você precisa aprender o sistema de build pouco intuitivo chamado Bazel.</p><p>No nosso caso a imagem base distroless é a gcr.io/distroless/static, ela tem apenas 2MB. Quais pacotes ela tem? Como não temos o apt, não vamos conseguir facilmente listar os pacotes.</p><p>Para resolver esse problema de identificar os pacotes vamos introduzir um conceito do Software Bill of materials (SBOM), é um “inventário” identificando todos os componentes presentes em um determinado artefato de software. Ele tem alguns formatos padrão, o mais difundido é o System Package Data Exchange (SPDX) , tipicamente representado em um arquivo json. Nesse arquivo teremos as versões de todos os componentes, suas licenças e por fim os relacionamentos (como dependências).</p><p>É uma boa prática gerar o SBOM junto ao build da imagem Docker, pois isso facilita demais auditorias de segurança, por exemplo, quando identificada uma vulnerabilidade em uma biblioteca que utilizamos, conseguimos facilmente encontrar se de fato estamos seguros ou onde precisamos atuar atualizando um pacote para uma versão não vulnerável.</p><p>Vamos gerar o nosso SBOM utilizando o syft (<a href="https://github.com/anchore/syft">github.com/anchore/syft</a>), nossa imagem tem os seguintes pacotes: a cadeia de certificados que precisamos e infos de fuso horários necessários para alguns apps.</p><p>Usando essa imagem como base no estágio final, nosso endpoint de previsão do tempo funciona \o/</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2Sd8NupxrP4EWC8n" /></figure><h3>Debugando imagens distroless</h3><p>Uma das maiores dificuldades em utilizar as imagens mínimas distroless é a de fazer o debug das aplicações, por exemplo, rodar um debugger com breakpoints para investigar algum bug.</p><p>Vamos abordar duas formas de resolver isso, a primeira é ter duas versões do Dockerfile, uma mínima utilizada em produção e uma versão “desenvolvedor” que inclui um shell, o gerenciador de pacotes como o apt e outros pacotes para esse fim.</p><p>Outra abordagem é “anexar” um container de debug junto ao container da aplicação, também chamado de container sidecar, o container de debug tem um shell e as ferramentas necessárias para fazer o debug e atua lado-a-lado da aplicação rodando.</p><p>Bora ver os pacotes da aplicação? Subi nosso app Golang com um container chamado golang, então vamos subir outro container usando o mesmo namespace de processos (pid) e na mesma rede, conforme o comando abaixo:</p><pre>docker  run --rm -it --privileged \<br>--pid container:golang --network container:golang \<br>nicolaka/netshoot</pre><p>Observação: a imagem nicolaka/netshoot (<a href="https://github.com/nicolaka/netshoot">github.com/nicolaka/netshoot</a>) é uma imagem com diversas ferramentas de rede instaladas. Para Kubernetes a imagem bretfisher/shpod (<a href="https://github.com/bretfisher/shpod">github.com/bretfisher/shpod</a>) é ótima com diversas ferramentas para fazer debug do cluster.</p><p>Por que o container precisa ser privilegiado? Para conseguirmos acessar os arquivos do outro arquivo, vá em /proc/1/root , e você estará no filesystem da aplicação. Onde 1 é o id do processo do app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/0*paA1aYlY9kqgqf53.png" /><figcaption><a href="https://wizardzines.com/comics/proc/">wizardzines.com/comics/proc</a></figcaption></figure><p>Antes de capturar os pacotes, bora dar um tutorial rápido de Wireshark? O wireguark é um aplicativo desktop que faz 2 coisas em uma, primeiro ele captura os pacotes passando na maquina e depois ele tem uma interface muito completa para visualizar o tráfego, vendo detalhes de cada pacote, possibilitando filtros e fazendo visualizações como diagramas de estado e estatísticas para ajudar a entender o que está acontecendo.</p><p>No nosso caso, como estamos utilizando containers, não vamos ter a interface gráfica do Wireshark, então podemos fazer de duas formas: capturar os pacotes utilizando o tcpdump (que não tem interface gráfica), salvar um arquivo pcap e visualizar no Wireshark. A outra opção é utilizar uma alternativa “terminal” do Wireshark, o termshark, com ele teremos uma experiência parecida com a original.</p><p>Para abrir o termshark precisamos especificar uma interface da qual os pacotes serão capturados, no nosso caso só temos uma interface, então não precisamos. Uma vez aberto, podemos ver que mesmo sem mandar muitos requests pro nosso app tem muitos pacotes que não são do nosso interesse, como os pacotes do protocolo ARP. Então é uma mão na roda usar filtros, podemos filtrar por IP, por porta , protocolo, etc …. Tem uma colinha dos filtros nesse link: <a href="https://medium.com/hacker-toolbelt/wireshark-filters-cheat-sheet-eacdc438969c">https://medium.com/hacker-toolbelt/wireshark-filters-cheat-sheet-eacdc438969c</a></p><p>Com o termshark aberto e filtrando apenas pacotes HTTP, no print abaixo podemos ver a aplicação rodando no terminal superior esquerdo, um request sendo feito com curl no terminal da direita e abaixo estamos rodando a versão</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mWjyWINu5sQkuEBOuPaO-w.png" /></figure><p>Fechando o parêntese do nosso tutorial 101 do wireshark, se tiver interesse em um texto aprofundado escreva pra gente :)</p><p>Para facilitar nossa vida, tem uma ferramenta que faz essa abordagem de maneira simplificada, o cdebug (<a href="https://github.com/iximiuz/cdebug">github.com/iximiuz/cdebug</a>), com uma feature adicional: fazer redirecionamento de portas não públicas (semelhante ao kubectl port-forward).</p><h3>Fazendo o scan de vulnerabilidades nas imagens</h3><p>Até agora o nosso intuito era diminuir o tamanho das imagens, pois dessa forma teríamos uma superfície de ataque menor, mas não medimos se de fato temos menos vulnerabilidades.</p><p>Vamos adotar o grype (<a href="https://github.com/anchore/grype">github.com/anchore/grype</a>), outra opção muito boa é o trivy (<a href="https://github.com/aquasecurity/trivy">github.com/aquasecurity/trivy</a>)</p><p>A nossa primeira versão (v1) tem 1334 CVEs :/ , das quais 6 são critical, 257 high, 894 medium, etc.</p><p>Já a nossa versão multistage (v2) tem 10x menos vulnerabilidades: com 136 CVEs , das quais 4 critical, 6 high, 36 medium.</p><p>Como pode um simples hello world ter 1300 CVEs? Em resumo, é porque imagens baseadas em Debian não atualizam por completo as versões para corrigir as CVEs, vamos falar em mais detalhes na próxima seção.</p><h3>Debian: Estamos sendo justos com ele?</h3><p>Vimos que a nossa imagem tem mais de mil vulnerabilidades, mas por que isso acontece? Estou de fato em risco?</p><p>A resposta é que provavelmente o problema não é tão grave quanto parece, só que a maneira que os scanners funcionam não bate bem da maneira que o Debian opera. O Debian quando tem sua versão stable declarada todos os pacotes são congelados na versão que estão e são feitos diversos testes para que tudo funcione até que seja lançada ao público a release.</p><p>Quando bugs são encontrados, de segurança ou não, o Debian muitas vezes simplesmente aplica a mudança (patch) que corrige o problema em cima da versão que saiu no stable.</p><p>Ao passo que os scanners de segurança funcionam identificando os pacotes e outros componentes de software (SBOM) e cruzar com um banco de dados de vulnerabilidades.</p><p>Ou seja, os scanners não estão nem aí pras mudanças que o Debian aplicou.</p><p>Por exemplo, nossa primeira versão de ambos o trivy e grype reportaram a CVE-2023–23914 (HSTS ignored on multiple requests) no curl, que de fato é uma vulnerabilidade crítica. Pois bora tentar reproduzir a vulnerabilidade?</p><p>Na página da CVE (<a href="https://curl.se/docs/CVE-2023-23914.html">curl.se/docs/CVE-2023–23914.html</a>), basta rodar o seguinte: curl — hsts “” <a href="https://curl.se/">https://curl.se</a> <a href="http://curl.se/">http://curl.se</a>, quando vulnerável, o curl vai fazer o segundo request sem https, mesmo com o site esforçando HSTS. Porém, o comando falha pois a feature de HSTS nem foi introduzida na versão do curl adotada no Debian Bullseye. Ou seja, é um falso positivo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/0*llF2Qp-91L7AJMT3" /></figure><p>Um excelente blog post falando sobre essa situação é <a href="https://www.linuxserver.io/blog/image-vulnerability-scanning-and-you">Image Vulnerability Scanning and You — linuxserver</a>, da linuxserver, grupo que disponibiliza imagens docker para diversas aplicações open source, no blog post eles mostram como esses resultados aparentemente alarmante de scanners de vulnerabilidades, são falsos positivos. Eles deram um exemplo de uma vulnerabilidade, a CVE-2020–16156, que só pode ser explorada caso um usuário altere configurações de maneira maliciosa, ou seja, para explorar a vulnerabilidade você já teria que estar comprometido, o que é um problema muito maior.</p><p>O scanner grype tem uma opção para apenas considerar vulnerabilidades que de fato serão corrigidas ( — only-fixed), rodando essa opção na nossa v2, as 130 vulnerabilidades caem para 2, uma de severidade medium e outra unknown.</p><h3>Imagens chainguard</h3><p>As imagens da Chainguard são imagens produzidas pela empresa de mesmo nome que, além de serem menores, fazem um grande esforço para as imagens estarem com os pacotes atualizados e com as correções de segurança aplicadas.</p><p>Outra feature legal dessas imagens é que toda vez que um pacote é instalado o SBOM dele é automaticamente gerado, criando um melhor lastro do conteúdo da imagem.</p><p>Para quem está acostumado com imagens baseadas em debian precisa se acostumar pois as imagens do chainguard são baseadas no alpine, ou seja, ao invés do gerenciador de pacotes apt é utilizado o apk, então tem uma certa “curva de aprendizado” para se acostumar, uma dica pra encontrar os pacotes equivalentes é utilizar o apk search com cmd para procurar o pacote que contém aquele comando, por exemplo para instalar o ldd, faça: apk search cmd:ldd e o pacote associado será o posix-libc-utils.</p><p>Outra diferença entre as imagens baseadas no Debian e do Alpine é o shell, nas imagens Debian o shell adotado é o bash, enquanto no Alpine é um shell mais limitado o ash (provido pelo busybox), então se seus scripts contém “bashismos” você precisa ver o que faz mais sentido entre tornar eles interoperáveis (posix-compliant) ou instalar o bash na imagem.</p><p>Apesar de ser baseada no alpine, as imagens chainguard não utilizam a biblioteca padrão musl do alpine, mas sim a implementação mais difundida da GNU a glibc, vamos retomar essa diferença mais a frente.</p><p>Bora colocar nossa app Python para usar o Chainguard?</p><pre>FROM cgr.dev/chainguard/wolfi-base<br><br>ARG pyversion=3.12<br><br>RUN apk add python-${pyversion} py${pyversion}-pip python-${pyversion}-dev \<br>    build-base openssl-dev vim curl &amp;&amp; \<br>    rm -rf /var/cache/apk/*<br><br>USER nonroot<br>WORKDIR /home/nonroot/app<br><br>COPY --chown=nonroot:nonroot . /home/nonroot/app<br><br>RUN python3 -m venv .venv &amp;&amp; . .venv/bin/activate &amp;&amp; \<br>    pip3 install --no-cache-dir -r requirements.txt<br><br>ENV PATH=&quot;/home/nonroot/app/.venv/bin:$PATH&quot;<br><br>EXPOSE 8000<br><br>CMD [ &quot;gunicorn&quot;, &quot;-w&quot;, &quot;2&quot;, &quot;-b&quot;, &quot;0.0.0.0:8000&quot;, &quot;--access-logfile&quot;, &quot;-&quot; , &quot;--error-logfile&quot;, &quot;-&quot;, &quot;app:app&quot; ]</pre><p>Dockerfile-v3</p><p>A imagem base da Chainguard é o wolfi, ela é uma imagem pequena da qual instalamos os pacotes de que precisamos.</p><p>A principal diferença é que os pacotes têm outros nomes, por exemplo, o equivalente do build-essential é o build-base, e diferentemente do Debian podemos escolher qual versão do Python vamos adotar.</p><p>Já vem com um usuário não root, então basta utilizar ele.</p><p>Quem tiver curiosidade em inspecionar a imagem com o dive, os SBOMs SPDX de cada pacote estão em /var/lib/db/sbom/.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/0*9ynafAKIUVR4KIaA" /></figure><p>E as CVEs? É aqui que a Chainguard brilha, nenhuma CVE reportada no Trivy ^_^, porém apesar da Chainguard ter uma postura bastante proativa para manter toda cadeia de suprimento segura e atualizada, você precisa periodicamente rebuildar as imagens para usar as versões mais atuais dos pacotes e das nossas bibliotecas de que dependemos (que permitimos que sejam atualizadas para versões compatíveis).</p><p>Quem tiver interesse em aprender mais sobre as imagens chainguard eles tem excelentes guias com passo-a-passo, exemplo e cursos em <a href="https://edu.chainguard.dev/">edu.chainguard.dev</a> gostei bastante da dinâmica dos cursos, com vídeos curtos e acompanhados de um texto do que é mostrado no vídeo.</p><h3>Criando imagens distroless da Chainguard com Melange</h3><p>No exemplo anterior utilizamos a imagem base da Chainguard para o nosso app Python, porém ela não é uma imagem distroless, visto que ela tem um shell, o apk e etc. … A Chainguard tem imagens distroless do Python e outras linguagens e projetos, porém só podemos usar gratuitamente sua tag latest.</p><p>Para termos uma imagem distroless pra chamar de nossa, vamos utilizar o sistema de build da Chainguard, o Melange.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*hp1stlhomcBHSgJF" /><figcaption><a href="https://edu.chainguard.dev/open-source/build-tools/melange/overview/">edu.chainguard.dev/open-source/build-tools/melange/overview</a></figcaption></figure><p>Primeiramente precisamos empacotar nossa app python em um pacote alpine apk usando o melange, para fazer esse empacotamento teremos uma pipeline de build no melange declarada a partir do arquivo yaml abaixo:</p><pre>package:<br>  name: hello-crud<br>  version: 0.0.1<br>  epoch: 0<br>  description: REST hello world<br>  copyright:<br>    - license: Apache-2.0<br>      paths:<br>        - &quot;*&quot;<br>  dependencies:<br>    runtime:<br>      - python-3.12<br><br>environment:<br>  accounts:<br>    groups:<br>      - groupname: nonroot<br>        gid: 65532<br>    users:<br>      - username: nonroot<br>        uid: 65532<br>    run-as: nonroot<br>  contents:<br>    keyring:<br>      - https://packages.wolfi.dev/os/wolfi-signing.rsa.pub<br>      - ./melange.rsa.pub<br>    repositories:<br>      - https://packages.wolfi.dev/os<br>    packages:<br>      - busybox<br>      - glibc<br>      - glibc-locale-posix<br>      - openssl-dev<br>      - build-base<br>      - python-3.12<br>      - py3.12-pip<br><br>pipeline:<br>  - name: Build Python application<br>    runs: |<br>      VENVDIR=/usr/share/webapps/hello-server/venv<br>      EXECDIR=&quot;${{targets.destdir}}/usr/bin&quot;<br>      WEBAPPDIR=&quot;${{targets.destdir}}/usr/share/webapps/hello-server&quot;<br>      mkdir -p &quot;${EXECDIR}&quot; &quot;${WEBAPPDIR}&quot; /usr/share/webapps/hello-server<br>      cd /usr/share/webapps/hello-server<br>      echo -e &quot;\n\n#########################################\n&quot;<br>      python3 -m venv ${VENVDIR}<br>      cd /home/build<br>      sh -c &quot;. ${VENVDIR}/bin/activate &amp;&amp; pip3 install --no-compile --no-cache-dir -r requirements.txt &amp;&amp; pip3 uninstall -y pip&quot;<br>      cp -r ${VENVDIR} ${WEBAPPDIR}<br>      cp app.py ${WEBAPPDIR}<br>      chown -R 65532:65532 ${WEBAPPDIR}</pre><p>melange.yaml</p><p>Nesse yaml a gente declara as informações do nosso pacote, como nome, versão e licença e as dependências em tempo de execução dele, no nosso caso apenas o python3.12.</p><p>Em seguida declaramos o que o nosso ambiente de build precisa: os pacotes de build, o usuário não root e os repositórios wolfi para usarmos os pacotes da chainguard (poderíamos usar o alpine se quiser).</p><p>Por fim a pipeline de build em si, ou seja uma sequência de comandos shell que builda a app e copia tudo para uma pasta em targets.destdir.</p><p>Fizemos uma pequena alteração no nosso pip install, utilizando a flag –no-compile que não gera os arquivos .pyc, dessa forma o venv fica menor. Tem um excelente blog post explicando os trade-offs dessa abordagem: <a href="https://aleksac.me/blog/dont-use-pythondontwritebytecode-in-your-dockerfiles/">Stop putting this into your Python Dockerfiles — Aleksa Cukovic</a></p><p>Bora buildar nosso pacote?</p><p>Na primeira vez precisamos gerar uma chave privada para assinar o pacote:</p><pre>docker run --rm -v &quot;${PWD}&quot;:/work cgr.dev/chainguard/melange keygen</pre><p>Não se preocupe com os comandos, criei um makefile no repositório que executa os comandos em sequência.</p><p>Então o build:</p><pre>docker run --privileged --rm -v &quot;${PWD}&quot;:/work cgr.dev/chainguard/melange build melange.yaml \<br>    --arch amd64 --signing-key melange.rsa</pre><p>Pronto! Uma vez executado, teremos nosso pacote alpine na pasta packages.</p><p>Com o nosso pacote alpine pronto, bora criar o container que faz o deploy do nosso app? É agora que surge o apko, nele declaramos o container usado em tempo de execução (runtime) contendo o pacote previamente gerado, é como se fosse um Dockerfile, mas feito de forma declarativa.</p><p>Agora o nosso apko.yaml:</p><pre>contents:<br>  keyring:<br>    - https://packages.wolfi.dev/os/wolfi-signing.rsa.pub<br>    - ./melange.rsa.pub<br>  repositories:<br>    - https://packages.wolfi.dev/os<br>    - &#39;@local /work/packages&#39;<br>  packages:<br>    - hello-crud@local<br>accounts:<br>  groups:<br>    - groupname: nonroot<br>      gid: 65532<br>  users:<br>    - username: nonroot<br>      uid: 65532<br>  run-as: nonroot<br>environment:<br>  PATH: /usr/share/webapps/hello-server/venv/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin<br>work-dir: /usr/share/webapps/hello-server/<br>entrypoint:<br>  command: gunicorn -w 2 -b 0.0.0.0:8000 --access-logfile - --error-logfile - app:app</pre><p>apko.yaml</p><p>No nosso apko declaramos os repositórios da chainguard (ou alpine), os pacotes: no nosso caso apenas o pacote da nossa app, o usuário não root e as condições pro nosso app rodar como variaveis de ambiente e o comando entrypoint.</p><p>Para buildar nossa imagem:</p><pre>docker run --rm --workdir /work -v ${PWD}:/work cgr.dev/chainguard/apko \<br>    build apko.yaml hello-crud:test hello-crud-server.tar --arch host</pre><p>Cuidado que a imagem não é carregada automaticamente no docker, você precisa fazer docker image load -i hello-crud-server.tar</p><p>E o resultado? A imagem ficou com 65MB \o/</p><p>Em retrospectiva a nossa primeira versão do dockerfile tinha 570MB, a versão multistage usando debian 190MB e agora quase 10x menor com 65MB, não vai embora ainda não porque vamos melhorar ainda mais.</p><h3>Distroless sem o melange e apko</h3><p>Na seção anterior mostrei como usar o melange e o apko para declarativamente criar imagens mínimas para sua aplicação, porém é um sistema de build dedicado que você vai ter que aprender e manter, minha intenção era mostrar que não é um bicho de sete cabeças , pelo contrário o melange e o apko são bastante amigáveis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/464/1*nN7C-5ulY2qQtlDXLXgyxg.png" /></figure><p>Porém pra quem não quiser aprender um novo sistema de build e não se importa em quebrar a cabeça fazendo um Dockerfile especializado temos essa alternativa.</p><p>A peça crítica para esse Dockerfile funcionar é que o gerenciador de pacotes apk suporta chroot, ou seja podemos instalar pacotes em outro sistema de arquivos por “fora da caixa”, sem precisarmos instalar o apk em si ou ter um shell para conseguir rodar qualquer comando durante o build.</p><blockquote>talk is cheap, show me the code:</blockquote><pre>ARG ROOTFS=/new_root<br>ARG pyversion=3.12<br># nonroot user<br>ARG PGID=1000<br>ARG PUID=1000<br><br>FROM cgr.dev/chainguard/wolfi-base AS appbuilder<br><br>ARG pyversion<br><br>RUN apk add python-${pyversion} py${pyversion}-pip python-${pyversion}-dev build-base openssl-dev &amp;&amp; \<br>    rm -rf /var/cache/apk/*<br><br>USER nonroot<br>WORKDIR /home/nonroot/app<br><br>COPY --chown=nonroot:nonroot . /home/nonroot/app<br><br>RUN python3 -m venv .venv &amp;&amp; . .venv/bin/activate &amp;&amp; \<br>    pip3 install --no-compile --no-cache-dir -r requirements.txt &amp;&amp; \<br>    pip3 uninstall -y pip<br><br>FROM cgr.dev/chainguard/wolfi-base AS chrootbuilder<br><br>ARG ROOTFS<br>ARG pyversion<br>ARG PGID<br>ARG PUID<br><br>RUN mkdir -p $ROOTFS/etc/apk/keys &amp;&amp; \<br>    cp -v /etc/apk/keys/* $ROOTFS/etc/apk/keys/ &amp;&amp; \<br>    cp -v /etc/apk/repositories  $ROOTFS/etc/apk/repositories<br><br>RUN apk add shadow &amp;&amp; \<br>    rm -rf /var/cache/apk/*<br><br>RUN apk add --no-commit-hooks --root $ROOTFS --initdb glibc glibc-locale-posix \<br>    python-${pyversion} &amp;&amp;\<br>    rm -rf $ROOTFS/var/cache/apk/*<br><br>RUN groupadd -g ${PGID} -R $ROOTFS nonroot &amp;&amp;\<br>    useradd -u ${PUID} -g nonroot -m --shell /bin/sh -R $ROOTFS nonroot<br><br>FROM scratch AS runtime<br><br>ARG ROOTFS<br><br>COPY --from=chrootbuilder $ROOTFS /<br><br>USER nonroot<br>WORKDIR /home/nonroot/app<br><br>COPY --chown=nonroot:nonroot --from=appbuilder /home/nonroot/app/ /home/nonroot/app/<br><br>ENV PATH=&quot;/home/nonroot/app/.venv/bin:$PATH&quot;<br><br>EXPOSE 8000<br><br>CMD [ &quot;gunicorn&quot;, &quot;-w&quot;, &quot;2&quot;, &quot;-b&quot;, &quot;0.0.0.0:8000&quot;, &quot;--access-logfile&quot;, &quot;-&quot; , &quot;--error-logfile&quot;, &quot;-&quot;, &quot;app:app&quot; ]</pre><p>Dockerfile-v4</p><p>O Dockerfile tem 3 estágios: um que faz o “build” do nosso venv e da app, um que gera o ambiente chroot com as dependências de tempo de execução e o estágio final que junta os dois. Fiz dessa forma para separar a nossa “imagem base” com o runtime de python, que é desacoplado da nossa app e o build do venv que aí sim depende da nossa app, dessa forma rebuilds com cache só fazem o build o que mudou.</p><p>O grande pulo do gato é o uso das flags do apk: -R apontando para chroot, –no-commit-hooks pois os hooks não se aplicam quando usando chroots e –initdb para inicializar o database do apk, sem isso o database não será gerado e ferramentas de SBOM não funcionam.</p><p>E o resultado? O tamanho ficou muito próximo do apko (65MB), com apenas alguns KBs de diferença.</p><h3>glibc vs musl: O inimigo agora é outro</h3><p>Quanto comecei minha jornada com Docker e comecei a colocar meus apps Python no docker, na época pelo menos era inviável usar imagens base alpine pois não tinha os wheels pré-compilados para biblioteca padrão c musl do alpine então qualquer app que precisava do numpy o build demorava demais pra compilar, então deixei de lado as imagens alpine.</p><p>Mas agora quando tentei novamente o pypi tem os wheels pré-compilados pro musl e outras arquiteturas como o arm \o/</p><p>Porém as imagens da chainguard apesar de serem baseadas no alpine não utilizam a musl, mas sim a implementação mais difundida a glibc, tem um artigo deles bastante completo explicando o diversos aspectos por trás dessa decisão, como compatibilidade com binários dinamicamente linkados:</p><p><a href="https://edu.chainguard.dev/chainguard/chainguard-images/about/images-compiled-programs/glibc-vs-musl/">glibc vs. musl — Chainguard</a></p><p>O dockerfile ficou igual ao dockerfile-v4, porém mudando a imagem base do wolfi para a release mais recente do alpine (alpine:3.23). E o tamanho da imagem ficou uns ~15MB menor que a do melange (50MB).</p><p>Bora fazer uma retrospectiva de como foi evoluindo o tamanho da nossa imagem Python? Podemos ver na tabela abaixo que começamos com o nosso Dockerfile v0 bem tradicional com quase 600MB e com o multistage o tamanho caiu para um quarto da v0 e metade disso usando distroless.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/481/1*VB8nsAK3DvKUx4CtwF90Tg.png" /></figure><p>Observação: Omitimos a v3 pois nela o objetivo era migrar para imagens baseadas em alpine, sem o foco em otimizar seu tamanho.</p><h3>Hadolint</h3><p>Pra fechar o texto, a última dica é utilizar o Hadolint (<a href="https://github.com/hadolint/hadolint">github.com/hadolint/hadolint</a>), ele dá excelentes dicas para as boas práticas de que falamos aqui, tem extensão pro VSCode e de quebra roda o outro linter excelente para shell <a href="http://shellcheck.net/">shellcheck.net</a> dentro das instruções RUN, então você leva dois linters dentro de um.</p><h3>Conclusão</h3><p>Resgatando a provocação inicial, espero a essa altura ter te convencido de que dockerfile não é tudo igual, que não posta a aplicação funcionar para termos um bom dockerfile.</p><p>O princípio que mais exploramos é tornar a imagem enxuta possível, pois além de imagens menores serem mais performáticas, elas têm uma superfície de ataque menor e dessa forma conseguimos identificar quais dependências são realmente necessárias em tempo de execução da aplicação.</p><p>Para “enxugar” as imagens vimos como o dive é uma ferramenta muito prática para dissecar camada a camada as imagens e identificar os pontos de melhoria, e o conceito de multi-stage para separar o build e o runtime.</p><p>Por fim, levando ao extremo o objetivo do multi-stage , vimos o conceito das imagens distroless e como fazer elas com o melange e o apko, porém o desafio de debugar essas imagens.</p><p>Espero que esse texto te auxilie a criar imagens Docker melhores e muito obrigado por chegar até aqui!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=24acaa25bf1e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/dockerfile-hardening-e-boas-pr%C3%A1ticas-24acaa25bf1e">Dockerfile: Hardening e boas práticas</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ansible localhost -a “/bin/echo Primeiros passos com o Ansible”]]></title>
            <link>https://medium.com/computando-arte/ansible-localhost-a-bin-echo-primeiros-passos-com-o-ansible-7674529524c0?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/7674529524c0</guid>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[computação]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Caio Volpato]]></dc:creator>
            <pubDate>Tue, 12 Jul 2022 16:29:24 GMT</pubDate>
            <atom:updated>2022-07-12T16:29:24.845Z</atom:updated>
            <content:encoded><![CDATA[<p>Lembra quando precisou configurar pela primeira vez seu computador? Possivelmente precisou instalar o git, docker, VSCode, um navegador decente, um <a href="https://medium.com/computando-arte/oh-my-zsh-deixando-seu-terminal-mais-interessante-61a34b3f8fde?source=collection_home---2------20-----------------------">shell bacana como o zsh</a>, mó trampo né?</p><p>Hoje vamos falar de uma ferramenta de automação de configuração, o Ansible, que permite que a configuração e manutenção dos ambientes seja feita de forma automatizada, poupando bastante tempo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/0*lfAs-2ihncHR4ZSa" /><figcaption>logo do ansible</figcaption></figure><p>O que é o Ansible? O <a href="https://www.ansible.com/">Ansible</a> é uma ferramenta de automação de configuração e manutenção de ambientes, e atua agilizando e escalando essas atividades.</p><p>As principais vantagens do Ansible são sua facilidade de aprendizado, e não ter a necessidade de instalar um agente da ferramenta nas máquinas gerenciadas. A desvantagem acaba sendo que como não existe um agente executando o Ansible este processo não escala bem, ou seja para gerenciar muitos computadores o nó de controle do Ansible precisa ser potente.</p><h3>Instalando o Ansible</h3><p>Para instalar o Ansible é necessária a instalação da linguagem python e então basta instalar o executável através do pip install</p><blockquote>pip install ansible</blockquote><p>Uma funcionalidade que gosto muito no python são os ambientes virtuais (venv), eles são nativos da linguagem e permitem que você possa ter um “ambiente python” diferente para cada projeto, e assim instalar as dependências adequadas de cada projeto sem interferir nos demais.</p><p>Normalmente o venv fica dentro da pasta do projeto, e é ignorado no .gitignore. Para criar o venv faça</p><blockquote>python3 -m venv venv</blockquote><p>Agora toda vez que for utilizar o venv ative com:</p><blockquote>source venv/bin/activate</blockquote><p>Obs: se estiver usando zsh ou outro shell coloque a extensão do seu shell (no zsh ficaria activate.zsh).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/0*N-PP_7spcrUAXUy8" /></figure><p>Repare que o prompt (PS1) ficou diferente, contendo o nome do venv (venv).</p><p>Para evitar problemas, a primeira vez que crio o venv atualizo o pip e outras ferramentas:</p><blockquote>pip install -U pip setuptools wheel</blockquote><p>Com venv criado basta só instalar o ansible normalmente (pip install ansible).</p><p>Bora testar a instalação? Rode o seguinte</p><blockquote>ansible -m ping localhost</blockquote><p>Se tiver a seguinte saída significa que deu bom:</p><blockquote>[WARNING]: No inventory was parsed, only implicit localhost is available</blockquote><blockquote>localhost | SUCCESS =&gt; {</blockquote><blockquote>“changed”: false,</blockquote><blockquote>“ping”: “pong”</blockquote><blockquote>}</blockquote><p>Bora para o hello world?</p><blockquote>ansible localhost -a “/bin/echo ola mundo”</blockquote><blockquote>[WARNING]: No inventory was parsed, only implicit localhost is available</blockquote><blockquote>localhost | CHANGED | rc=0 &gt;&gt;</blockquote><blockquote><strong>ola mundo</strong></blockquote><h3>Como o Ansible funciona?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/593/0*lZXJ3aNrsDMES4IK" /></figure><p>O Ansible é executado no nó de controle e conecta via o protocolo ssh nos nós gerenciados. Para executar a ferramenta recebe como entrada um arquivo de texto que é o inventário com informações dos nós gerenciados, como os IPs e credenciais. A outra entrada é o playbook, um arquivo no formato yaml, que contém as instruções a serem executadas.</p><p>Um requisito para o ansible é que os nós gerenciados precisam do python instalado, porém é possível rodar o ansible de forma limitada para instalar o python para contornar isso ;)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/0*CL8Voej2630ewFCC" /><figcaption>Fonte: <a href="https://twitter.com/scienceshitpost">https://twitter.com/scienceshitpost</a></figcaption></figure><h3>Montando o inventário</h3><p>Antes de montar o inventário precisamos de pelo menos uma máquina para conectarmos via ssh, no meu caso utilizei uma raspberrypi e uma máquina virtual. Sem enrolação, vamos ao inventário:</p><p>inventario.ini:</p><blockquote>[pies]</blockquote><blockquote>rpi4 ansible_host=192.168.1.205 ansible_user=piuser ansible_password=pipass ansible_become=yes</blockquote><blockquote>[vms]</blockquote><blockquote>rockylinux ansible_host=192.168.121.182 ansible_user=rockyuser ansible_password=rockypass</blockquote><blockquote>[vms:vars]</blockquote><blockquote>ansible_become=yes</blockquote><blockquote>[all:vars]</blockquote><blockquote>ansible_port=22</blockquote><blockquote>ansible_become_method=sudo</blockquote><blockquote>ansible_python_interpreter=python3</blockquote><blockquote>ansible_become_password=”{{ ansible_password }}”</blockquote><p>O inventário pode ser escrito no <a href="https://en.wikipedia.org/wiki/INI_file">formato ini</a> ou no formato yaml, aqui optei pelo ini.</p><p>Nesse exemplo foram definidas duas máquinas a rpi4 pertencente ao grupo pies e rockylinux pertencente ao grupo vms.</p><p><em>E essas variáveis</em>?</p><ul><li><strong>ansible_host</strong> é o ip ou domínio da máquina.</li><li><strong>ansible_port</strong> é porta usada pelo ssh, por padrão é a 22, ou seja nem precisaríamos mudar no nosso caso.</li><li><strong>ansible_user</strong> e <strong>ansible_password </strong>usuário e senha do ssh utilizados para conectar.</li><li><strong>ansible_become</strong> indica se deve elevar privilégios ou não, ou seja rodar como usuário root.</li><li><strong>ansible_become_method </strong>indica o método utilizado para elevar privilégios, aqui estamos utilizando o sudo, mas poderia ser su e utilizar a senha do root.</li></ul><p>O inventário pode ser montado de diversas formas e tem várias outras variáveis, consulte a documentação para saber mais: <a href="https://docs.ansible.com/ansible/latest/user_guide/intro_inventory.html">How to build your inventory</a>. Uma coisa que gosto de fazer é utilizar a opção <strong>ansible_ssh_common_args</strong> com <strong>-F ssh_config</strong>, onde ssh_config (<a href="https://man.openbsd.org/ssh_config">man page</a>) é um arquivo de configuração do ssh.</p><p>As vezes não conseguimos acessar diretamente todas as máquinas, pois é exposto apenas uma máquina, chamada de bastião que atua como proxy para acessar as outras máquinas dentro da rede privada. No ssh_config podemos usar a opção <strong>ProxyJump</strong>.</p><p>Outra vantagem é que fica mais fácil de acessar manualmente uma máquina, basta fazer <strong>ssh -F ssh_config nome_maquina</strong> e pronto ;)</p><p>Bora testar o inventário? Rode</p><blockquote>ansible -m ping -i inventario.ini all</blockquote><p>Putz, deu ruim, <strong>to use the ‘ssh’ connection type with passwords or pkcs11_provider, you must install the sshpass program . </strong>Por padrão o ansible conecta autenticando com chaves ssh, não a senha, então precisamos instalar o sshpass. Bastou um <strong>sudo apt install sshpass</strong> , pra quem tem mac tem um pacote no brew (brew install hudochenkov/sshpass/sshpass).</p><p>Agora foi:</p><blockquote>rockylinux | SUCCESS =&gt; {</blockquote><blockquote>“changed”: false,</blockquote><blockquote>“ping”: “pong”</blockquote><blockquote>}</blockquote><blockquote>rpi4 | SUCCESS =&gt; {</blockquote><blockquote>“changed”: false,</blockquote><blockquote>“ping”: “pong”</blockquote><blockquote>}</blockquote><h3>Rodando comandos adhoc</h3><p>Até aqui só fizemos <strong>-m ping</strong>, mas podemos fazer praticamente qualquer coisa, no ansible as tarefas são executadas através de módulos e vamos mostrar alguns deles aqui.</p><p>Caso não seja especificado nenhum módulo o ansible executa por padrão o módulo command, vou executar o comando hostnamectl, que exibe diversas informações do computador:</p><blockquote>ansible -i inventario.ini -a hostnamectl all</blockquote><blockquote>rockylinux | CHANGED | rc=0 &gt;&gt;</blockquote><blockquote>Static hostname: localhost.localdomain</blockquote><blockquote>Icon name: computer-vm</blockquote><blockquote>Chassis: vm</blockquote><blockquote>Machine ID: 3d137ab51d6c4a1098281d0f08170bce</blockquote><blockquote>Boot ID: 95f4fb49069040b484410562dbbf344c</blockquote><blockquote>Virtualization: kvm</blockquote><blockquote>Operating System: Rocky Linux 8.6 (Green Obsidian)</blockquote><blockquote>CPE OS Name: cpe:/o:rocky:rocky:8:GA</blockquote><blockquote>Kernel: Linux 4.18.0–372.9.1.el8.x86_64</blockquote><blockquote>Architecture: x86–64</blockquote><blockquote>rpi4 | CHANGED | rc=0 &gt;&gt;</blockquote><blockquote>Static hostname: rpi4</blockquote><blockquote>Icon name: computer</blockquote><blockquote>Machine ID: 8e5eb04e49a74e26952554ad422b19fb</blockquote><blockquote>Boot ID: 18563abe0fa6420fb55488b28401304e</blockquote><blockquote>Operating System: Debian GNU/Linux 11 (bullseye)</blockquote><blockquote>Kernel: Linux 5.10.0–15-arm64</blockquote><blockquote>Architecture: arm64</blockquote><p>Deu bom! Conseguimos visualizar as infos sobre as máquinas. Por curiosidade, <em>qual é desse rockylinux</em>? A redhat descontinuou o centos em dez/2020, que é uma versão gratuita e comunitária do redhat enterprise linux (RHEL) e com o fim do centos dois projetos surgiram como sucessores compatíveis ao centos, o rockylinux e o almalinux.</p><p>Bora instalar um pacote como o neofetch? <em>Só mandar um sudo apt install neofetch, certo</em>? No nosso caso uma máquina tem uma distro baseada em redhat ou seja não utiliza o gerenciador de pacotes apt, mas o dnf. Por isso vamos utilizar o módulo package que é genérico e funciona com diversos gerenciadores de pacotes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/302/0*J10JQ-13f_2N2Du8" /><figcaption><a href="https://xkcd.com/1654/">xkcd #1654</a></figcaption></figure><p>Vendo a documentação do <a href="https://docs.ansible.com/ansible/2.9/modules/package_module.html#package-module">módulo package</a>, temos 3 argumentos, dos quais apenas 2 são obrigatórios, o nome dos pacotes (name) e o estado (state) como instalado (present) ou removido (absent).</p><blockquote>ansible -i inventario.ini -m package -a “name=neofetch state=present” all</blockquote><blockquote>rpi4 | CHANGED =&gt; {</blockquote><blockquote>“cache_update_time”: 1655557364,</blockquote><blockquote>“cache_updated”: false,</blockquote><blockquote>“changed”: true,</blockquote><blockquote>“stderr”: “”,</blockquote><blockquote>“stderr_lines”: [],</blockquote><blockquote>“stdout”: “Reading package lists…\nBuilding dependency tree… […]</blockquote><p>Rodando o neofetch: <strong>ansible -i inventario.ini -a neofetch all</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/0*ui7KSOvrZagnOsRc" /></figure><p>Uma opção que facilita muito é a –limit que como o nome sugere limita a execução a algumas máquinas, pode ser especificada múltiplas vezes. Até então utilizamos o all que executa em todas as máquinas. Você pode trocar o all por um grupo(s) ou máquina(s) . E também podemos limitar qual não queremos que sejam incluídas, utilizando o ! como operador de negação.</p><p>Por exemplo, queremos reiniciar todas as máquinas, excepto as que pertencem ao grupo vms:</p><blockquote>ansible -i inventario.ini -m reboot all — limit !vms</blockquote><blockquote>rpi4 | CHANGED =&gt; {</blockquote><blockquote>“changed”: true,</blockquote><blockquote>“elapsed”: 68,</blockquote><blockquote>“rebooted”: true</blockquote><blockquote>}</blockquote><h3>Usando o ansible-vault para proteger segredos</h3><p>Quando criamos o inventário, colocamos as credenciais de acesso, isso não é uma boa prática pois pode acabar expondo essas credenciais. O que podemos fazer nesses casos?</p><p>Uma opção simples é tirar as senhas do inventário e digitar apenas quando precisar, utilizando as opções — ask-pass (ou abreviando -k) e — ask-become-pass (abreviando -K).</p><p>Mas vamos focar na abordagem do ansible-vault, que funciona como um gerenciador de senhas, onde os segredos ficam armazenados em um arquivo que está protegido por uma única senha.</p><p>Para usar o ansible-vault vamos primeiro tirar as senhas do inventário:</p><p>inventario.ini</p><blockquote>[pies]</blockquote><blockquote>rpi4 ansible_host=192.168.1.205 ansible_user=piuser ansible_password=”{{ rpi4_pass }}”</blockquote><blockquote>[vms]</blockquote><blockquote>rockylinux ansible_host=192.168.121.182 ansible_user=rockyuser ansible_password=”{{ rocky_vm_pass }}”</blockquote><blockquote>[all:vars]</blockquote><blockquote>ansible_become=yes</blockquote><blockquote>ansible_become_method=sudo</blockquote><blockquote>ansible_python_interpreter=python3</blockquote><blockquote>ansible_become_password=”{{ ansible_password }}”</blockquote><p>Repare que em ambas as máquinas a variável a <strong>ansible_password</strong> estão sendo recebidas como referência.</p><p>Crie um arquivo que vamos chamar de vault.yml</p><p>vault.yml</p><blockquote>— -</blockquote><blockquote>rpi4_pass: ‘pipass’</blockquote><blockquote>rocky_vm_pass: ‘rockypass’</blockquote><p>Agora que a mágica acontece, vamos criptografar o arquivo: ansible-vault encrypt vault.yml e digite a senha desejada. Por curiosidade, bora ver o conteúdo do arquivo?</p><blockquote>$ANSIBLE_VAULT;1.1;AES256</blockquote><blockquote>33303863323038363938333365326637343733313432626231623735666433303965333266383934</blockquote><blockquote>6332633534626465353436666539646466633633393362370a353161653663633263663635643466</blockquote><blockquote>…</blockquote><p>Quando precisar editar o vault, basta fazer <strong>ansible-vault edit vault.yml</strong></p><p>E para carregar os segredos definidos no vault vamos usar a opção — extra-vars (abreviada por -e) onde podemos fazer -e “var=value” mas vamos apontar para um arquivo então -e @vault.yml. E a opção — ask-vault-pass para entrar com a senha do vault</p><blockquote>ansible -i inventario.ini -m ping all -e @vault.yml — ask-vault-pass</blockquote><blockquote>rockylinux | SUCCESS =&gt; {</blockquote><blockquote>“changed”: false,</blockquote><blockquote>“ping”: “pong”</blockquote><blockquote>}</blockquote><blockquote>rpi4 | SUCCESS =&gt; {</blockquote><blockquote>“changed”: false,</blockquote><blockquote>“ping”: “pong”</blockquote><blockquote>}</blockquote><p><em>Preciso digitar a senha do vault toda vez</em>? Não necessariamente, uma abordagem é colocar a senha em um arquivo local e utilizar a opção — vault-password-file , mas sou preguiçoso :P e vou deixar configurado em um arquivo de configuração, o ansible.cfg edai fica tudo setado lá 😊</p><p>ansible.cfg:</p><blockquote>[defaults]</blockquote><blockquote>host_key_checking = True</blockquote><blockquote>inventory = inventario.ini</blockquote><blockquote>vault_password_file = ../.arquivo_com_a_senha.txt</blockquote><p>Documentação com todas opções do ansible.cfg: <a href="https://docs.ansible.com/ansible/latest/reference_appendices/config.html">Ansible Configuration Settings</a></p><p>Outra abordagem é a conhecida pela buzzword GitOps, que consiste em rodar o ansible no próprio repositório onde ficam os playbooks do ansible, utilizando um sistema de integração contínua, como <a href="https://medium.com/computando-arte/introdu%C3%A7%C3%A3o-a-ci-no-github-actions-5b6e9ad1bb64?source=collection_home---2------5-----------------------">github actions que falamos anteriormente aqui</a>. Dessa forma a senha do vault pode ser passada via variável de ambiente e colocada em temporariamente um arquivo ou via argumento do comando.</p><h3>Escrevendo nosso primeiro playbook</h3><p>Chegou a hora! Bora escrever nosso primeiro playbook. Para isso vamos subir um servidor web, o apache, para hospedar um site um site estático.</p><p>Quando fui instalar o apache no rockylinux deu ruim, porque o pacote no debian é o apache2 mas no rockylinux é httpd. <em>Como faz agora</em>? <em>Como eu faço pro ansible detectar que a máquina é o rockylinux ou debian e tratar adequadamente cada caso</em>?</p><p>A ferramenta roda automaticamente um módulo chamado setup que obtém diversas infos das máquinas, e disponibiliza em uma variável chamada ansible_facts .</p><p>Fazendo <strong>ansible -m setup -e @vault.yml all</strong> obtive:</p><blockquote>rpi4 | SUCCESS =&gt; {</blockquote><blockquote>“ansible_facts”: {</blockquote><blockquote>“ansible_all_ipv4_addresses”: [</blockquote><blockquote>“192.168.1.205”</blockquote><blockquote>],</blockquote><blockquote>[…]</blockquote><blockquote><strong>“ansible_distribution”: “Debian”,</strong></blockquote><blockquote>“ansible_distribution_file_parsed”: true,</blockquote><blockquote>“ansible_distribution_file_path”: “/etc/os-release”,</blockquote><blockquote>“ansible_distribution_file_variety”: “Debian”,</blockquote><blockquote>“ansible_distribution_major_version”: “11”,</blockquote><blockquote>“ansible_distribution_release”: “bullseye”,</blockquote><blockquote>“ansible_distribution_version”: “11”,</blockquote><blockquote><strong>“ansible_os_family”: “Debian”,</strong></blockquote><blockquote>[…]</blockquote><blockquote>}</blockquote><blockquote>rockylinux | SUCCESS =&gt; {</blockquote><blockquote>“ansible_facts”: {</blockquote><blockquote>“ansible_all_ipv4_addresses”: [</blockquote><blockquote>“192.168.121.182”</blockquote><blockquote>],</blockquote><blockquote>[…]</blockquote><blockquote><strong>“ansible_distribution”: “Rocky”,</strong></blockquote><blockquote>“ansible_distribution_file_parsed”: true,</blockquote><blockquote>“ansible_distribution_file_path”: “/etc/redhat-release”,</blockquote><blockquote>“ansible_distribution_file_variety”: “RedHat”,</blockquote><blockquote>“ansible_distribution_major_version”: “8”,</blockquote><blockquote>“ansible_distribution_release”: “Green Obsidian”,</blockquote><blockquote>“ansible_distribution_version”: “8.6”,</blockquote><blockquote><strong>“ansible_os_family”: “RedHat”,</strong></blockquote><blockquote>[…]</blockquote><blockquote>}</blockquote><p>Com isso, podemos usar a variável ansible_distribution (Debian e Rocky) ou ansible_os_family (Debian e RedHat), optei pela ansible_os_family para que nosso playbook seja mais genérico.</p><p>playbook.yml:</p><blockquote>— -</blockquote><blockquote>- name: Configura um site estatico.</blockquote><blockquote>hosts: all</blockquote><blockquote>become: true</blockquote><blockquote>vars:</blockquote><blockquote>apache_name_dict:</blockquote><blockquote>“Debian”: apache2</blockquote><blockquote>“RedHat”: httpd</blockquote><blockquote>handlers:</blockquote><blockquote>- name: restart apache</blockquote><blockquote>service:</blockquote><blockquote>name: “{{ apache_name_dict[ansible_os_family] }}”</blockquote><blockquote>state: restarted</blockquote><blockquote>tasks:</blockquote><blockquote>- name: Instala o apache.</blockquote><blockquote>package:</blockquote><blockquote>name: “{{ apache_name_dict[ansible_os_family] }}”</blockquote><blockquote>state: present</blockquote><blockquote>- name: Copia o html da pag.</blockquote><blockquote>copy:</blockquote><blockquote>src: page.html</blockquote><blockquote>remote_src: no</blockquote><blockquote>dest: “/var/www/html/index.html”</blockquote><blockquote>mode: 0664</blockquote><blockquote>notify: restart apache</blockquote><blockquote>- name: Habilita o servico do apache.</blockquote><blockquote>service:</blockquote><blockquote>name: “{{ apache_name_dict[ansible_os_family] }}”</blockquote><blockquote>state: started</blockquote><blockquote>enabled: true</blockquote><p>O playbook funciona da seguinte forma:</p><ol><li>Primeiro é instalado o pacote do apache, usando uma variável para mapear o nome correto do pacote.</li><li>Copia o html do nosso site, o html precisa estar localizado ao lado do playbook, mas caso o arquivo já estivesse no nó gerenciado basta trocar a opção remote_src para yes.</li><li>Habita o serviço do apache para que o mesmo seja iniciado automaticamente quando a máquina é iniciada.</li></ol><p>O que é esse notify na task de copiar o html? Pense no seguinte: depois de copiar o html preciso que o apache seja reiniciado para carregar o html da página que acabamos de enviar, mas e se o html que estiver lá não foi alterado? Dessa forma o Ansible só reinicia o apache caso necessário, chamando o handler previamente definido.</p><p>Bora escrever sem usar o handler, pra ficar mais claro?</p><p>playbook2.yml:</p><blockquote>— -</blockquote><blockquote>- name: Configura um site estatico.</blockquote><blockquote>hosts: all</blockquote><blockquote>become: true</blockquote><blockquote>vars:</blockquote><blockquote>apache_name_dict:</blockquote><blockquote>“Debian”: apache2</blockquote><blockquote>“RedHat”: httpd</blockquote><blockquote>tasks:</blockquote><blockquote>- name: Instala o apache.</blockquote><blockquote>package:</blockquote><blockquote>name: “{{ apache_name_dict[ansible_os_family] }}”</blockquote><blockquote>state: present</blockquote><blockquote>- name: Copia o html da pag.</blockquote><blockquote>copy:</blockquote><blockquote>src: page.html</blockquote><blockquote>remote_src: no</blockquote><blockquote>dest: “/var/www/html/index.html”</blockquote><blockquote>mode: 0664</blockquote><blockquote>register: html_copy</blockquote><blockquote>- name: restart apache.</blockquote><blockquote>service:</blockquote><blockquote>name: “{{ apache_name_dict[ansible_os_family] }}”</blockquote><blockquote>state: restarted</blockquote><blockquote>when: html_copy.changed</blockquote><blockquote>- name: Habilita o servico do apache.</blockquote><blockquote>service:</blockquote><blockquote>name: “{{ apache_name_dict[ansible_os_family] }}”</blockquote><blockquote>state: started</blockquote><blockquote>enabled: true</blockquote><p>Nessa versão do playbook, repare que na task de copiar o html estamos fazendo register: html_copy como o nome sugere estamos registrando o resultado daquela task em uma variável. E na task de reiniciar o apache é acionada apenas quando mudou, em when: html_copy.changed.</p><p>Para rodar o comando é sugestivo: <strong>ansible-playbook -e @vault.yml playbook.yml</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CpPImRe9iDrqhp8o" /></figure><p>Será que o site tá de pé? Abrindo o navegador no ip da VM:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/589/0*kgyMFw6h5409gKnS" /></figure><p>Uma coisa que você precisa ficar de olho quando escreve seus playbooks é se eles são idempotentes, que significa que o efeito de rodar o playbook é o mesmo independente de quantas vezes o mesmo foi executado. Para quem curte linguagens funcionais tá ligado qualé: O playbook não pode ter efeitos colaterais.</p><p>Na prática, assim que rodar a primeira vez execute novamente e veja no final se teve alguma task como changed.</p><p>O principal desafio para tornar os playbooks idempotentes acontece quando as tasks são do tipo command ou shell, afinal como o ansible vai saber se a task foi executada anteriormente com sucesso?</p><p>Nesses casos, uma possibilidade é utilizar o parâmetro chamado creates, disponível nos módulos de command e shell, que aponta para um arquivo marcador que seu shell script ou command precisa criar quando executado com sucesso.</p><p>Bora ver na prática?</p><p>playbook3.yml:</p><blockquote>— -</blockquote><blockquote>- hosts: all</blockquote><blockquote>become: true</blockquote><blockquote>tasks:</blockquote><blockquote>- name: inicializa um arquivo</blockquote><blockquote>shell: echo “passei por aqui” &gt; /etc/marcador_xpto.txt</blockquote><blockquote>args:</blockquote><blockquote>creates: /etc/marcador_xpto.txt</blockquote><p>Repare que quando executamos a primeira vez no recap a task foi changed, mas na segunda vez não houve mudanças.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hOZaw96yAsGjrPij" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pIl0ag4ApIPvgGZA" /></figure><p>Quem tiver interesse, tem um texto excelente que até saiu no hacker news com várias dicas de como escrever scripts bash idempotentes: <a href="https://arslan.io/2019/07/03/how-to-write-idempotent-bash-scripts/">How to write idempotent Bash scripts · Fatih Arslan</a></p><h3>Conclusão</h3><p>Uma regra de ouro é: Antes de sair automatizando, primeiro documente o processo manual, quais recursos sua aplicação precisa? Com os recursos disponíveis, como deve ser feita a configuração da aplicação? Dessa forma fica fácil de vislumbrar o todo e não precisa sair caçando nos códigos. Apesar do manifesto ágil dar preferência a ter um software funcional a documentação abrangente, sugiro não deixar de documentar no início essas definições.</p><p>Para aprender ansible, a melhor referência é o livro do Jeff Geerling, <a href="https://www.ansiblefordevops.com/">Ansible for DevOps</a> o livro tem vários exemplos e dicas. Pra quem prefere o formato de vídeos, no início da pandemia o autor trouxe o conteúdo do livro em forma de lives: <a href="https://www.youtube.com/watch?v=goclfp6a2IQ&amp;list=PL2_OBreMn7FqZkvMYt6ATmgC0KAGGJNAN">Ansible 101 — Episode 1 — Introduction to Ansible</a>. E pra quem prefere ir direto nos códigos os exemplos estão disponíveis nesse github: <a href="https://github.com/geerlingguy/ansible-for-devops">github.com/geerlingguy/ansible-for-devops</a></p><p>Obrigado por acompanhar esse texto, espero que te ajude, caso tenha algum feedback ou dúvida não hesite em entrar em contato.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7674529524c0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/ansible-localhost-a-bin-echo-primeiros-passos-com-o-ansible-7674529524c0">ansible localhost -a “/bin/echo Primeiros passos com o Ansible”</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como rodar Jupyter Notebooks dentro do Docker]]></title>
            <link>https://medium.com/computando-arte/como-rodar-jupyter-notebooks-dentro-do-docker-60625bf1234e?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/60625bf1234e</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[jupyter-notebook]]></category>
            <category><![CDATA[docker-container]]></category>
            <dc:creator><![CDATA[Erica Bertan]]></dc:creator>
            <pubDate>Wed, 25 May 2022 11:35:53 GMT</pubDate>
            <atom:updated>2022-05-25T11:35:53.056Z</atom:updated>
            <content:encoded><![CDATA[<h4>Um passo-a-passo de como montar sua imagem preparada para rodar Jupyter Notebooks</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZWfbdMW8B5u7us49gEQMPg.png" /></figure><p>Para fazer provas de conceito, scripts curtos e descartáveis, até mesmo análises de dados complexas, muita gente já precisou usar um notebook. A popularidade da ferramenta é compreensível, visto que ela é bem prática e visual. Inclusive, usando ferramentas como o <a href="https://colab.research.google.com/">Colab</a>, o esforço de preparação do ambiente é nulo!</p><p>Mas você não estaria nesse artigo se não tivesse passado da parte de preparação. Seu projeto avançou bastante e você começou a ter que compartilhar o arquivo do notebook com terceiros para que eles pudessem testar e experimentar novas coisas. Repassá-lo começou a ficar inconveniente, mesmo com mecanismos de versionamento:</p><ul><li>Para rodar seu notebook, é necessário ter um algumas libs instaladas na sua máquina. A versão que você utiliza é diferente da máquina dos colegas e os primeiros bugs por esse motivo começam a aparecer;</li><li>Ou seu notebook começa a exigir muitos recursos da sua máquina e fica à beira do impraticável continuar usando seu laptop enquanto ele roda;</li><li>Ou o projeto avança bastante a ponto de você precisar migrar esse notebook para um ambiente remoto, e continuar fazendo modificações no código com pouco esforço de replicação se torna uma tarefa onerosa.</li></ul><p>Ou todos esses problemas ao mesmo tempo e muito mais. É nesse momento que talvez você possa considerar usar notebooks dentro de containers, e isso traz muitas vantagens:</p><ul><li><strong>Facilidade de replicação</strong> do ambiente quando mais de uma pessoa precisa usá-lo;</li><li><strong>Garantia de isolamento</strong> do ambiente, o que também torna o primeiro ponto possível. Uma vez que você prepara seu container, os processos do dentro dele rodam sem interferência das configurações da máquina host, ou seja, resolve o famoso “<em>na minha máquina funciona</em>” 😄;</li><li><strong>Facilitar gerenciamento de recursos</strong>, uma vez que você pode alocar e desalocar facilmente os recursos do seu container a medida que for necessário.</li></ul><p>Então, neste artigo meu objetivo é mostrar um passo a passo de como construir sua imagem Docker para rodar notebooks para facilitar seu dia a dia.</p><p><em>* A leitura do artigo vai ser mais fácil e fluida se você acompanhar o que for dito com o projeto completo no repositório </em><a href="https://github.com/ericabertan/jupyter-boilerplate"><em>jupyter-boilerplate no meu Github</em></a><em>.</em></p><p><em>** Aqui vou assumir que conhecimentos básicos como Docker e Notebooks já são conhecidos pelo leitor.</em></p><h4>📌 Docker entra no chat: montando uma imagem</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*H9bcub9hPo2hSB3QorAVNA.jpeg" /><figcaption>Fonte:<a href="https://blog.container-solutions.com/docker-to-kubernetes"> Jérôme Petazzoni</a></figcaption></figure><p><strong>1. Preparando o requirements.txt</strong></p><p>Para preparar uma imagem, possivelmente vamos precisar instalar algumas bibliotecas que não existem previamente na imagem base que estamos usando. Por isso, crie um arquivo requirements.txt com todas as libs que você precisa.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/920085227e7203b8ae63bfde596c03d2/href">https://medium.com/media/920085227e7203b8ae63bfde596c03d2/href</a></iframe><p><strong>2. Configurando o Dockerfile</strong></p><p>O Docker consegue construir imagens a partir das instruções que ele lê em um arquivo chamado Dockerfile. O nosso vai ser curto e fácil de entender. Veja no arquivo abaixo que explicarei linha por linha.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b97fb54695d9b20662f10bdffd943d30/href">https://medium.com/media/b97fb54695d9b20662f10bdffd943d30/href</a></iframe><ul><li>Linha 1: o comando FROM indica que estamos começando a construir uma imagem, e com ele setamos a imagem base usada para construir a nossa. Como boa prática, sempre use imagens oficiais. (<a href="https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#from">Guia para boas práticas de escrita do Dockerfile</a>);</li><li>Linha 3: com o comando WORKDIR setamos o diretório de trabalho, ou seja, quando você subsequentemente rodar um comando ADD, COPY, RUN, etc, esses comandos serão executados nesse diretório. Um meio de ver isso na prática é entrar no shell do container que está de pé, pois é nesse diretório que seremos jogados;</li><li>Linha 4: O comando ADD copia arquivos de algum lugar de origem para o sistema de arquivos da imagem. No caso, o requirements.txt é que está sendo copiado para dentro da nossa imagem;</li><li>Linha 5: O RUN executa comandos, e no nosso caso, ele roda o pip para instalar todas as libs que adicionamos anteriormente no arquivo requirements.txt.</li></ul><p>Pronto, temos a definição da nossa imagem. Agora, vamos preparar as configurações para lidar com esse container em produção através de um arquivo de especificação do docker-compose.</p><p><strong>3. Criando o docker-compose.yml</strong></p><p>Você deve estar se perguntando (e com razão) por que precisamos dessa etapa. Para isso, vale explicar a diferença entre usar o docker e o docker-compose: enquanto o primeiro está preparado para lidar com um container, o segundo consegue lidar com vários — o que é bastante útil em produção.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f24f9cab07c29a4b0f8855c2521bf531/href">https://medium.com/media/f24f9cab07c29a4b0f8855c2521bf531/href</a></iframe><ul><li>Linha 4: aqui precisamos definir o nome do serviço, que no caso é o jupyter_service. Este arquivo pode ter vários outros serviços, a depender da necessidade;</li><li>Linha 5: o . indica que o Dockerfile vai ser procurado na raiz do projeto para que a imagem possa ser construída. A <a href="https://docs.docker.com/compose/compose-file/build/">documentação do Compose</a> dá uma boa ideia sobre o funcionamento desse comando;</li><li>Linha 6: o entrypoint sobrescreve o entrypoint default definido na imagem. Mais na frente, veremos que a definição desse arquivo scripts/docker-entrypoint.sh é apenas um comando que executa o Jupyter Notebooks, ou seja, ao executar o container poderemos acessar a instância do Jupyter dentro dele;</li><li>Linha 7: aqui definimos o usuário que iremos acessar os notebooks de dentro do container, e para fins didáticos, setei o root e para que eu tivesse todas as permissões. Com a ausência dele, só acessaríamos o notebook em modo de leitura;</li><li>Linha 8–9: com o ports eu defino a porta por onde conseguimos acessar o ambiente do Jupyter Notebook dentro do container;</li><li>Linha 10–11: com o comando env_file definimos as nossas variáveis de ambientes que poderão ser acessadas e usadas dentro do container;</li><li>Linha 12–13: volumes valem um artigo separado aqui no Computando Arte, mas por hora, só se precisa entender que uma vez que provisionamos um container, e logo depois desprovisionamos esses recursos, os dados <strong>não</strong> são persistidos. Uma maneira de persisti-los é justamente fazendo o uso de volumes.</li></ul><p><strong>4. Exclua arquivos não necessários com o .dockerignore</strong></p><p>Para quem lida com o git no dia-a-dia, fica trivial entender o propósito do arquivo .dockerignore. De maneira análoga, à medida que for desenvolvendo seu projeto e não quiser que certos arquivos sejam incorporados no build da sua imagem, basta adicionar as extensões .dockerignore e o Docker o ignorará.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3f6ac3c3f4a70e6a71c243aaf90434f4/href">https://medium.com/media/3f6ac3c3f4a70e6a71c243aaf90434f4/href</a></iframe><h4>📌 Rodando um notebook</h4><p>Temos nossa imagem pronta, mas ainda falta passarmos por um ponto crucial: como rodar o notebook dentro do container? É, na verdade, muito simples. Anteriormente, definimos um entrypoint dentro do nosso arquivo docker-compose.yml e ele tinha o valor scripts/docker-entrypoint.sh. Vamos defini-lo agora:</p><p><strong>1. Criando o arquivo scripts/docker-entrypoint.sh</strong></p><p>Vamos começar pelo mais simples, se você tivesse rodando um notebook na sua máquina, você apenas digitaria jupyter notebook e a mágica aconteceria. Aqui, só temos algumas sofisticações a mais, mas é puramente a mesma ideia.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2a73aff26138dad7dbe03bd4e0a14af3/href">https://medium.com/media/2a73aff26138dad7dbe03bd4e0a14af3/href</a></iframe><ul><li>--ip: com este parâmetro estamos definindo o ip por onde conseguiremos acessar o ambiente do Jupyter pelo browser</li><li>--port: com este parâmetro definimos a porta por onde acessaremos o ambiente do Jupyter pelo browser</li><li>--allow-root: como estou rodando o notebook no modo root, na ausência dele o seguinte erro é disparado: “Running as root is not recommended. Use — allow-root to bypass.”. Aqui, o allow-root é apenas uma forma de contornar esse problema.</li></ul><p>E o que significa o PYTHONPATH=$PYTHONPATH:/home/src neste início? Apenas que estamos setando o PYTHONPATH dentro do container como variável de ambiente com os valores já existentes somado ao workdir do container (/home/src), assim o Python consegue enxergar os módulos e pacotes no diretório do container também.</p><p><strong>2. Usando o docker-compose para executar nosso notebook</strong></p><p>Agora podemos testar nosso notebook dentro do container. Para isso, basta executar os comandos</p><ul><li><em>docker-compose build</em>: para construir a imagem e prepará-la para execução no container</li><li><em>docker-compose up</em>: para subir o container. No terminal, deve aparecer um link para clicar e o Jupyter abrir em seu terminal</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1019/1*tHGgsnzeYF41EJ3_N4d2kQ.png" /><figcaption>Links para acessar o Jupyter</figcaption></figure><ul><li><em>docker-compose down</em>: para matar seu container e desalocar os recursos.</li></ul><h4>Conclusão</h4><p>Pronto, agora você pode rodar notebooks dentro de um Docker container. Para construir esse boilerplate e também para o meu dia-a-dia no uso e entendimento de Docker, boa parte do que aprendi foi lendo a documentação do <a href="https://docs.docker.com/compose/compose-file/">Compose</a>, pois ela é bem completa. Então, fica aí a recomendação de leitura!</p><p>E, claro, caso tenha qualquer dúvida, ou mesmo sugestão de melhoria em algum ponto do projeto e do post, fique à vontade para comentar aqui que responderei assim que possível 😃</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60625bf1234e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/como-rodar-jupyter-notebooks-dentro-do-docker-60625bf1234e">Como rodar Jupyter Notebooks dentro do Docker</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como criar um pendrive de instalação com vários sistemas]]></title>
            <link>https://medium.com/computando-arte/como-criar-um-pendrive-de-instala%C3%A7%C3%A3o-com-v%C3%A1rios-sistemas-de380c1e040d?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/de380c1e040d</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[computação]]></category>
            <dc:creator><![CDATA[Caio Volpato]]></dc:creator>
            <pubDate>Mon, 09 May 2022 15:51:44 GMT</pubDate>
            <atom:updated>2022-05-09T15:51:44.489Z</atom:updated>
            <content:encoded><![CDATA[<h3>Conheça o Ventoy, a ferramenta que nos ajuda a fazer isso</h3><p>Quando vou ajudar alguém a formatar seu computador tenho esse problema, preciso levar vários pen drives preparados dependendo de qual sistema a pessoa quer instalar (como o Windows, o Ubuntu, PopOS, Manjaro e etc …). Isso acontece porque só dá para ter um sistema operacional por pen drive.</p><p>Hoje vou falar de uma solução desse problema, criar um pen drive multiboot contendo vários sistemas em um único pen drive, utilizando o Ventoy 🤯</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ukoVyt5RBjXEjxEE" /><figcaption>Marvin Meyer, on <a href="https://unsplash.com/photos/SYTO3xs06fU">unsplash</a></figcaption></figure><h3>Domando o destruidor de discos (dd)</h3><p>Antes de mostrar o esquema multiboot, vou mostrar o esquema tradicional de gravar um pendrive usando o tradicional comando dd no Linux.</p><p>Pra quem usa Windows calma aí que já mostro outra opção.</p><p>A tarefa de gravar um pendrive bootável com o dd consiste de 6 tarefas, são elas:</p><ol><li>Baixar a imagem do sistema operacional.</li><li>Verificar se a imagem não está corrompida ou adulterada.</li><li>Plugando o pendrive e identificando onde “subiu”.</li><li>Fazer um umount no pendrive.</li><li>De fato, gravando a imagem com o dd.</li><li>Removendo o pendrive com segurança.</li><li>Antes de tudo precisamos baixar a imagem .iso, que podemos encontrar no site do Ubuntu (<a href="https://releases.ubuntu.com/">releases.ubuntu.com</a>). Usei o link abaixo:</li></ol><blockquote>wget <a href="https://releases.ubuntu.com/20.04.4/ubuntu-20.04.4-desktop-amd64.iso">https://releases.ubuntu.com/20.04.4/ubuntu-20.04.4-desktop-amd64.iso</a></blockquote><p>2. É de bom tom sempre verificar se imagem iso não está corrompida ou foi adulterada ;) , com este intuito vamos importar a chave de assinatura do ubuntu:</p><blockquote>gpg — keyid-format long — keyserver hkp://keyserver.ubuntu.com — recv-keys 0x46181433FBB75451 0xD94AA3F0EFE21092</blockquote><p>Veja que as chaves foram importadas com sucesso:</p><blockquote>gpg: key D94AA3F0EFE21092: public key “Ubuntu CD Image Automatic Signing Key (2012) &lt;cdimage@ubuntu.com&gt;” imported</blockquote><blockquote>gpg: key 46181433FBB75451: public key “Ubuntu CD Image Automatic Signing Key &lt;cdimage@ubuntu.com&gt;” imported</blockquote><blockquote>gpg: Total number processed: 2</blockquote><blockquote>gpg: imported: 2</blockquote><p>Em seguida vamos baixar os hashes da imagem e a assinatura:</p><blockquote>wget <a href="https://releases.ubuntu.com/20.04.4/SHA256SUMS">https://releases.ubuntu.com/20.04.4/SHA256SUMS</a></blockquote><blockquote>wget <a href="https://releases.ubuntu.com/20.04.4/SHA256SUMS.gpg">https://releases.ubuntu.com/20.04.4/SHA256SUMS.gpg</a></blockquote><p>Verificando a assinatura:</p><blockquote>gpg — verify SHA256SUMS.gpg SHA256SUMS</blockquote><p>Deu bom! Repare no resultado do comando (good signature …)</p><blockquote>gpg: Signature made qui 24 fev 2022 17:36:20 -03</blockquote><blockquote>gpg: using RSA key 843938DF228D22F7B3742BC0D94AA3F0EFE21092</blockquote><blockquote><strong>gpg: Good signature from “Ubuntu CD Image Automatic Signing Key (2012) &lt;cdimage@ubuntu.com&gt;” [unknown]</strong></blockquote><blockquote>gpg: WARNING: This key is not certified with a trusted signature!</blockquote><blockquote>gpg: There is no indication that the signature belongs to the owner.</blockquote><blockquote>Primary key fingerprint: 8439 38DF 228D 22F7 B374 2BC0 D94A A3F0 EFE2 1092</blockquote><p>Por fim, verificando a imagem:</p><blockquote>sha256sum — ignore-missing -c SHA256SUMS</blockquote><blockquote>ubuntu-20.04.4-desktop-amd64.iso: OK</blockquote><p>3. Tá safe! Bora gravar essa imagem. Para isto, antes de plugar o pen drive execute o comando lsblk para listar os dispositivos de armazenamento, então plugue o pendrive e execute o lsblk novamente e veja se “onde o pendrive subiu” (comparando quando rodou o lsblk a primeira vez), isto é, se foi conectado ao sdb, sdc ou sdd etc … Aqui “subiu” como sdb.</p><p>4. Sempre bom fazer umount antes:</p><blockquote>sudo umount /dev/sdb*</blockquote><p>5. Finalmente gravando a imagem:</p><blockquote>sudo dd if=ubuntu-20.04.4-desktop-amd64.iso of=/dev/sdb bs=1M status=progress ; sync</blockquote><p>Aponte para o endereço da imagem no argumento if, e aponte para o endereço do pen drive no argumento of. Preste atenção se de fato está apontando para o pen drive em /dev/sdb, não coloque a partição /dev/sdb1 ou 2, é só sdb!</p><p>Observação: O comando sync faz com que a imagem completa seja de fato escrita no pendrive, não somente no cache.</p><p>6. Espere a gravação finalizar (demora alguns minutos) e por fim vamos remover com segurança o pendrive:</p><blockquote>sudo udisksctl power-off -b /dev/sdb</blockquote><h3>Gravando utilizando o etcher</h3><p>Uma alternativa ao dd é utilizar o etcher, que está disponível no Windows, Mac e Linux, super simples de usar! Basta entrar no site <a href="https://www.balena.io/etcher/">balena.io/etcher/</a> e baixar o programa, então selecionar a imagem iso, o pen drive e clicar em Flash!, conforme a figura abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/0*x3YY2qDDHRCwiM5Z" /></figure><h3>Multiboot com Ventoy</h3><p>Chegou a hora de falar do Ventoy \o/</p><p>Instalar o ventoy é tranquilo, basta ir na pagina de releases no Github do Ventoy <a href="https://github.com/ventoy/Ventoy/releases/">github.com/ventoy/Ventoy/releases/</a>, estou utilizando a versão 1.0.73:</p><blockquote>wget <a href="https://github.com/ventoy/Ventoy/releases/download/v1.0.73/ventoy-1.0.73-linux.tar.gz">https://github.com/ventoy/Ventoy/releases/download/v1.0.73/ventoy-1.0.73-linux.tar.gz</a></blockquote><p>Verificando o download:</p><blockquote>sha256sum ventoy-1.0.73-linux.tar.gz | grep ba1b61864598af2db662e393043c8759213869419ad95adb71fb5d92484f4b7d</blockquote><p>Extraindo o tar:</p><blockquote>tar xvf ventoy-1.0.73-linux.tar.gz</blockquote><p>Gravando o ventoy:</p><blockquote>sudo umount /dev/sdb*</blockquote><blockquote>cd ventoy-1.0.73/</blockquote><blockquote>sudo ./Ventoy2Disk.sh -i /dev/sdb</blockquote><p>Quando finalizar a gravação, basta copiar as isos para uma partição que foi criada e sucesso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/0*IwqNmWvCPoSeIRxg" /></figure><p>Quando ligar o computador, e apertar F12 (ou a tecla do seu fabricante) com esse pendrive a tela do ventoy vai aparecer, no qual você pode escolher qual das imagens será utilizada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*AqkrUToheFTBtJOr" /><figcaption>Captura de tela do Ventoy, Fonte: <a href="https://www.ventoy.net/en/screenshot.html">https://www.ventoy.net/en/screenshot.html</a></figcaption></figure><p>Quando precisar de outro sistema basta colocar a iso na partição do ventoy e usar! Muito prático!</p><p>Testei e funcionou bootar tanto no modo legacy (MBR) quanto UEFI ^_^</p><p>Adorei o Ventoy :) daqui para frente só preciso de um pendrive na minha caixa de ferramentas quando for atender alguém.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de380c1e040d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/como-criar-um-pendrive-de-instala%C3%A7%C3%A3o-com-v%C3%A1rios-sistemas-de380c1e040d">Como criar um pendrive de instalação com vários sistemas</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SQL: As funções LAG e LEAD [5/5]]]></title>
            <link>https://medium.com/computando-arte/sql-as-fun%C3%A7%C3%B5es-lag-e-lead-5-5-ebfc97f79791?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/ebfc97f79791</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[data-analysis]]></category>
            <dc:creator><![CDATA[Erica Bertan]]></dc:creator>
            <pubDate>Thu, 21 Apr 2022 13:58:24 GMT</pubDate>
            <atom:updated>2022-04-21T13:58:24.845Z</atom:updated>
            <content:encoded><![CDATA[<h4>Veja como obter o registro anterior ou posterior de um campo de uma forma bem simples.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IijUm0e5Xwy91oqlPBsQaQ.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@vidarnm?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Vidar Nordli-Mathisen</a> on <a href="https://unsplash.com/s/photos/next-step?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><h4>Disclaimer</h4><p>Nesta série de 5 posts, gostaria de compartilhar com vocês alguns comandos que tive contato recentemente em SQL e que considero muito úteis! Se você ainda não leu os outros artigos, sugiro começar pelo primeiro post da série, onde falo sobre as funções <a href="https://medium.com/computando-arte/sql-as-fun%C3%A7%C3%B5es-greatest-e-least-1-5-aeaf4dcf21b6">Greatest and Least</a>.</p><h4>O que são essas funções e para que servem?</h4><p>Em termos simples, a função LAG permite o acesso a uma linha anterior à linha atual, ao passo que a função LEAD permite o acesso a uma linha posterior. Vamos para um exemplo para ficar mais inteligível:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/545/1*dJIYp8OH_XGJmTQM2uP3_A.png" /><figcaption>Figura 1. Tabela de preços de iPhone ao longo dos anos.</figcaption></figure><p>Imagine uma tabela de preços de iPhone ao longo dos anos, como na Figura 1. Queremos saber para cada ano qual foi o preço do iPhone no ano anterior e no ano posterior. O resultado que buscamos está esquematizado na Figura 2:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*8IN6OsCw2EKA-1X-8OSBZA.png" /><figcaption>Figura 2. Preços dos iPhones nos anos anteriores e posteriores.</figcaption></figure><p>As funções LAG e LEAD nos ajudariam a produzir justamente esse resultado. Bem útil, não é mesmo? Vamos ver na prática como fica o código em SQL.</p><h4><strong>Exemplo: Quais os termos de busca mais buscados no Amazonas ao longo de cada semana do ano de 2022?</strong></h4><p>Vamos mudar um pouco o conjunto de dados para esse último post da série. Iremos explorar um pouco a <a href="https://cloud.google.com/blog/products/data-analytics/international-google-trends-datasets-in-bigquery">base de dados pública do BigQuery</a> que contém os top termos de busca do Google no mundo. Nossa consulta para a pergunta do exemplo fica assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/61f8a6e18dbb50ce7e3369379d4482e2/href">https://medium.com/media/61f8a6e18dbb50ce7e3369379d4482e2/href</a></iframe><p>E produzimos uma série de registros com os termos mais acessados por semana no ano de 2022, como ilustrado na Figura 3. Você também pode <a href="https://console.cloud.google.com/bigquery?sq=229919784316:ec09aa0b8ab9441f9561f220a63415c7">rodar a query de exemplo no BigQuery</a> e até tentar fazer de outras formas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/856/1*mbR8gqPBBJ7TiIaCylGUIw.png" /><figcaption>Figura 3. Top termos buscados no Amazonas por semana no ano de 2022.</figcaption></figure><p>Ok, mas você pode estar se perguntando onde o LAG e o LEAD entram, certo? Vamos repetir a mesma ideia do exemplo do iPhone aqui no exemplo dos top termos buscados no Amazonas, e vamos adicionar duas colunas que informam quais são os termos mais buscados da semana anterior e posterior.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/978ef29083c07ef725213fa4ed2b8865/href">https://medium.com/media/978ef29083c07ef725213fa4ed2b8865/href</a></iframe><p>Nos campos <strong>previous_week_top_terms</strong> e <strong>next_week_top_terms </strong>temos o uso da sintaxe para produzir o resultado que queremos. <a href="https://console.cloud.google.com/bigquery?sq=229919784316:6f764c46859347718731ff9dd7b6762d">O resultado pode ser conferido no BigQuery</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WIrepftsE0LNOIMakWYycQ.png" /><figcaption>Figura 4. O campo <strong>previous_week_top_terms</strong> captura os top termos da semana anterior.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Achw5TnCbZTYJaODjdxiug.png" /><figcaption>Figura 5. O campo <strong>next_week_top_terms</strong> captura os top termos da semana posterior.</figcaption></figure><h4><strong>Sintaxe</strong></h4><p>Na prática, a sintaxe é muito similar às funções de janela que mostrei nos posts anteriores dessa série.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/02572869a86030795b7468bc250fcd42/href">https://medium.com/media/02572869a86030795b7468bc250fcd42/href</a></iframe><p>Onde:</p><ul><li><strong>expression</strong>: indica o campo que você necessita obter na linha anterior ou posterior;</li><li><strong>offset</strong>: indica quantos campos anteriormente ou posteriormente você precisa “andar” para obter o valor desejado. No caso do exemplo do artigo utilizei o valor 1, ou seja, a consulta obteve o registro imediatamente antes e imediatamente depois da linha corrente;</li><li><strong>default_value</strong>: preenche com um valor default no início ou fim da tabela, ao invés de deixá-lo nulo;</li><li><strong>partition_expression</strong>: é o campo escolhido como partição e será o guia para que as funções LAG e LEAD reiniciem sua aplicação;</li><li><strong>sort_expression</strong>: é expressão que indicará a lógica de ordenação em cada partição.</li></ul><h4>Comentários Finais</h4><p>Chegamos ao final da série de posts sobre SQL para Análise de Dados. Essas funções me acompanham no meu dia a dia e penso que são recursos bastante úteis para consultas sem usar muito código.</p><p>Espero que essa série de posts tenha a aumentar seu cinto de utilidades, e obrigada por acompanhar até aqui!</p><h4>Referências</h4><p>[1] <a href="https://www.postgresqltutorial.com/postgresql-window-function/postgresql-lag-function/">PostgreSQL LAG function</a></p><p>[2] <a href="https://www.topcoder.com/thrive/articles/lead-and-lag-functions-in-sql">LEAD and LAG functions in SQL</a></p><p>[3] <a href="https://learnsql.com/blog/lead-and-lag-functions-in-sql/">The LAG function and the LEAD function in SQL</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebfc97f79791" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/sql-as-fun%C3%A7%C3%B5es-lag-e-lead-5-5-ebfc97f79791">SQL: As funções LAG e LEAD [5/5]</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Por que e como fazer um blog técnico]]></title>
            <link>https://medium.com/computando-arte/por-que-e-como-fazer-um-blog-t%C3%A9cnico-9193bbe4b71f?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/9193bbe4b71f</guid>
            <category><![CDATA[blog]]></category>
            <category><![CDATA[science-communication]]></category>
            <category><![CDATA[divulgação-científica]]></category>
            <category><![CDATA[website]]></category>
            <dc:creator><![CDATA[Caio Volpato]]></dc:creator>
            <pubDate>Tue, 22 Mar 2022 17:16:57 GMT</pubDate>
            <atom:updated>2022-03-22T17:16:57.110Z</atom:updated>
            <content:encoded><![CDATA[<p>Hoje vou falar de um hábito inesperado que passei a praticar durante a quarentena, o de compartilhar o conhecimento através de textos.</p><p>Eu não era um bom aluno de português :/, mas hoje percebo a importância de conseguir se comunicar bem, e como faz toda diferença!</p><p>Antes da pandemia, participava de algumas comunidades, hackerspaces e eventos (como a Cryptorave e a CasaHacker), e nesses espaços físicos são construídas diversas atividades colaborativamente.</p><p>Edai veio a pandemia que mudou essas interações então comecei a criar esses registros dessas trocas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oyY--jkJ3pBQ9V90" /><figcaption>Mika Baumeister, <a href="https://unsplash.com/photos/LaqL8nxiacc">unsplash</a></figcaption></figure><h3>Acompanhe referências da sua área</h3><p>O primeiro passo para começar a escrever é ler ;) quem escreve bem normalmente lê muito e na comunicação científica isso não é diferente. Veja o que outras pessoas falam, procure e acompanhe blogs e talks dessas pessoas. Preste atenção em alguns pontos: Como elas explicam determinado conceito? Quais analogias/comparações ela usa? E, principalmente, como apresentar isso para quem está começando e quais detalhes são importantes?</p><h3>Decida se quer ser anônimo ou não</h3><p>Uma possibilidade é escrever sem se identificar, dessa forma você não “contamina” o debate com quem você é, onde você trabalha, onde você estudou, com que você interage, sua aparência, enfim, de onde você vem.</p><p>Um exemplo disso é o <a href="https://startupdareal.medium.com/">Startup da Real</a>, ele criou um perfil para expor os discursos de empreendedorismo. Depois de produzir vários textos aqui no medium ele amarrou esses textos em um livro chamado “Este livro não vai te deixar rico: Descubra a verdade sobre empreendedorismo, startups e a arte de ganhar dinheiro”. O startup da real, ou Alberto Brandão, revelou sua identidade no talk show do Ronald Rios. Confira aqui ele contando a história: <a href="https://www.youtube.com/watch?v=Aca1ZbHDQ3g">STARTUP DA REAL — Ronald Rios Talk Show #12</a></p><p>Apesar dessas vantagens, vou trazer no próximo tópico um bom motivo para não fazer de forma anônima.</p><h3>Use seu conteúdo para construir rastros digitais positivos!</h3><p>A internet não esquece! Já deu um google no seu nome completo? O que encontrou? Possivelmente seu currículo lattes ou algum trabalho publicado, talvez até seu perfil no LinkedIn. Mas às vezes tem coisas que você não gostaria que aparecesse (pelo menos com tanto destaque), como por exemplo um processo no JusBrasil, no Diário Oficial ou então alguma nota em disciplina da faculdade. E o mais triste disso é que não temos muito como deletar essas pegadas digitais de forma fácil e rápida.</p><p>Ao invés de tentar deletar toda sua presença online e ocupar esses espaços online da forma mais anônima possível, que tal criar um conteúdo legal e que quando pesquisarem você isso vai causar uma ótima primeira impressão?</p><p>Quando pesquisarem seu nome no Google vão encontrar seu artigo, seu blog pessoal, uma talk que você fez em algum evento, uma participação em podcast ou live. E as coisas que não tem tanto orgulho só irão aparecer nas últimas páginas da pesquisa, que normalmente as pessoas não procuram. Vi essa excelente proposta no texto da Casey Fiesler, ela estuda os espaços online há anos, e propôs essa abordagem no contexto da hashtag #10YearChallenge, quando acabaram trazendo à tona coisas que a pessoa postou e que hoje em dia não se orgulham. Veja o texto dela: <a href="https://cfiesler.medium.com/if-youre-worried-about-your-digital-footprint-don-t-destroy-it-make-it-better-cce67263c587">If you’re worried about your digital footprint, don’t destroy it — make it bigger. | by Casey Fiesler</a></p><h3>Outros porquês para divulgar conhecimento</h3><p>Além de ter uma presença online mais positiva, quais outras vantagens de divulgar conhecimento?</p><p>Uma habilidade que você acaba desenvolvendo é de colocar em uma ordem linear como abordar determinado assunto. No fundo, você vai escrever uma história com começo, meio e fim. E quando você registra isso logo depois que começou a aprender um assunto novo, vai te ajudar bastante no seu processo de aprendizado.</p><p>Quando criar uma documentação quando você tiver que configurar seu ambiente, se você documentar vai ficar mais fácil de reproduzir quando precisar novamente. Como você já escreveu essa documentação, terá pouco trabalho para publicar e vai ajudar quem estiver precisando. Por exemplo, quer aprender como montei meu setup de backups automatizados? Confira aqui: <a href="https://caioau.net/blog/backups/">Como parei de me preocupar e passei a adorar minha solução de backups</a>.</p><h3>Ninguém se importa com seu conteúdo!</h3><p>E isso é bom! Esse post do Gabs Ferreira, do grupo Alura: <a href="http://gabsferreira.com/ninguem-se-importa-com-o-seu-conteudo-e-isso-e-bom/">Ninguém se importa com o seu conteúdo: e isso é bom — Gabs Ferreira</a> trouxe essa perspectiva, só vai!</p><p>Se estiver com receio de começar a escrever, pois vão te criticar ou te julgar de alguma forma, não se preocupe! A maioria das pessoas nem vai consumir seu conteúdo. Então escreva pensando em você, como isso vai te ajudar a aprender melhor, a se expressar melhor, a colocar as coisas em uma ordem linear e etc … E se conseguir impactar positivamente mesmo que for apenas uma pessoa isso já valeu a pena.</p><p>Pra quem curte estatísticas, na pegada do princípio de pareto (80% dos efeitos vêm de 20% das causas) temos a regra <a href="https://en.wikipedia.org/wiki/1%25_rule">90–9–1 (ou regra do 1%)</a> que mostra que via de regra para qualquer comunidade na internet 90% dos internautas vão apenas consumir de forma passiva, sem interagir de nenhuma forma (os “Lurkers”). Dos 10% restantes, 9% vão participar pouco através das “micro-reações”, como like ou claps no medium, e apenas 1% dos internautas serão responsáveis pela maioria das discussões.</p><p>Na reportagem de Janeiro de 2012 da Revista Galileu (<a href="https://web.archive.org/web/20120102101719/http://revistagalileu.globo.com/Revista/Common/0,,EMI281132-17773,00-OS+COMENTADORES+DA+INTERNET.html">web archive</a>) entrevistou uma pessoa que foi responsável por mais de CINCO MIL comentários, de forma anônima, na folha.com.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*IegwUThKfXc0u1JH" /><figcaption><a href="https://xkcd.com/386/">xkcd #386</a></figcaption></figure><h3>Melhor escrever em português ou inglês?</h3><p>A língua é uma barreira! Com isso em vista, devo escrever em português ou em inglês?</p><p>Se optar pelo inglês, possivelmente seu conteúdo vai atingir mais pessoas, mas em compensação tem muito conteúdo em inglês então fica mais difícil do seu texto se destacar.</p><p>Caso seja algo específico, como um tutorial de um framework recém lançado, talvez seja melhor fazer em inglês.</p><h3>Alguns exemplos</h3><p>Vou trazer alguns textos de formatos diferentes para trazer inspirações.</p><p>O primeiro exemplo é uma dica de ouro, é o texto da Anna sobre <a href="https://anna.flourishing.stream/pt-br/today-i-learned/cancelamento-de-ruido-pulseaudio/">Como ativar o cancelamento de eco no PulseAudio — Anna escreve</a>. No texto, a autora apresenta o problema (a captação de áudio do microfone embutido do notebook não funciona bem) e apresenta como atacar o problema.</p><p>Outro formato é falar sobre seu setup (um site que gosto muito de acompanhar é o <a href="https://manualdousuario.net/">manualdousuario.net</a>).No tipo de texto como <a href="https://manualdousuario.net/home-office-camila/">O escritório em casa da designer de UI/UX Camila</a>,você vai falar como é o seu escritório, quais equipamentos tem e como usa. É bem divertido e ajuda quem está em dúvida do que comprar, ou até mesmo repensar a forma de trabalhar.</p><p>Para fechar os exemplos vou falar do texto do Gabriel Arruda que eu adoraria ter lido na faculdade quando estudava sobre o assunto. O texto se chama <a href="https://gdarruda.github.io/2021/04/04/ferias-otimizadas.html">Organizando férias com otimização</a>. A proposta é encontrar os melhores períodos para entrar de férias para ter o máximo de dias de descanso. No texto o autor fala do problema, como vai ser modelado, a linguagem <a href="https://www.minizinc.org/">MiniZinc</a>, o código e o resultado. Atente-se em como o autor conta uma história, com começo, meio e fim, e tenha isso em mente quando estiver escrevendo seu texto.</p><h3>Use memes!</h3><p>Uma imagem vale por mil palavras, para deixar seu textão mais atraente e prender a atenção dos leitores, use e abuse de memes!</p><p>Por exemplo se estiver escrevendo sobre como a mediana é mais uma medida mais robusta que a média a valores aberrantes (outliers), o meme abaixo encaixa como uma luva:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/884/0*d1CxHRpwoayQKm_2" /></figure><p>Entretanto em alguns contextos mais formais não pega muito bem usar memes :/ nesses casos sugiro usar outros recursos visuais como diagramas ou tirinhas como do XKCD. Uma obra prima foi o texto aqui no computando arte <a href="https://medium.com/computando-arte/entendendo-m%C3%A9tricas-de-modelos-preditivos-problemas-de-classifica%C3%A7%C3%A3o-desbalanceados-11aa406f6aac">Métricas de Modelos Preditivos: Acurácia em Problemas de Classificação Desbalanceados | by Mikael Souza | Computando Arte</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sbO24W8aqOQ7Uy2e" /></figure><h3>Onde escrever</h3><p>O Medium é a opção mais conhecida para publicar textos. Nele seu texto é “impulsionado” para pessoas que estão na plataforma, porém a desvantagem é que ele tem um paywall que impede a leitura de mais de 5 textos por dia :/</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*UrpBndnxBQK2h3Yz" /><figcaption><a href="https://twitter.com/linhadotrem/status/1451596753032069125">@linhadotrem/Twitter</a></figcaption></figure><p>Uma plataforma mais focada para o público de tecnologia é o <a href="https://dev.to/">dev.to</a>, nele os textos devem estar no formato markdown, ao passo que o Medium tem um editor próprio. Mas o dev.to não tem paywall \o/</p><p>Dependendo do seu objetivo, uma opção é escrever e publicar no próprio Linkedin. Para isso, você precisa habilitar o modo criador (<a href="https://www.linkedin.com/help/linkedin/answer/a522537/linkedin-creator-mode?lang=pt">instruções</a>) então no seu perfil aparece sobre quais tópicos você escreve. Um exemplo é a Vanessa Moura (WonderWanny).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/788/0*DZB6YHZTR2EWekfF" /><figcaption><a href="https://www.linkedin.com/in/vannessamoura/">linkedin.com/in/vannessamoura</a></figcaption></figure><p><em>Qual plataforma devo escolher?</em> Minha sugestão é que não se preocupe muito com isso, só comece a escrever! Mas sugiro que tenha um blog pessoal pelo menos como “backup” para não ficar refém das plataformas.</p><h3>Blog pessoal</h3><p>Poucas plataformas da internet sobreviveram à prova do tempo. Lembra do Orkut? Já teve um MSN? Ter um blog pessoal te ajuda a evitar isso, vou dar algumas dicas de ter um blog pessoal.</p><p>Devo usar o WordPress, Ghost, Jekyll ou Hugo? A ferramenta não importa! Só comece a escrever!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*L3em-XHu54iU0dlW" /><figcaption><a href="https://rakhim.org/honestly-undefined/19/">rakhim.org/honestly-undefined/19</a></figcaption></figure><h3>Analytics</h3><p>Quando estiver criando seu cantinho da internet, evite os analytics comerciais, principalmente o Google Analytics. O Google Analytics está presente na esmagadora maioria dos sites, tenha carinho pelos seus leitores e considere uma alternativa mais privativa.</p><p>Já ouviu que “se o produto é de graça, você é o produto”? O produto de verdade do Google Analytics são os dados de navegação dos internautas. Que tal, pelo menos no seu cantinho, experimentar opções mais privativas?</p><p>Dentre as alternativas vou destacar o <a href="https://www.goatcounter.com/">goatcounter.com</a>: é gratuito para até 100k pageviews por mês e tem a opção self-hosting.</p><p>Para quem optar pela via de hospedar por sua conta o site, tem o <a href="https://goaccess.io/">goaccess.io</a> que cria dashboards apartir dos logs de acessos dos webserver como Nginx e Apache, ou seja, zero scripts de rastreamento ^_^</p><h3>Usuários de RSS existem e resistem!</h3><p>Já falamos sobre RSS aqui no computando arte: <a href="https://medium.com/computando-arte/utilizando-o-rss-para-furar-a-bolha-507f8b0ed410">Utilizando o RSS para “furar a bolha” | Computando Arte</a></p><p>O RSS é um dos principais meios dos usuários acompanharem seu site, mas fique tranquilo pois provavelmente a ferramenta do seu site já deve gerar o feed sozinho.</p><p>Só se atente que o link do feed está presente no HTML, caso contrário a pessoa vai ter que “caçar” o seu feed, por exemplo:</p><blockquote>&lt;link rel=”alternate” type=”application/rss+xml” href=’https://caioau.net/blog/index.xml&#39; title=”Blogs on Pagina do caioau”&gt;</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/455/0*jRJlHplWQSg_ehtV" /></figure><h3>Sobre ter um domínio próprio</h3><p><em>Vou criar um site, preciso ter um domínio?</em> Absolutamente não precisa! Você pode usar a hospedagens gratuitas como Github Pages. Pessoalmente, prefiro o Gitlab ou até mesmo o Wordpress.</p><p>De novo, não se preocupe com isso! Só comece a escrever! Se depois de alguns meses ou anos que começou você sempre pode migrar para um domínio novo.Quando você for migrar, você pode colocar um atributo no HTML para redirecionar automaticamente para o domínio novo, o <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/meta#attr-http-equiv">http-equiv</a>. Por exemplo:</p><blockquote>&lt;meta http-equiv=”refresh” content=”0;url=https://caioau.net/&quot; /&gt;</blockquote><p>Não caia nas extensões como .xyz! Pode parecer um preço tentador, mas muitas vezes o preço só é vantajoso para registrar o domínio na primeira vez, mas quando levar em conta as renovações não vale tanto a pena assim se comparado com extensões tradicionais como .net, .com ou .org.</p><p><em>E um .br?</em> O .br até que tem um preço bom, mas infelizmente no registro br seus dados pessoais (nome completo e CPF) ficam públicos no whois :/</p><h3>Um .onion (onion service) cai bem</h3><p>Para o seu cantinho ficar ainda mais privado você pode disponibilizar seu site em um onion service, trazendo anonimato para quem o visita com o navegador Tor.</p><p>É tranquilo fazer! A documentação é muito boa: <a href="https://community.torproject.org/onion-services/">community.torproject.org/onion-services</a>. Dá pra facilitar ainda mais usando o <a href="https://onionshare.org/">onionshare.org</a> (só apontar a pasta que fica os HTML).</p><p>Porém você vai precisar de um computador rodando 24 horas por dia para hospedar seu .onion, mas uma raspberry-pi dá conta do recado.</p><p>Último cabeçalho, prometo! Coloque no HTML o atributo http-equiv=”onion-location”, dessa forma quando o navegador Tor abrir seu site na clearnet ele vai redirecionar automaticamente para a versão disponível no .onion, por exemplo:</p><blockquote>&lt;meta http-equiv=”onion-location” content=”http://zgjjgd2o7zh4u76b5d5fpyekeif4nmbtbktufe7z4vaa6sazeraz4nyd.onion&quot; /&gt;</blockquote><h3>/join #computando-arte</h3><p>Quando estiver escrevendo seus textos é importante pedir feedbacks, dessa forma você verá como pessoas com diferentes bagagens receberão seu conteúdo, por isso ter um grupo de divulgação onde todo mundo se ajuda é muito bom!</p><p>Se gosta do nosso trabalho no Computando Arte e quiser escrever como convidado ou passar a compor o grupo, vamos te dar esse apoio! Basta nos enviar uma mensagem no twitter em <a href="https://twitter.com/ComputandoArte">@ComputandoArte</a> ou no computando.arte@protonmail.com que iremos te responder :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9193bbe4b71f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/por-que-e-como-fazer-um-blog-t%C3%A9cnico-9193bbe4b71f">Por que e como fazer um blog técnico</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SQL: As funções FIRST_VALUE e LAST_VALUE [4/5]]]></title>
            <link>https://medium.com/computando-arte/sql-as-fun%C3%A7%C3%B5es-first-value-and-last-value-4-5-a211dc37157d?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/a211dc37157d</guid>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Erica Bertan]]></dc:creator>
            <pubDate>Thu, 10 Mar 2022 14:30:38 GMT</pubDate>
            <atom:updated>2022-03-10T14:36:54.829Z</atom:updated>
            <content:encoded><![CDATA[<h4>Veja como obter o primeiro ou último registro de um campo de uma forma bem simples.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bqD2DbAnggqmr2O01wXTGw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@briennehong?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Brienne Hong</a> on <a href="https://unsplash.com/s/photos/pick?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><h4>Disclaimer</h4><p>Nesta série de 5 posts, gostaria de compartilhar com vocês alguns comandos que tive contato recentemente em SQL e que considero muito úteis! Se você ainda não leu os outros, sugiro começar pelo primeiro post da série, onde falo sobre as funções <a href="https://medium.com/computando-arte/sql-as-fun%C3%A7%C3%B5es-greatest-e-least-1-5-aeaf4dcf21b6">Greatest and Least</a>.</p><h4>O que são essas funções e para que servem?</h4><p><em>FIRST_VALUE</em> e <em>LAST_VALUE</em> são window functions (ou funções de janela em tradução literal) que obtêm o primeiro e último registro de cada partição de uma amostra de dados. <a href="https://docs.aws.amazon.com/pt_br/redshift/latest/dg/c_Window_functions.html">Funções de janela</a> tem o papel de retornar um único valor de uma dada partição, enquanto funções sem janela operam em cada registro do resultado da tabela.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/86d5e05122267bba1f32a8ccbf3d5e4d/href">https://medium.com/media/86d5e05122267bba1f32a8ccbf3d5e4d/href</a></iframe><p>A sintaxe parece complicada, mas vamos com calma nos principais pontos:</p><ul><li><strong>expression</strong> é o campo onde desejamos obter o primeiro ou último valor. Lembre-se que o valor é obtido mediante ao resultado da expressão usada para particionar e ordenar os valores;</li><li><strong>expr_list</strong> ou também expressão de partição, é o campo escolhido como partição e será o guia para que as funções FIRST_VALUE e LAST_VALUE sejam aplicadas. Caso nenhum campo seja definido aqui, as funções FIRST_VALUE e LAST_VALUE vão tratar todo o resultado da amostra como uma única partição;</li><li><strong>order_list</strong> é expressão que indicará a lógica de ordenação em cada partição;</li><li><strong>frame_clause </strong>é uma expressão que ajuda a refinar a lógica dos registros que a função vai considerar na partição, ou seja, se registros serão incluídos ou excluídos dela. Porém, não vamos dar atenção a ela neste post.</li></ul><p><strong>Exemplo: A música menos dançante de cada artista</strong></p><p>Vamos supor que precisamos obter o nome da música menos dançante de cada artista. Claro que existem outras formas de fazer isso, mas vamos aplicar o FIRST_VALUE neste exemplo (o princípio por trás de LAST_VALUE é o mesmo). A query fica assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/08159c2c90d15944d5302e8cde1e0d9a/href">https://medium.com/media/08159c2c90d15944d5302e8cde1e0d9a/href</a></iframe><p>Observe o resultado na Imagem 1. As linhas em vermelho mostram como a função se comportou para as 4 músicas de The Chainsmokers que estavam na amostra utilizada:</p><figure><img alt="Imagem 1 — O resultado da ordenação faz com que a primeira música seja a menos dançante." src="https://cdn-images-1.medium.com/max/780/1*9ZqhQMxD8Lht9gq7QVPzqA.png" /><figcaption>Imagem 1 — O resultado da ordenação faz com que a primeira música selecionada seja a menos dançante.</figcaption></figure><p>De forma geral, a query particiona o resultado por artista e ordena cada faixa desse artista na ordem crescente, assim o FIRST_VALUE captura o primeiro registro de cada partição, que no caso do exemplo é a música menos dançante. Considerando todas as 4 faixas de The Chainsmokers da amostra, <em>Don&#39;t Let Me Down</em> realmente parece ser a menos dançante entre elas 😃.</p><p>Veja na Imagem 2 que para Ed Sheeran a música menos dançante selecionada foi Castle on the Hill, conforme consta no campo first_danceability:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*M1HgkIYJnL3-13g2gaVqLw.png" /><figcaption>Imagem 2 — Castle on the Hill foi selecionada como a a música menos dançante de Ed Sheeran.</figcaption></figure><h4>Próximos Passos</h4><p>Se você se interessa pelo tipo de assunto abordado neste post, no próximo e último post da série falaremos sobre mais uma função muito útil em SQL: a <strong>LAG</strong>.</p><h4>Referências</h4><p>[1] <a href="https://docs.aws.amazon.com/redshift/latest/dg/r_WF_first_value.html">FIRST_VALUE and LAST_VALUE window functions</a></p><p>[2] <a href="http://SQL Server LAST_VALUE Function">SQL Server LAST_VALUE function</a></p><p>[3] <a href="https://docs.aws.amazon.com/pt_br/redshift/latest/dg/c_Window_functions.html">Funções de Janela</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a211dc37157d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/sql-as-fun%C3%A7%C3%B5es-first-value-and-last-value-4-5-a211dc37157d">SQL: As funções FIRST_VALUE e LAST_VALUE [4/5]</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sobre aranhas e teias]]></title>
            <link>https://medium.com/computando-arte/sobre-aranhas-e-teias-595798ae2efb?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/595798ae2efb</guid>
            <dc:creator><![CDATA[Vinicius Aguiar]]></dc:creator>
            <pubDate>Wed, 02 Feb 2022 13:10:47 GMT</pubDate>
            <atom:updated>2022-02-02T13:10:47.814Z</atom:updated>
            <content:encoded><![CDATA[<p>Ou web scraping, a cada qual segundo as suas vontades</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gbAZDROmEpYdpHoh" /><figcaption>Photo by <a href="https://unsplash.com/@jammypodger7470?utm_source=medium&amp;utm_medium=referral">michael podger</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Prólogo</h4><p>Bom dia, espero que esteja bem caro leitor. Nesta semana vou apresentar um pouco sobre como criar crawlers e como passar pelos obstáculos mais comuns, com um pequeno exemplo. Por fim espero que as referências indiquem um caminho a ser percorrido em cenários mais desafiadores.</p><p>Aliás, escrever sobre crawlers me lembra de dois textos. Um, o primeiro capítulo do livro <a href="http://networksciencebook.com/chapter/1">Network Science</a>, comenta sobre redes e também sobre como o avanço tecnológico permitiu mapear estas redes. O que neste caso se traduz no surgimento da world wide web e o uso de crawlers para mapear a mesma (estou falando de você <a href="https://developers.google.com/search/docs/advanced/crawling/googlebot">Googlebot</a>). E o segundo, a <a href="https://www.newyorker.com/magazine/2018/12/10/the-friendship-that-made-google-huge">história</a> de dois desenvolvedores principais da Google, que juntos foram responsáveis por refatorar o Googlebot. Recomendo como leitura do cafézinho.</p><h4>Conhecendo um pouco o Browser</h4><p>É bem provável que esteja usando um navegador neste momento, logo convido você a entender um pouquinho mais suas ferramentas. Para isto basta abrir outra janela e acessar as ferramentas de desenvolvedor através do atalho Ctrl+Shift+I. Nela podemos observar algumas abas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/701/1*w5ZNWmdtPR7hjOX-cX3Efw.png" /><figcaption>Ferramentas de desenvolvedor do Google Chrome</figcaption></figure><p>Na aba Elements é possível visualizar a página em formato HTML, já a aba Console permite interagir com a página, como um terminal (aliás, já ouviu falar na palavra do zsh). Nesta última vale visualizar os dados disponíveis no window.navigator, ou navigator e também no window.chrome. Eles serão importantes (ou não) mais pra frente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/705/1*L7Dkj4bf4PSJ6ecET8WZLQ.png" /><figcaption>Objeto navigator no console do browser</figcaption></figure><p>Outras abas importantes são Sources e Application . A primeira nos permite ler o código dos arquivos js e css carregados, e a segunda permite o acesso aos <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies">cookies</a>, <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage">local storage</a> e <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage">session storage</a> (que também podem ser acessados pelo console, mas esta aba é bem conveniente). Por fim, mas não menos importante, na aba Network é possível visualizar o fluxo das requisições.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pN11pewXLn22S-j0tpo-fw.png" /><figcaption>Fluxo de requisições da página</figcaption></figure><p>Esta última aba é a protagonista da história e por meio dela é possível montar raspadores de dados (vulgos crawlers). Para isso tenha em mente que qualquer automatização deste tipo é um fluxo de requisições, às vezes simples, como o download de uma imagem ou zip; às vezes complexo, com fluxo de autenticação, verificação de fluxo e de humanidade.</p><h4>Scraping em Baixo Nível</h4><p>A primeira forma de criar crawlers é usar requisições de baixo nível, que não são nada mais do requisições HTTP. Abaixo observamos um simples tipo de requisição para obter seu próprio IP (na aba Timeline do Insomnia).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/372/1*82n22rsh6TzuXpZRvrDLyg.png" /><figcaption>Requisição GET para a API do ipify</figcaption></figure><p>Um workflow para criar crawlers em baixo nível se resume entender o fluxo de requisições através da aba Network no browser, refazer este fluxo em um aplicativo como Insomnia ou Postman, e por fim reescrever em código.</p><p>Algumas dificuldades nesta fase estão em duplicar corretamente o fluxo de forma que seja aceita pelo site. É bom sempre lembrar de:</p><ul><li>Atualizar o seu user agent, usando pacotes como <a href="https://www.npmjs.com/package/user-agents">user-agents</a>;</li><li>Manter a mesma cookie jar, que armazene os cookies atuais para requisições futuras. Feature incluida no scrapy, que pode ser adicionada ao superagent através da integração com o pacote <a href="https://www.npmjs.com/package/tough-cookie">tough-cookie</a>;</li><li>Verificar o uso de headers de autenticação/autorização, como Authorization , Referer , Origin e Tokens . Algumas vezes algum endpoint é chamado anteriormente para gerar um <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication">bearer token</a>.</li></ul><p>Ferramentas que já usei e recomendo são os pacotes requests e beautifulsoup para casos simples, e scrapy em casos mais complexos no caso de Python. E em TypeScript superagent com as interfaces em json ou um parser de html, como node-html-parser. Neste último caso o uso de interfaces facilita na hora de parsear os dados, e em ambos <a href="https://regex101.com/">regex</a>.</p><pre>def fetch(url, save_path, chunk_size=128):<br>    r = requests.get(url, stream=True)<br>    with open(save_path, &quot;wb&quot;) as fd:<br>        for chunk in r.iter_content(chunk_size=chunk_size):<br>            fd.write(chunk)<br><br>    return save_path</pre><h4>Scraping em Alto Nível (Headless Browser)</h4><p>Alguns casos estão longe de serem tão diretos como baixar um arquivo no formato json com o cabeçalho da requisição correto. Existem empresas com foco em defesa contra bots, como <a href="https://www.imperva.com/">Imperva</a> e <a href="https://www.akamai.com/">Akamai</a>. Para estes casos também existem alternativas criadas pela comunidade, como <a href="https://github.com/puppeteer/puppeteer">puppeter</a>, <a href="https://github.com/berstend/puppeteer-extra">puppeter-extra</a> e <a href="https://playwright.dev/">playwright</a> (Não necessariamente criados para este problema, e sim para automação de testes em alguns casos. E algumas vezes provavelmente motivados por motivos excusos, sem palavras a mais).</p><p>Note que nem tudo são flores. Essas bibliotecas tem um custo em termos de uso de processamento e memória, além do fato que não são uma solução pronta, é necessário trabalhar em cima das mesmas. Outro ponto importante neste caso é a limitação de requisições por IP, o bloqueio geográfico de IPs ou o bloqueio de IPs não residenciais (que sugere a necessidade de usar um provedor de IPs). Não tenho vergonha de só mostrar um exemplo bobo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*f61x3pH7auxYfEJIZc-aXA.gif" /><figcaption>Exemplo de resolução do Wordle com Puppeteer</figcaption></figure><p>Sim, estou fortemente considerando lançar o <a href="https://github.com/vncsna/learning-crawlers">Wordle as a Service</a>, e talvez até expandir esse serviço. Afinal pertencer a uma comunidade sustentada por esbanjar riqueza (<a href="https://palladiummag.com/2022/01/21/when-the-stagnation-goes-virtual/">NFTs</a>?) ou inteligência (QI) é tão popular hoje.</p><p>Se quiser é possível testar seus crawlers e respectivos comportamentos com <a href="https://webhook.site/">Webhook Site</a> e <a href="https://browserleaks.com/">Browser Leaks</a>. Note que existem diferenças entre um headless browser e um browser normal, incluindo a falta de plugins.</p><h4>Então, isso é tudo? Não</h4><p>Analogamente a uma grande quantidade de problemas, este tipo de coleta de dados pode ser tão difícil quanto o contexto demande, ou quanto se queira. Outros desafios que podem ser enfrentados são:</p><ul><li>Monitoramento de múltiplos crawlers;</li><li>Gerenciamentos de provedores de proxy;</li><li>Engenharia reversa em códigos obfuscados;</li><li>Agendamento de extrações (parte da engenharia de dados);</li><li>Tratamento de erros, tanto no tratamento de dados, quanto na indisponibilidade do serviço que esta sendo raspado.</li></ul><p>É bom lembrar que várias empresas diferentes lidam com este problema, oferecem seu serviço, e também divulgam suas estratégias, como: <a href="https://httptoolkit.tech/blog/">HTTP Toolkit</a>, <a href="https://fingerprintjs.com/blog/">FingerprintJS</a>, <a href="https://scrapingant.com/blog/">ScrapingAnt</a> e <a href="https://www.scrapingdog.com/blog/">Scrapingdog</a> (O mundo conspira para criação do Scrapingcat). Já no Brasil temos também uma empresa especializada no assunto, chamada <a href="https://www.crawly.com.br/">Crawly</a>.</p><h4>Praticando o respeito</h4><p>Lembre-se de respeitar o <a href="https://developer.mozilla.org/en-US/docs/Glossary/Robots.txt">robots.txt</a>, se possível e desejável.</p><h4>Epílogo</h4><p>E mais uma vez, muito obrigado pela leitura. A recomendação da vez é assistir <a href="https://music.youtube.com/watch?v=UFFa0QoHWvE&amp;feature=share">Cowboy Bebop</a> (anime, live action nem existe) e Samurai Champloo. Hoje eu me perguntei que eu curto recomendar em geral, nem sei o porquê…</p><blockquote>See You Space Cowboy - Cowboy Bebop (1997)</blockquote><h4>Referências</h4><p>[1] <a href="https://www.pluralsight.com/guides/advanced-web-scraping-tactics-python-playbook">Advanced Web Scraping Tactics</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=595798ae2efb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/sobre-aranhas-e-teias-595798ae2efb">Sobre aranhas e teias</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como contêineres funcionam?]]></title>
            <link>https://medium.com/computando-arte/como-cont%C3%AAineres-funcionam-d24907dcf08d?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/d24907dcf08d</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[computação]]></category>
            <dc:creator><![CDATA[Caio Volpato]]></dc:creator>
            <pubDate>Wed, 19 Jan 2022 17:06:37 GMT</pubDate>
            <atom:updated>2022-01-19T17:13:00.573Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<p>Existe muito ~hype~ quando o assunto é contêineres e Kubernetes, isso acaba gerando uma expectativa e confusão do que são e como funcionam essas tecnologias.</p><p>Hoje vamos falar o que de fato é um contêiner, como funciona e se cria um contêiner do zero (sem o docker).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QDIVEcQR5ZFRGyHf" /><figcaption>Foto de ines mills, <a href="https://unsplash.com/photos/TGs0tHMk4eg">unsplash</a></figcaption></figure><h3>O que é um contêiner?</h3><p>Um contêiner é um processo rodando no kernel linux. E esse processo é isolado dos outros processos/contêineres e do host (através de features do kernel).</p><p>Essa é a principal diferença dos contêineres para máquinas virtuais (VM). Todos os contêineres compartilham o mesmo kernel, no passo que cada VM tem seu kernel.</p><p>Mas se é um kernel linux, como funciona quando uso o docker no Windows ou Mac? No fundo no Windows (mesmo WSL) e Mac tem uma máquina virtual rodando o linux.</p><p>E quais são essas features do kernel que fazem tudo isso acontecer? Vamos falar delas nesse texto.</p><h3>Namespaces</h3><p>Namespaces controlam o que um processo/contêiner consegue ver, existem atualmente os seguintes namespaces:</p><ul><li>Processes ID (pid)</li><li>mount points (mnt)</li><li>Network (net)</li><li>IDs do usúario e group (user)</li><li>Interprocess communication (ipc)</li><li>Control Group (cgroup)</li><li>Unix Timesharing System (uts), apesar do nome complicado, representa o hostname e domínios.</li></ul><h3>/proc</h3><p>O procfs (montado em /proc) é um tipo de filesystem especial, nele existem diversas informações do sistema como cpu, memória e principalmente os processos.</p><p>Se quiser entender como ler as infos do /proc, veja em <a href="https://linux.die.net/man/5/proc">man proc</a>.</p><p>Para que os processos do host ficarem isolados do contêiner, o contêiner precisa ter um /proc próprio (além de um namespace pid).</p><h3>chroot</h3><p>Para que o contêiner não acesse os arquivos do host, o chroot (change root directory) faz com que o contêiner só consiga acessar um diretório do host.</p><p>Por exemplo, se fizermos um chroot /mnt/root, um arquivo em /mnt/root/arq1.txt no host será apenas /arq01.txt no chroot. Neste chroot só consegue acessar o que está em /mnt/root</p><h3>Control groups (cgroup)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/711/0*MXYbgmFbpgW4uT8d" /></figure><blockquote>:(){ :|:&amp; };:</blockquote><p>Provavelmente é a forkbomb mais conhecida. Uma forkbomb é um ataque que quando executada são rapidamente criados muitos processos que que se multiplicam exponencialmente incapacitando totalmente o computador, sério! Só tirando da tomada pra conseguir parar.</p><p>Precisamos de uma forma de limitar quantos recursos um determinado contêiner consegue utilizar. Os control group (cgroup) limitam os recursos como CPU, memória, rede que cada contêiner pode utilizar.</p><h3>Demo: Criando um contêiner do zero</h3><p>Bora criar nosso container sem usar o docker! Antes de tudo precisamos instalar o que vamos precisar:</p><blockquote>sudo apt install debootstrap cgroup-tools util-linux</blockquote><p>Primeiramente vamos criar uma instalação base do debian, para que o que fizermos no container não contamine nossa máquina (o host), rode o seguinte no terminal:</p><blockquote>sudo debootstrap bullseye ./deb11-rootfs <a href="https://deb.debian.org/debian/">https://deb.debian.org/debian/</a></blockquote><p>O comando acima vai criar uma instalação do Debian 11 (bullseye) na pasta deb11-rootfs.</p><p>Agora vamos criar um cgroup</p><blockquote>export cgroup_name=”cg_$(shuf -i 2000–3000 -n 1)”</blockquote><blockquote>cgcreate -g “cpu,cpuacct,memory,pids:$cgroup_name”</blockquote><p>Colocando limites no cgroup</p><blockquote>cgset -r cpu.shares=256 “$cgroup_name”</blockquote><blockquote>cgset -r memory.limit_in_bytes=100M “$cgroup_name”</blockquote><blockquote>cgset -r pids.max=100 “$cgroup_name”</blockquote><p>Então nosso cgroup vai ter no máximo 100MB de RAM, 1/4 de cpu (256/1024 shares) e 100 processos simultâneos então uma forkbomb vai ser contida.</p><p>É agora, bora disparar um container nesse cgroup:</p><blockquote>cgexec -g “cpu,cpuacct,memory,pids:$cgroup_name” \</blockquote><blockquote>unshare — fork — mount — uts — ipc — pid — mount-proc \</blockquote><blockquote>chroot “./debian11-rootfs” \</blockquote><blockquote>/bin/sh -c “/bin/mount -t proc proc /proc &amp;&amp; hostname container &amp;&amp; /bin/bash”</blockquote><p>Calma, muita coisa ao mesmo tempo, vamos rodar o unshare no cgroup, o unshare vai criar os namespaces que queremos (uts, ipc e pid), então fazer um chroot no debian, montar um /proc próprio, mudar o hostname para container e abrir um shell bash.</p><p>Sucesso! Temos um container! O que vamos fazer?</p><p>Vamos ver que o container não consegue ver os processos do host, faça ps aux (para listar os processos) e veja que são apenas listados os processos do container, isso aconteceu porque o container está num namespace pid (veja — pid no unshare e um /proc próprio).</p><p>Mas o host consegue ver o container, faça sleep 1000 no container e no host faça ps aux | grep ‘sleep 1000’, o host consegue ver todos os container, repare que os mesmos processos no host tem um pid enquanto no container tem outro PID.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UL-QPytLwcn2p4MN" /></figure><p>Veja que o container só consegue enxergar seus processos, ao passo que o host (parte inferior) consegue ver os processos do(s) container(s), veja também que o processo bash no container tem PID 4 enquanto no host 12885.</p><p>Faça cat /proc/self/cgroup no contêiner e compare com o host, esse arquivo lista os cgroups do processo, repare que os cgroup pids,memory,cpu,cpuacct são o cgroup que criamos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/564/0*fZBg4HPmQfG940Ry" /></figure><p>No host vá em /sys/fs/cgroup/ e navegue por exemplo em pid/nome_do_cgroup veja que tem vários arquivos informando infos e limites como pids.current e pids.max.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/0*--Ian_KNqZC5hWRc" /></figure><p>Por fim vamos testar esses limites, no container instale o python (apt update &amp;&amp; apt install python3) então abra o python e faça vet = int(1e9)*[None], tentamos alocar um vetor com 1 bilhão (1e9) valores, apareceu o Killed. O que aconteceu? No host faça dmesg (que exibe mensagens do kernel) e veja que o kernel (out of memory (oom)) matou processo pois ele passou do constraint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/951/0*FMNfLwOLFepVDUpV" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/0*gqjRHDXseX2JgcGd" /></figure><p>Para facilitar coloquei os comandos que usamos para criar um container em um script:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/deb2eb092b81ee9387b07046eb498f42/href">https://medium.com/media/deb2eb092b81ee9387b07046eb498f42/href</a></iframe><h3>Overlay filesystems</h3><p>No nosso exemplo usamos uma instalação do debian como filesystem, dessa forma cada contêiner precisaria ter sua própria instalação, gastando muito espaço de disco (sem aproveitar o que é comum).</p><p>Os filesystem overlay permitem que contêineres diferentes aproveitem o mesmo espaço em disco. Isso acontece através das camadas que são reutilizadas e empilhadas para criar o filesystem final de cada contêiner.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*3igFzFt5_I-NCJbR" /><figcaption><a href="https://www.freecodecamp.org/news/demystifying-containers-101-a-deep-dive-into-container-technology-for-beginners-d7b60d8511c1/">Fonte</a></figcaption></figure><p>Na figura acima temos uma visualização bacana, partimos de uma instalação do sistema operacional Ubuntu, então é instalado o java e por fim são copiados os binários da aplicação elasticsearch essa é a imagem 1 (representada na 3a camada b108…). A imagem 2 são adicionados arquivos de configuração e por fim definidas algumas variáveis de ambiente.</p><p>Cada passo é uma camada (representada à direita), aproveitando aquela ação para outras imagens que usam aquilo como base.</p><h3>Features de segurança</h3><p>Capabilities, seccomp e apparmor são features de segurança para restringir o que os contêineres podem fazer, vamos falar brevemente delas a seguir:</p><ul><li>Capabilities: São permissões especiais que permitem processos fazer determinadas ações. Por exemplo <strong>cap_net_bind_service</strong> permite usar portas privilegiadas (&lt;1024). As capabilities surgiram para dar permissões mais granulares aos programas, antes delas essas ações só eram permitidas para o root.</li><li>seccomp-bpf: Define quais chamadas de sistema (syscalls) são permitidas.</li><li>AppArmor ou SELinux: São sistemas concorrentes normalmente distribuições baseadas no RedHat (como fedora) usam o SELinux enquanto distros baseadas no Debian (como Ubuntu, linux mint e pop-os) usam o AppArmor. Eles tem um perfil que define quais arquivos podem ser acessados (ou não) e quais capabilities são permitidas.</li></ul><h3>Quem faz tudo isso acontecer?</h3><p>Quem já usa docker não precisa criar os namespaces, cgroups etc … que falamos aqui, então quem faz isso? O docker? Quem se ocupa disso são os container runtime.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cspyIIDJJqyueCt0" /><figcaption><a href="https://iximiuz.com/en/posts/container-learning-path/">Fonte</a></figcaption></figure><p>O diagrama acima mostra como tudo se relaciona, ao longo dos anos foram sendo criadas interfaces padronizadas, primeiramente a OCI (open containers iniciative) em jun/2015 e nasceu o runc. Depois foi criada a CRI (container runtime interface) em Dez/2016 e nasceu o containerd.</p><p>Essas interfaces foram criadas principalmente por causa do Kubernetes, e com elas sendo padronizadas esses componentes podem ser substituídos facilmente. Por exemplo, se não quiser usar o <a href="https://containerd.io/">containerd</a> você pode usar uma alternativa mais leve como o <a href="https://cri-o.io/">cri-o</a>.</p><p>Lembra em 2020 que na versão 1.20 do Kubernetes que o docker não ia ser mais suportado? Isso aconteceu porque o Kubernetes interagia com o docker de uma forma não padronizada. O dockershim não era a interface padronizada CRI, então o Kubernetes tinha que manter duas implementações separadas. Mais detalhes aqui: <a href="https://kubernetes.io/pt-br/blog/2020/12/02/dont-panic-kubernetes-and-docker/">Não entre em pânico: Kubernetes e Docker</a></p><p>Tem uma talk legal que conta a história dessas interfaces: <a href="https://www.youtube.com/watch?v=MDsjINTL7Ek">Below Kubernetes: Demystifying container runtimes</a></p><h3>Rootless</h3><p>Por padrão o docker daemon (e o containerd) roda como root no host, caso um contêiner consiga escapar o isolamento isso vai comprometer totalmente o computador host.</p><p>Uma vulnerabilidade grave no runc foi a <a href="https://seclists.org/oss-sec/2019/q1/119">CVE-2019–5736</a> que permitia um container escapar e ter acesso root no host.</p><p>Rootless roda o docker (e os runtimes) como um usuário não root, trazendo um avanço significativo de segurança.</p><p>Até então o modo rootless no docker era experimental, mas na versão <a href="https://www.docker.com/blog/introducing-docker-engine-20-10/">20.10</a> (lançado em dez/2020) virou estável.</p><p>Um site ótimo que fala sobre containers rootless é o <a href="https://rootlesscontaine.rs/">rootlesscontaine.rs</a>, ele explica como tudo funciona e as instruções de como usar.</p><h3>Conclusão</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZBXPTXOSGXxz_gjA" /><figcaption><a href="https://turnoff.us/geek/linux-containers/">turnoff.us/geek/linux-containers/</a></figcaption></figure><p>Vimos as primitivas do kernel Linux que fazem os containers funcionarem e as diferenças com máquinas virtuais, quem se interessou e quiser aprender mais vou deixar algumas referências.</p><p>Pra quem tá começando recomendo os seguintes materiais:</p><ul><li><a href="https://docker-curriculum.com/">docker-curriculum.com</a>: É um tutorial bem prático e completo.</li><li><a href="https://livro.descomplicandodocker.com.br/">Descomplicando Docker</a>: Curso do LINUXtips em português brasileiro, a LINUXtips tem vários cursos excelentes de Devops.</li><li><a href="https://www.udemy.com/course/docker-mastery/">Docker Mastery</a>: É o curso que mais gosto ;) ele é bem completo e passa várias dicas para depurar os containers e ainda faz uma breve introdução sobre orquestração de containers (docker swarm e kubernetes).</li></ul><p>Para montar esse texto usei o livro da Liz Rice: <a href="https://www.oreilly.com/library/view/container-security/9781492056690/">Container Security: Fundamental Technology Concepts that Protect Containerized Applications</a>, é bem completo e quem curte segurança vai adorar. A mesma autora tem uma talk legal <a href="https://www.youtube.com/watch?v=Utf-A4rODH8">Building a conteiner from scratch in Go</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d24907dcf08d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/como-cont%C3%AAineres-funcionam-d24907dcf08d">Como contêineres funcionam?</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Análise de redes complexas em Python com NetworkX e PyVis]]></title>
            <link>https://medium.com/computando-arte/an%C3%A1lise-de-redes-complexas-em-python-com-networkx-e-pyvis-bd8d67889918?source=rss----16b99e4b265c---4</link>
            <guid isPermaLink="false">https://medium.com/p/bd8d67889918</guid>
            <category><![CDATA[network-analysis]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Victoria Aires]]></dc:creator>
            <pubDate>Wed, 17 Nov 2021 12:49:00 GMT</pubDate>
            <atom:updated>2021-11-17T12:49:00.213Z</atom:updated>
            <content:encoded><![CDATA[<h4>Hora de colocar a mão na massa!</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ben78a4MWbNVQ4RI" /><figcaption>Photo by <a href="https://unsplash.com/@nasa?utm_source=medium&amp;utm_medium=referral">NASA</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>No meu artigo anterior aqui no blog, falei um pouco sobre redes complexas e como elas podem ser uma ferramenta útil para analisar diferentes tipos de problemas, oferecendo insights ricos e muito relacionados com suas aplicações no “mundo real”. Para quem perdeu ou gostaria de relembrar, segue o artigo no link abaixo.</p><p><a href="https://medium.com/computando-arte/uma-breve-introdu%C3%A7%C3%A3o-%C3%A0s-redes-complexas-63db41b4a9a6">Uma breve introdução às redes complexas</a></p><p>Mas na prática, como podemos trabalhar com dados de redes complexas? Falando especificamente sobre a linguagem Python, a biblioteca <a href="https://networkx.org/documentation/stable/index.html">NetworkX</a> é uma ótima opção. Trata-se de uma ferramenta para criação, manipulação e estudo de redes complexas, que facilita bastante obter insights e análises. Na minha visão, considero-a como uma biblioteca muito completa, e de fácil aprendizado quando comparada a outras opções que já pude testar.</p><p>No entanto, o ponto fraco do NetworkX é o módulo de visualização dos grafos, que pode ser muito complexo para compreender e ainda resultar em visualizações confusas e estáticas. Nesse sentido, um excelente complemento é a biblioteca <a href="https://pyvis.readthedocs.io/en/latest/">PyVis</a>, voltada para visualizações interativas de redes complexas, com a vantagem de integrar-se com o NetworkX. O melhor dos dois mundos! Neste artigo, veremos um exemplo prático combinando ambas as bibliotecas.</p><h3>1. A base de dados</h3><p>Para exemplificar uma aplicação de análise de redes complexas com Python, vamos utilizar uma base de dados disponível no <a href="https://www.kaggle.com/stackoverflow/stack-overflow-tag-network/metadata">Kaggle</a>, denominada <strong>Stack Overflow Tag Network</strong>. Esta base modela a correlação entre tags de tecnologias dentro da plataforma do Stack Overflow. Possui a seguinte estrutura:</p><ul><li>Vértices: as tags, como html, python, android, docker, etc.</li><li>Arestas: o número de vezes em que duas tags foram associadas.</li></ul><p>Como o número de vezes em que duas tags aparecem juntas pode variar, teremos um <strong>grafo ponderado</strong>, ou seja, há um <strong>peso </strong>ou <strong>valor</strong> associado à relação entre os vértices. Apesar de ser uma base de dados antiga, datada de 2017, ela é simples e interessante o suficiente para servir de exemplo à nossa aplicação.</p><p>Na base de dados, vamos utilizar apenas o arquivo stack_network_links.csv. Esse arquivo contém a lista das arestas do grafo, através das colunas <em>source</em>, <em>target </em>e <em>value</em>. Isso significa que, para cada linha, temos uma aresta entre os vértices <em>source</em> e <em>target</em>, e esse relacionamento tem a intensidade representada por <em>value</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/371/1*-cQh4tTrbl3j_jAyELluLg.png" /><figcaption>Amostra da lista de arestas disponibilizada na base de dados.</figcaption></figure><h3>2. Carregando os dados</h3><p>Para criar um grafo vazio com a biblioteca NetworkX, basta executar o comando abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3440f5e29bb4ea7214b76f8fa9690908/href">https://medium.com/media/3440f5e29bb4ea7214b76f8fa9690908/href</a></iframe><p>No nosso caso, não criaremos um grafo vazio: vamos carregar diretamente a lista de arestas disponibilizada na base de dados, como explicado anteriormente. Isso pode ser feito de acordo com o código a seguir. A função nx.parse_edgelist recebe como entrada uma lista de arestas. Podemos especificar dados extras, como peso das arestas, através do parâmetro data .</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e1365c819c6139c74ae6c8db2c25a3a6/href">https://medium.com/media/e1365c819c6139c74ae6c8db2c25a3a6/href</a></iframe><p>O resultado final é um objeto do tipo Graph , contendo os vértices e arestas representados na base de dados. É possível conferir quais são esses conjuntos através dos métodos G.nodes() e G.edges() . Como nossas arestas possuem um dado extra (o peso), podemos visualizá-lo através do método G.edges.data(&#39;weight&#39;) .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/607/1*hmKa2jlqIVr5JGOrx62Udw.png" /><figcaption>Os primeiros 5 vértices e 5 arestas do grafo, com seus respectivos pesos.</figcaption></figure><h3>3. Obtendo insights</h3><p>Com nosso grafo devidamente carregado, podemos analisar sua estrutura em busca de insights sobre os nós e os relacionamentos entre eles. Lembrando que, nesse caso, os vértices são tags de tecnologias, e as arestas indicam o número de vezes que um par de tags foi relacionada. Assim, métricas de redes complexas devem ser capazes de capturar informações interessantes nesse contexto.</p><p>No artigo anterior, comentei sobre métricas de <strong>centralidade</strong>, que demonstram os nós mais influentes em uma rede, segundo um critério específico. Também vimos o conceito de <strong>comunidades</strong>, estruturas que capturam um conjunto de vértices com um forte relacionamento entre si.</p><p>A seguir, vamos ver como trabalhar com esses conceitos e métricas utilizando as ferramentas da biblioteca NetworkX.</p><h4>Métricas de centralidade</h4><p>O NetworkX disponibiliza uma série de métricas de centralidade, e você pode conferi-las neste <a href="https://networkx.org/documentation/stable/reference/algorithms/centrality.html">link</a>. Para nosso exemplo, analisaremos três delas: centralidade de grau ponderado (ou <em>weighted degree</em>), intermediação (ou <em>betweenness</em>) e autovetor (ou <em>eigenvector</em>).</p><p><strong>Centralidade de grau ponderado: </strong>essa métrica representa a soma de todos os pesos das arestas ligadas a um dado nó. Assim, os nós mais influentes são aqueles que recebem mais ligações, ou as ligações com maiores intensidades.</p><p>No NetworkX, essa métrica pode ser calculada da seguinte forma: weighted_degree = G.degree(weight=&#39;weight&#39;) . Essa função retornará um dicionário onde as chaves são os vértices, e os valores são seus respectivos graus ponderados. Ordenando pelos maiores valores, temos o top 10 dos vértices mais influentes. Nota-se que são termos, em sua maioria, muito relacionados a ferramentas para desenvolvimento web em 2017.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*Be9HSG_GcmczLhF1e6ENhg.png" /><figcaption>Os 10 vértices mais influentes pela métrica de centralidade de grau ponderado.</figcaption></figure><p><strong>Centralidade de intermediação: </strong>nessa métrica, são considerados mais influentes os nós que aparecem mais vezes no caminho mínimo entre os outros nós da rede. Ou seja, os nós mais centrais são aqueles que funcionam como pontes, conectando os demais na estrutura da rede.</p><p>Para calcular a intermediação no NetworkX, basta executar betweenness = nx.betweenness_centrality(G, weight=&#39;weight&#39;) . O retorno da função, novamente, é um dicionário contendo o score de <em>betweenness</em> de cada nó.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/706/1*PCan-Hc7yumWP4dvf-UW2g.png" /><figcaption>Ranking dos 10 vértices mais influentes pela centralidade de intermediação.</figcaption></figure><p>Analisando os top 10 nós mais influentes pela intermediação, observamos tags que podem estar relacionadas a diferentes contextos: sistemas operacionais, bancos de dados, e web em geral. Como são termos que não são exclusivos a um nicho, faz sentido que eles sejam considerados como as principais pontes da rede.</p><p><strong>Centralidade de autovetor: </strong>o conceito dessa métrica é que vértices mais influentes compartilham suas influências com seus vizinhos. Basicamente, a ideia é a seguinte: nós de grau alto são muito relevantes, e compartilham essa relevância através de suas conexões, que compartilham com os vizinhos e assim sucessivamente.</p><p>Assim como nos exemplos anteriores, é simples computar a centralidade de autovetor, através do método eigenvector = nx.eigenvector_centrality(G, weight=&#39;weight&#39;) . O ranking dessa métrica, como podemos ver abaixo, é composto por alguns dos vértices mais influentes por grau ponderado, porém essa influência foi compartilhada com outros termos “bem relacionados”, como <em>javascript</em>, <em>mysql</em>, e <em>html</em>, todos relevantes no contexto de desenvolvimento web.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/711/1*dJ3Ucjet-fog2P12OnYlWA.png" /><figcaption>Top 10 vértices mais influentes pela centralidade de autovetor.</figcaption></figure><h4>Comunidades</h4><p>Falando sobre algoritmos para detecção de comunidades, a biblioteca NetworkX fornece diferentes opções, que você pode explorar <a href="https://networkx.org/documentation/stable/reference/algorithms/community.html">aqui</a>. Para nosso exemplo, utilizaremos a função greedy_modularity_communities , baseado em uma métrica chamada <strong>modularidade</strong>.</p><p>A modularidade descreve a qualidade dos grupos em um grafo. Quanto mais coeso, isto é, mais o grupo é conectado entre si, maior a modularidade. Esta métrica é usada por algoritmos para descobrir as comunidades dentro de uma dada rede.</p><p>O método implementado pelo NetworkX é o algoritmo de <a href="https://arxiv.org/abs/cond-mat/0408187">Clauset-Newman-Moore</a> de heurística gulosa para modularidade. Em outras palavras, o algoritmo aplica um critério simples para selecionar o conjunto de comunidades com a melhor modularidade. Para executá-lo na biblioteca, basta executar o código abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a618a94d190b0e786da5352887632e7c/href">https://medium.com/media/a618a94d190b0e786da5352887632e7c/href</a></iframe><p>No nosso exemplo, o algoritmo descobriu 14 comunidades. Cada uma delas está relacionada a um mesmo contexto: desenvolvimento web, sistemas operacionais, programação para Android e iOS, desenvolvimento ágil, e assim sucessivamente.</p><h3>4. Visualizando o grafo</h3><p>Como comentei no início do artigo, o NetworkX oferece suporte ao <a href="https://networkx.org/documentation/stable/reference/drawing.html">desenho</a> dos grafos. Porém, o resultado final costuma não ser satisfatório, sendo o principal ponto fraco da biblioteca. Para ilustrar, executei o código a seguir para desenhar nossa rede da melhor maneira possível.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/27784463103a8b265c2454ffd542db60/href">https://medium.com/media/27784463103a8b265c2454ffd542db60/href</a></iframe><p>O resultado foi uma visualização muito confusa, com sobreposição dos textos de cada vértice e um grande emaranhado de arestas, organizados de qualquer maneira.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c0c9IGa9OUP6r7cPTwLH_w.png" /><figcaption>Uma visualização gerada pelo NetworkX para nossa rede.</figcaption></figure><p>Para sanar esse ponto fraco, podemos utilizar a biblioteca PyVis, que recebe um grafo NetworkX como entrada e retorna uma visualização interativa. Podemos fazer ainda melhor: a biblioteca é capaz de colorir os vértices de acordo com um atributo, e no nosso caso vamos utilizar as comunidades. Para isso, vamos criar o atributo group no nosso grafo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9e78975abaef93bf5e3c9020793306d7/href">https://medium.com/media/9e78975abaef93bf5e3c9020793306d7/href</a></iframe><p>Caso você opte por executar o código em um notebook Jupyter, incluindo o Google Colab, as poucas linhas a seguir são suficientes para gerar um arquivo HTML contendo uma visualização interativa da nossa rede, onde vértices da mesma cor pertencem à mesma comunidade.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/08c89c3b2b5e55b0ee99bd3b8b47742e/href">https://medium.com/media/08c89c3b2b5e55b0ee99bd3b8b47742e/href</a></iframe><p>Você pode conferir o resultado abaixo, onde passamos por todas as comunidades. Levando em consideração que a base de dados é antiga, podemos visualizar tendências de tecnologias da época. Algumas associações ficam bem claras, como as comunidades formada por tecnologias da Apple, Android, sistemas operacionais, desenvolvimento web e até mesmo Excel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*MHGlm7mxKbmpdQDq4bGGWQ.gif" /><figcaption>Passeando pelas comunidades da rede de tags.</figcaption></figure><h3>Conclusão</h3><p>Caso você tenha interesse em modelar seu problema utilizando ciência de redes, a biblioteca NetworkX é uma excelente opção para isso. Além da integração com Python, ela fornece diversos recursos para você explorar e obter insights sobre os relacionamentos na rede.</p><p>Já a biblioteca PyVis é uma alternativa fácil de usar para gerar visualizações interativas. Como ela gera um HTML, você pode facilmente incorporá-lo em websites, aplicações e dashboards. Assim, qualquer pessoa que consultar sua análise pode interagir e entender melhor os componentes da rede!</p><p>Caso você queira conferir nossa rede de tags de tecnologia, basta acessar este <a href="https://colab.research.google.com/drive/1qNt9CCIeRmL02Pn_YBNSM6HVxiFeouWM?usp=sharing">notebook</a>. E caso tenha experiências e conhecimentos sobre outras formas de trabalhar com análise e visualização de redes, deixa aqui nos comentários! :D</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bd8d67889918" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computando-arte/an%C3%A1lise-de-redes-complexas-em-python-com-networkx-e-pyvis-bd8d67889918">Análise de redes complexas em Python com NetworkX e PyVis</a> was originally published in <a href="https://medium.com/computando-arte">Computando Arte</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>