<?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[Stories by Italo Vendrameto on Medium]]></title>
        <description><![CDATA[Stories by Italo Vendrameto on Medium]]></description>
        <link>https://medium.com/@ivendrameto?source=rss-7d8c2772b2e2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*ZJoN4Zw1dK9IABuIc5DO3A.jpeg</url>
            <title>Stories by Italo Vendrameto on Medium</title>
            <link>https://medium.com/@ivendrameto?source=rss-7d8c2772b2e2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 05:16:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ivendrameto/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Logging]]></title>
            <link>https://xp4.dev/logging-b8e2f895bc95?source=rss-7d8c2772b2e2------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8e2f895bc95</guid>
            <category><![CDATA[logging]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Italo Vendrameto]]></dc:creator>
            <pubDate>Mon, 05 Feb 2024 14:02:30 GMT</pubDate>
            <atom:updated>2024-02-05T14:25:58.959Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D0AkV3t441V9X0EYkfYvYQ.png" /></figure><p>Qualquer desenvolvedor que já precisou solucionar problemas em uma aplicação na qual não podia executar um debug no código ou acessar diretamente o banco de dados ou a infraestrutura, acabou sendo salvo pelo log da aplicação. Com o log, é possível simular o erro em um ambiente local e, assim, verificar se o problema reportado está relacionado aos dados em si ou a erros na codificação.</p><p>Embora o log seja uma ferramenta valiosa no arsenal dos desenvolvedores, muitas vezes acabamos gerando outros problemas, como:</p><ul><li>Registrando um grande volume de dados inúteis que podem dificultar a análise;</li><li>Em ambientes de nuvem (cloud), todo dado armazenado, seja um dado no banco de dados ou uma linha em um arquivo de log, gera custos;</li><li>No contexto da proteção de dados dos clientes, é essencial considerar logs com dados sensíveis.</li></ul><p><strong>Observações:</strong></p><ol><li>No decorrer deste artigo, consideraremos o uso de Java 17 e Spring-Boot 3. Algumas adaptações podem ser necessárias para versões anteriores do Java ou do Spring-Boot.</li><li>O framework de log padrão adotado pelo Spring é o Logback, e seguiremos essa recomendação, mesmo que algumas configurações tenham valores pré-definidos.</li><li>A aplicação de referência apresenta o uso de lombok para disponibilizar o logger nas classes mas essa é uma forma simples de ser revertida caso não se deseje utilizar lombok.</li></ol><p>GitHub: <a href="https://github.com/ivendrameto/xp4dev-logging">xp4dev-logging</a></p><h3>Níveis de Logs e Suas Finalidades</h3><p>O nível de log é uma maneira de categorizar mensagens de log com base em sua gravidade ou importância. Por exemplo, no Logback, existem cinco níveis de log predefinidos, cada um com um valor inteiro correspondente, conforme mostrado na lista abaixo:</p><ul><li><strong>TRACE (5000)</strong>: O nível TRACE é o nível de log mais baixo usado para registrar informações detalhadas de depuração, principalmente o fluxo de execução do aplicativo. É mais refinado em comparação com DEBUG.</li><li><strong>DEBUG (10000)</strong>: O nível DEBUG é usado para depurar mensagens que são menos detalhadas do que mensagens TRACE. Essas mensagens devem fornecer informações sobre o comportamento do aplicativo que podem ser úteis para solução de problemas.</li><li><strong>INFO (20000)</strong>: O nível INFO indica mensagens que descrevem o comportamento normal do aplicativo. Essas mensagens geralmente não são importantes o suficiente para causar preocupação, mas podem ajudar a monitorar o desempenho do aplicativo.</li><li><strong>WARN (30000)</strong>: O nível WARN indica mensagens que descrevem possíveis problemas ou avisos. Essas mensagens indicam que ocorreu algo inesperado ou potencialmente problemático, mas o aplicativo ainda pode funcionar normalmente.</li><li><strong>ERROR (40000)</strong>: O nível ERROR indica mensagens que descrevem erros ou exceções. Essas mensagens indicam que algo deu errado com o aplicativo e que ações corretivas podem ser necessárias.</li></ul><p>O nível de log é definido para a aplicação como um todo, e podemos definir níveis específicos em pacotes. Além disso, podemos desativar os logs usando o nível “<strong>OFF</strong>”.</p><p>Um entendimento importante é a progressão dos níveis definidos na aplicação. Por exemplo, se configurarmos o nível de log para INFO (com um valor de 20000), todas as mensagens de log com níveis de valor maior ou igual a 20000 serão registradas, o que inclui INFO, WARN e ERROR. Se configurarmos para DEBUG (com valor 10000), teremos DEBUG, INFO, WARN e ERROR.</p><p>Em geral, recomenda-se usar log em DEBUG durante o desenvolvimento, quando precisamos de mais dados para criar ou melhorar a aplicação. Em ambientes produtivos, é aconselhável usar INFO ou até mesmo WARN. O nível TRACE é normalmente usado no desenvolvimento de bibliotecas e frameworks, que exigem um maior volume de informações para depuração, mas raramente é necessário em uma aplicação final.</p><h3><em>Configurando Spring-Boot e Logback</em></h3><p>O Spring-Boot adota o Logback como seu framework padrão, mas é bastante flexível e permite a fácil adaptação para outros frameworks, como o Log4J. Sem nenhuma configuração adicional, a aplicação já estará configurada com o <strong>CONSOLE</strong> e o <strong>PATTERN</strong> padrões do Spring.</p><p>GitHub: <a href="https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/logback">Config de Logback para Spring</a></p><p>Pessoalmente, prefiro manter algumas configurações do meu projeto explícitas e visíveis no repositório de fontes, para que qualquer desenvolvedor possa facilmente entender as configurações do projeto. Portanto, substituo a configuração padrão do Logback criando o arquivo <strong>logback-spring.xml</strong> na pasta de recursos com o seguinte conteúdo:</p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>&lt;configuration&gt;<br>    &lt;include resource=&quot;org/springframework/boot/logging/logback/defaults.xml&quot;/&gt;<br><br>    &lt;appender name=&quot;STDOUT&quot; class=&quot;ch.qos.logback.core.ConsoleAppender&quot; &gt;<br>        &lt;filter class=&quot;ch.qos.logback.classic.filter.ThresholdFilter&quot;&gt;<br>            &lt;level&gt;${CONSOLE_LOG_THRESHOLD}&lt;/level&gt;<br>        &lt;/filter&gt;<br>        &lt;encoder&gt;<br>            &lt;pattern&gt;${CONSOLE_LOG_PATTERN}&lt;/pattern&gt;<br>            &lt;charset&gt;${CONSOLE_LOG_CHARSET}&lt;/charset&gt;<br>        &lt;/encoder&gt;<br>    &lt;/appender&gt;<br><br>    &lt;logger name=&quot;dev.xp4.article&quot; level=&quot;INFO&quot; /&gt;<br>    &lt;logger name=&quot;dev.xp4.article.tasks&quot; level=&quot;OFF&quot; /&gt;<br>    &lt;logger name=&quot;dev.xp4.article.tasks.error&quot; level=&quot;ERROR&quot; /&gt;<br>    &lt;logger name=&quot;dev.xp4.article.tasks.warn&quot; level=&quot;WARN&quot; /&gt;<br>    &lt;logger name=&quot;dev.xp4.article.tasks.info&quot; level=&quot;INFO&quot; /&gt;<br>    &lt;logger name=&quot;dev.xp4.article.tasks.debug&quot; level=&quot;DEBUG&quot; /&gt;<br>    &lt;logger name=&quot;dev.xp4.article.tasks.trace&quot; level=&quot;TRACE&quot; /&gt;<br>    &lt;logger name=&quot;dev.xp4.article.tasks.mask&quot; level=&quot;INFO&quot; /&gt;<br><br>    &lt;root level=&quot;INFO&quot;&gt;<br>        &lt;appender-ref ref=&quot;STDOUT&quot; /&gt;<br>    &lt;/root&gt;<br>&lt;/configuration&gt;</pre><p>Nesse exemplo de configuração, o nível da aplicação está definido como INFO. No entanto, em pacotes específicos, redefinimos o nível, tornando nossos logs mais versáteis.</p><h3>Alterando o Nível de Log sem Reiniciar</h3><p>Não é raro que seja necessário aumentar o nível de log de uma aplicação em produção para avaliar um problema relatado e que não pode ser simulado em outros ambientes. Na maioria dos casos, os desenvolvedores abririam um chamado, alterariam o nível nas configurações, fariam a implantação da aplicação com a alteração, coletariam os logs e, em seguida, repetiriam o processo para retornar o log ao nível anterior (caso seja necessário).</p><p>Esse processo envolve duas compilações da aplicação, além de uma implantação adicional com a correção. Além disso, acaba gerando mais logs do que o necessário.</p><p>Para evitar esse processo, podemos usar o Spring Actuator para alterar o nível de log sem a necessidade de qualquer alteração no artefato. O Spring Actuator permite que façamos consultas para verificar o nível atual e fornece um endpoint para alterar as configurações de log.</p><h4>Spring Actuator: Dependência</h4><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-boot-starter-actuator&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><h4>Configuração do Spring: application.yaml</h4><pre>management:<br>  endpoints:<br>    web:<br>      exposure:<br>        include: loggers<br>  endpoint:<br>    loggers:<br>      enabled: true</pre><p>Com essa configuração, podemos usar os seguintes endpoints para consultar os níveis de log:</p><ul><li>GET /actuator/loggers — listar todos os loggers</li><li>GET /actuator/loggers/ROOT — exibe o nível de log padrão da aplicação</li><li>GET /actuator/loggers/{name} — exibe o nível de log para a categoria {name}</li></ul><p>Para efetivamente alterar o nível de log de uma categoria, devemos usar uma chamada POST no endpoint /actuator/loggers/{name} com os cabeçalhos Accept: application/json e Content-Type: application/json. Em seguida, enviamos um corpo com a seguinte estrutura: {&quot;configuredLevel&quot;: &quot;novo-nível-log&quot;}</p><pre>curl -X POST http://localhost:8080/actuator/loggers/ROOT \<br>--header &quot;Accept: application/json&quot; \<br>--header &quot;Content-Type: application/json&quot; \<br>--data-raw &quot;{ \&quot;configuredLevel\&quot;: \&quot;ERROR\&quot; }&quot;</pre><h3>Tratando Dados Sensíveis</h3><p>Ao analisar aplicações em produção, frequentemente encontramos dados que não deveriam estar presentes nos logs, como endereços de e-mail ou números de documentos. Esses dados não devem ser registrados nos logs ou, pelo menos, não devem ser expostos integralmente. Outra situação comum em APIs REST é o registro de objetos inteiros, incluindo campos codificados em Base64 ou tokens de acesso.</p><p>Podemos dizer que cabe ao desenvolvedor revisar e remover esses dados dos logs. No entanto, sabemos que, dependendo do volume de atividades e de outras demandas, essa tarefa pode acabar sendo postergada e dificilmente será uma prioridade.</p><p>Praticamente todos os frameworks de log permitem a implementação de um Layout que permite criar um mecanismo para mascarar (ou “limpar”) esses dados.</p><p>Aqui temos um exemplo de Layout que recebe uma lista de expressões regulares para reconhecer um padrão de dados e substituí-los por “***”. Em seguida, temos a configuração desse Layout com alguns exemplos de expressões regulares.</p><p>Observação: Para fins de demonstração, o Layout está codificado no projeto, mas idealmente ele deveria ser isolado em uma biblioteca (lib) para permitir o re-uso.</p><h4><strong>DataCleanAndMaskingPatternLayout.java</strong></h4><pre>public class DataCleanAndMaskingPatternLayout extends PatternLayout {<br><br>    private String sensitiveMask = &quot;****&quot;;<br>    private char sensitiveCharMask = &#39;*&#39;;<br>    private Pattern aplpliedPattern;<br>    private List&lt;String&gt; maskPatterns = new ArrayList&lt;&gt;();<br><br>    public void addMaskPattern(String maskPattern) {<br>        maskPatterns.add(maskPattern);<br>        aplpliedPattern = Pattern.compile( maskPatterns.stream()<br>            .collect(Collectors.joining(&quot;|&quot;)), Pattern.MULTILINE);<br>    }<br><br>    @Override<br>    public String doLayout(ILoggingEvent event) {<br>        return maskMessage(super.doLayout(event));<br>    }<br><br>    private String maskMessage(String message) {<br>        //When masking is disabled in a environment<br>        if (aplpliedPattern == null) {<br>            return message;<br>        }<br>        StringBuilder sb = new StringBuilder(message);<br><br>        Matcher matcher = aplpliedPattern.matcher(sb);<br>        while (matcher.find()) {<br>            IntStream.rangeClosed(1, matcher.groupCount()).forEach(group -&gt; {<br>                if (matcher.group(group) != null) {<br>                    IntStream.range(matcher.start(group),<br>                        matcher.end(group)).forEach(i -&gt; sb.setCharAt(i, sensitiveCharMask));<br>                }<br>            });<br>        }<br><br>        return sb.toString().replaceAll(&quot;\\*{6,}&quot;, sensitiveMask);<br>    }<br><br>}<br></pre><h4><strong>Configuração do appender</strong></h4><pre>&lt;appender name=&quot;DATA_MASK&quot; class=&quot;ch.qos.logback.core.ConsoleAppender&quot;&gt;<br>    &lt;encoder class=&quot;ch.qos.logback.core.encoder.LayoutWrappingEncoder&quot;&gt;<br>        &lt;layout class=&quot;dev.xp4.article.logger.layout.DataCleanAndMaskingPatternLayout&quot;&gt;<br>            &lt;maskPattern&gt;((?!000|666)[0-8][0-9]{2}-(?!00)[0-9]{2}-(?!0000)[0-9]{4})&lt;/maskPattern&gt; &lt;!-- SSN --&gt;<br>            &lt;maskPattern&gt;(\b(?:\d{3}\.){2}\d{3}-\d{2}\b)&lt;/maskPattern&gt; &lt;!-- CPF --&gt;<br>            &lt;maskPattern&gt;(\b\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}\b)&lt;/maskPattern&gt; &lt;!-- CNPJ --&gt;<br>            &lt;maskPattern&gt;(\b\w+@\w+(\.\w+)+\b)&lt;/maskPattern&gt; &lt;!-- Email --&gt;<br>            &lt;pattern&gt;${CONSOLE_LOG_PATTERN}&lt;/pattern&gt;<br>        &lt;/layout&gt;<br>    &lt;/encoder&gt;<br>&lt;/appender&gt;</pre><h3>Considerações Finais</h3><p>Neste artigo, exploramos a importância do log em desenvolvimento de software e como o Logback, o framework de log padrão do Spring Boot, desempenha um papel fundamental. Definir corretamente os níveis de log e configurar adequadamente os logs é crucial para melhorar a depuração e o desempenho de sua aplicação.</p><p>Além disso, discutimos como o Spring Actuator permite que você altere os níveis de log em tempo real, evitando a necessidade de compilar e implantar novamente a aplicação em produção. Isso economiza tempo e recursos.</p><p>Por fim, abordamos a importância de tratar dados sensíveis nos logs e fornecemos um exemplo de como criar um mecanismo para mascarar esses dados. Proteger informações confidenciais nos logs é essencial para garantir a privacidade dos usuários e cumprir regulamentações de proteção de dados.</p><p>Lembre-se de que uma configuração eficiente de logs é uma prática fundamental no desenvolvimento de software, e dominar essa habilidade pode economizar tempo e recursos valiosos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8e2f895bc95" width="1" height="1" alt=""><hr><p><a href="https://xp4.dev/logging-b8e2f895bc95">Logging</a> was originally published in <a href="https://xp4.dev/">XP4Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Health Check / Probes]]></title>
            <link>https://xp4.dev/health-check-probes-2737b8bf962a?source=rss-7d8c2772b2e2------2</link>
            <guid isPermaLink="false">https://medium.com/p/2737b8bf962a</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[kubernetes-observability]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Italo Vendrameto]]></dc:creator>
            <pubDate>Tue, 30 Jan 2024 12:14:53 GMT</pubDate>
            <atom:updated>2024-01-30T12:14:53.509Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/881/1*NwS5lRaULv0H3MFrREuHeg.png" /></figure><p>Um conceito crucial que precisamos estabelecer é que a decisão de encerrar ou interromper uma aplicação é tomada pelo cluster. Em outras palavras, nosso cluster toma decisões com base em métricas e validações pré-configuradas, determinando se novas instâncias devem ser criadas ou se uma ou mais instâncias em execução devem ser encerradas.</p><p>Uma parte fundamental desse processo envolve a verificação da disponibilidade e saúde da aplicação e seus recursos. Essa avaliação é realizada por meio de uma configuração específica que chamamos de “probes”, que são divididas em três tipos: startup, readiness e liveness.</p><p>O conceito central por trás de todas as probes é realizar verificações que determinem se um recurso está disponível e funcional. Cada tipo de probe avalia uma fase diferente da inicialização da aplicação como um todo.</p><h3>Probes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/471/1*qVN5QLeIVcPnQQI0zDE6Qw.png" /></figure><h4>Startup Probe</h4><p>A “<em>Startup Probe</em>” é a primeira a entrar em ação e comunica ao kubelet que a aplicação dentro do container foi iniciada com êxito. As outras duas sondagens, “readiness” e “liveness”, permanecerão inativas até que o teste de inicialização seja concluído com sucesso.</p><p>Um exemplo prático do uso das sondagens de inicialização é o monitoramento de containers com tempos de inicialização mais demorados. Se, em vez disso, utilizássemos uma verificação de atividade para monitorar esses containers, poderíamos encerrá-los prematuramente, uma vez que nenhum dos aplicativos aparentaria ter sido iniciado com sucesso.</p><h4>Readiness Probe</h4><p>A “<em>Readiness Probe</em>” comunica ao cluster Kubernetes que o container está pronto para aceitar requisições, como aquelas que permitem que um usuário se conecte a um aplicativo da web. Se a verificação estiver em estado de falha, nenhum endereço IP será encaminhado para o pod, resultando na remoção do pod do serviço.</p><p>Essa verificação pode assegurar que o aplicativo em execução no container esteja 100% pronto para ser utilizado. No entanto, há situações em que a verificação não é capaz de determinar esse estado com precisão.</p><h4>Liveness Probe</h4><p>A “<em>Liveness Probe</em>” verifica se o container está em execução. Se o resultado do teste indicar que o container não está em execução, o kubelet identifica essa condição e encerra o processo do container. Normalmente, isso resultará na reinicialização do container, a menos que tenha sido configurado de forma diferente.</p><p>Essas sondagens desempenham um papel essencial no ecossistema do Kubernetes, permitindo o monitoramento da saúde e disponibilidade de nossas aplicações, garantindo operações contínuas e confiáveis em ambientes de containers.</p><h3>Maneiras de verificar a integridade de pods/containers usando Probes</h3><p>O Kubelet possui três maneiras principais de verificar a integridade de um pod:</p><h4>Probes HTTP</h4><p>As probes HTTP são o tipo mais comum de sondagens personalizadas. Definimos um número de porta juntamente com a URL. O Kubernetes faz uma requisição nesse caminho e, se receber uma resposta HTTP no intervalo 200 ou 300, considerará o aplicativo como íntegro. Caso contrário, marcará o aplicativo como não saudável. Mesmo que seu aplicativo não seja um servidor HTTP, você pode criar um servidor HTTP leve dentro dele para responder às sondagens de atividade.</p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: meu-pod<br>spec:<br>  containers:<br>  - name: meu-servico-container<br>    image: minha-imagem:latest<br>    ports:<br>    - containerPort: 80<br>    readinessProbe:<br>      httpGet:<br>        path: /meu-servico/health<br>        port: 80<br>      initialDelaySeconds: 15<br>      periodSeconds: 10</pre><h4>Probes TCP</h4><p>O Kubernetes tenta estabelecer uma conexão TCP na porta especificada. Se a conexão for estabelecida com sucesso, o container é considerado íntegro. Se não conseguir estabelecer a conexão, o container é considerado não saudável. As sondagens TCP são úteis em cenários nos quais as sondagens HTTP ou comandos não funcionam bem. Por exemplo, serviços gRPC ou FTP são candidatos ideais para esse tipo de sondagem.</p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: meu-pod<br>spec:<br>  containers:<br>  - name: meu-servidor-ftp<br>    image: minha-imagem-ftp:latest<br>    ports:<br>    - containerPort: 21<br>    readinessProbe:<br>      tcpSocket:<br>        port: 21<br>      initialDelaySeconds: 15<br>      periodSeconds: 10</pre><h4>Probes Command</h4><p>O Kubernetes executa um comando dentro do container e, se o comando retornar com um código de saída 0, o container é marcado como íntegro. Caso contrário, é considerado não saudável. Esse tipo de sondagem é útil quando não é possível ou desejável executar um servidor HTTP, mas é possível executar um comando que verifica a integridade do seu aplicativo.</p><p>Essas três abordagens oferecem flexibilidade na verificação da integridade dos pods, permitindo que você escolha a opção mais adequada às necessidades do seu aplicativo e cenário específico.</p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: meu-pod<br>spec:<br>  containers:<br>  - name: meu-container<br>    image: minha-imagem:latest<br>    ports:<br>    - containerPort: 80<br>    readinessProbe:<br>      exec:<br>        command:<br>        - /bin/sh<br>        - -c<br>        - /opt/validate-health.sh<br>      initialDelaySeconds: 15<br>      periodSeconds: 10</pre><h3>Configurando Probes</h3><p>As Probes oferecem uma variedade de campos que nos permitem controlar de forma precisa o comportamento das verificações de inicialização, prontidão e atividade:</p><ul><li><strong>initialDelaySeconds</strong>: Este campo representa o tempo que o Kubernetes aguardará antes de realizar a primeira verificação após o início do container. O valor padrão é 0 segundos, com um mínimo de 0.</li><li><strong>periodSeconds</strong>: O intervalo entre as verificações é determinado pelo campo periodSeconds. O valor padrão é de 10 segundos, com um mínimo de 1 segundo.</li><li><strong>timeoutSeconds</strong>: Este campo define o número de segundos após os quais a probe atingirá o tempo limite. O valor padrão é de 1 segundo, com um mínimo de 1 segundo.</li><li><strong>SuccessThreshold</strong>: Indica o número mínimo de sucessos consecutivos necessários para que a probe seja considerada bem-sucedida após falhar. O valor padrão é 1, e deve permanecer como 1 para verificações de atividade e inicialização. O valor mínimo permitido é 1.</li><li><strong>failedThreshold</strong>: Este campo determina quantas vezes consecutivas uma análise pode falhar antes que o Kubernetes considere a verificação geral como falha. No caso de uma probe de inicialização ou atividade, se pelo menos a quantidade especificada no failedThreshold de probe falharem, o Kubernetes considerará o container como não íntegro e acionará a reinicialização específica desse container.</li></ul><p>Esses campos fornecem controle preciso sobre o comportamento das Probes no Kubernetes, permitindo que você ajuste as verificações de acordo com os requisitos específicos de sua aplicação e ambiente.</p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: meu-pod<br>spec:<br>  containers:<br>  - name: meu-container<br>    image: minha-imagem:latest<br>    ports:<br>    - containerPort: 80<br>    readinessProbe:<br>      httpGet:<br>        path: /meu-servico/health<br>        port: 80<br>      initialDelaySeconds: 15<br>      periodSeconds: 10<br>      timeoutSeconds: 5<br>      successThreshold: 3<br>      failureThreshold: 2</pre><p>Neste exemplo:</p><ul><li>initialDelaySeconds: O Kubernetes aguardará 15 segundos após o início do contêiner antes de realizar a primeira verificação de prontidão.</li><li>periodSeconds: As verificações de prontidão serão executadas a cada 10 segundos.</li><li>timeoutSeconds: Se a verificação de prontidão não obtiver uma resposta dentro de 5 segundos, será considerada falha.</li><li>successThreshold: São necessários 3 sucessos consecutivos para que a probe seja considerada bem-sucedida após uma falha.</li><li>failureThreshold: Após 2 falhas consecutivas, o Kubernetes considerará a verificação geral como falha e acionará a reinicialização do contêiner.</li></ul><h3>Java 17, Spring-boot 3 e Health Check / Probes</h3><p>Bom nós já abordamos a estratégia do ponto de vista do K8S agora vamos dar uma olhada em como preparar a nossa aplicação para receber corretamente o sinal de desligamento e executar o mesmo.</p><p>O Spring-boot já possui um conjunto de operações para realizar essa ação através de um endpoint, para tanto iremos incluir uma dependencia no pom da aplicação e incluir algumas linhas no nosso arquivos de configuração application.yaml</p><h4>Spring Actuator : Dependencia</h4><p>O Spring Actuator irá nos fornecer todos os recursos necessários para que possamos monitorar e gerenciar a nossa aplicação, nesse caso o que precisamos é habilitar o endpoint de shutdown.</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-boot-starter-actuator&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><h4>Spring Actuator : Health Check / Probes</h4><pre># Actuator Health Check / Probes<br>management:<br>  health:<br>    liveness-state:<br>      enabled: true<br>    readiness-state:<br>      enabled: true<br>  endpoints:<br>    web:<br>      exposure:<br>        include: health<br>  endpoint:<br>    health:<br>      show-details: always<br>      enabled: true</pre><p>Agora, podemos enviar um GET para os endpoints <strong>/actuator/health</strong>, <strong>/actuator/health/livenessState</strong> e <strong>/actuator/health/readinessState</strong> para verificar o estado da aplicação.</p><h3>Considerações Finais</h3><p>Neste artigo, exploramos detalhadamente a importância dos health checks e probes no ecossistema do Kubernetes. Essas ferramentas desempenham um papel crucial na garantia da saúde e disponibilidade de suas aplicações em containers, proporcionando um controle preciso sobre o ciclo de vida das mesmas.</p><p>Os health checks e probes não são apenas recursos do Kubernetes eles representam uma abordagem fundamental para o gerenciamento de aplicativos em ambientes dinâmicos.</p><p>Alguns pontos de destaque:</p><ol><li>Resiliência em Ambientes Dinâmicos</li><li>Precisão no Controle</li><li>Proatividade e Recuperação</li><li>Monitoramento Contínuo</li><li>Personalização e Otimização</li></ol><p>À medida que você aprofunda seus conhecimentos sobre health checks e probes, estará melhor equipado para construir aplicações mais robustas, resistentes a falhas e altamente disponíveis em ambientes Kubernetes.</p><p>Lembre-se de que as aplicações são tão boas quanto sua saúde, e as probes são suas ferramentas para manter a saúde em dia.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2737b8bf962a" width="1" height="1" alt=""><hr><p><a href="https://xp4.dev/health-check-probes-2737b8bf962a">Health Check / Probes</a> was originally published in <a href="https://xp4.dev/">XP4Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Graceful Shutdown]]></title>
            <link>https://xp4.dev/graceful-shutdown-82ed846068a2?source=rss-7d8c2772b2e2------2</link>
            <guid isPermaLink="false">https://medium.com/p/82ed846068a2</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[observability]]></category>
            <dc:creator><![CDATA[Italo Vendrameto]]></dc:creator>
            <pubDate>Mon, 22 Jan 2024 22:52:46 GMT</pubDate>
            <atom:updated>2024-01-22T22:52:46.975Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/881/1*NwS5lRaULv0H3MFrREuHeg.png" /></figure><p>Um conceito importante que precisamos estabelecer é que “<em>quem determina se uma aplicação será terminada ou interrompida é o cluster”</em>. Isso significa que nosso cluster, com base em métricas e validações pré-configuradas, toma a decisão de criar novas instâncias ou finalizar uma ou mais instâncias em execução.</p><h3>O que é Graceful Shutdown?</h3><p>Quando uma aplicação é terminada ou interrompida, ela pode estar no meio de uma operação, como processar um cálculo ou persistir um dado. Se for finalizada abruptamente, inconsistências podem ocorrer. O ideal é que, ao ser encerrada, a aplicação saiba lidar com isso e conclua todas as operações em andamento, como finalizar uma requisição já iniciada ou liberar recursos.</p><h3>Sinais IPC (Inter-Process Communication)</h3><p>Os sinais IPC são enviados pelo sistema operacional para indicar ao programa que ele será finalizado. Abaixo está uma tabela com alguns sinais e suas descrições, bem como as ações padrão associadas a eles:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/552d1b2327ca333a8887d567f41b6c50/href">https://medium.com/media/552d1b2327ca333a8887d567f41b6c50/href</a></iframe><h3>Kubernetes e Graceful Shutdown</h3><p>Quando levamos esses conceitos para o nível de um cluster Kubernetes, percebemos que o Kubernetes opera de maneira contínua, analisando constantemente configurações como o número de réplicas, escalabilidade horizontal, a saúde das aplicações e a disponibilidade de recursos. Com base nessas informações, o Kubernetes toma decisões e realiza ações, como criar, terminar ou interromper pods (os containers de aplicações).</p><p>Essa abordagem permite que o Kubernetes seja altamente dinâmico e responsivo às necessidades do ambiente, garantindo que os recursos sejam alocados de maneira eficiente e que as aplicações possam escalar de forma adaptativa. Portanto, o Kubernetes desempenha um papel fundamental na implementação de um “<em>graceful shutdown</em>” em um ambiente de containers, onde é essencial garantir a conclusão adequada das tarefas em andamento e a liberação adequada dos recursos antes de encerrar uma aplicação ou serviço.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/351/1*YiG_HZSoeN4QBh-yt-XigA.png" /></figure><h4><strong>Terminar/Interromper um POD</strong></h4><p>Nesse processo, o cluster Kubernetes utiliza dois sinais, <strong>SIGTERM</strong> e <strong>SIGKILL</strong>, ao decidir remover um POD. Quando o cluster envia um sinal <strong>SIGTERM</strong>, espera que a aplicação o receba e finalize. Após o envio do <strong>SIGTERM</strong>, o cluster aguarda um período de tempo. Caso o POD não seja finalizado dentro desse período, o cluster envia o sinal <strong>SIGKILL</strong> para encerrar o processo de forma mais abrupta.</p><p>O intervalo de tempo entre os sinais <strong>SIGTERM</strong> e <strong>SIGKILL</strong> é especificado no Deployment do POD pela definição <strong>terminationGracePeriodSeconds</strong>. Se não for informado, o valor padrão é de 30 segundos</p><pre>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: minha-aplicacao<br>spec:<br>  replicas: 3<br>  selector:<br>    matchLabels:<br>      app: minha-aplicacao<br>  template:<br>    metadata:<br>      labels:<br>        app: minha-aplicacao<br>    spec:<br>      containers:<br>      - name: minha-aplicacao<br>        image: minha-imagem:latest<br>        ports:<br>        - containerPort: 80<br>        terminationGracePeriodSeconds: 60</pre><p>Neste exemplo, estamos criando um Deployment chamado minha-aplicacao. Observe a inclusão da linha <strong>terminationGracePeriodSeconds: 60</strong>. Isso define um período de término gracioso de 60 segundos para o container quando o Kubernetes decide encerrá-lo.</p><p>O valor <strong>terminationGracePeriodSeconds</strong> especifica o tempo que o Kubernetes aguardará após enviar o sinal <strong>SIGTERM</strong> antes de enviar o sinal <strong>SIGKILL</strong> para encerrar o container. Neste caso, estamos dando à aplicação um minuto (60 segundos) para concluir as operações em andamento e liberar recursos antes do encerramento final.</p><p>Certifique-se de ajustar o valor de <strong>terminationGracePeriodSeconds</strong> conforme necessário, dependendo das necessidades específicas da sua aplicação.</p><h4><strong>Preparando as Aplicações para Receber o SIGTERM</strong></h4><p>Quando o cluster envia o sinal <strong>SIGTERM</strong>, ele verifica as configurações do Deployment em busca de definições de preStop. Se essas definições estiverem presentes, são executadas.</p><h4>preStop</h4><p>As definições de preStop permitem a execução de comandos, scripts ou até mesmo a chamada de um endpoint. Isso oferece a capacidade de implementar um fluxo de término seguro para as aplicações. Essa etapa é crucial para garantir que as aplicações tenham a oportunidade de concluir operações em andamento, finalizar conexões e liberar recursos antes de serem interrompidas. Isso contribui para um encerramento controlado e evita possíveis problemas de consistência ou perda de dados.</p><p>Portanto, configurar adequadamente as definições de preStop é uma prática importante para garantir um término de POD responsável e seguro em um ambiente Kubernetes.</p><h4>Execução de um Comando em preStop</h4><pre>containers:<br>- name: minha-aplicacao<br>  image: minha-imagem:latest<br>  ports:<br>  - containerPort: 80<br>  lifecycle:<br>    preStop:<br>      exec:<br>        command: [&quot;/bin/sh&quot;, &quot;-c&quot;, &quot;echo &#39;Encerrando minha aplicação...&#39;&quot;]</pre><p>Neste exemplo, a definição preStop executa um comando shell (/bin/sh -c) para imprimir uma mensagem de encerramento antes que o container seja finalizado. Isso pode ser útil para registrar eventos importantes ou realizar ações de limpeza antes de encerrar a aplicação.</p><h4>Chamando um Endpoint em preStop</h4><pre>containers:<br>- name: minha-aplicacao<br>  image: minha-imagem:latest<br>  ports:<br>  - containerPort: 80<br>  lifecycle:<br>    preStop:<br>      httpGet:<br>        path: /encerrar<br>        port: 80</pre><p>Neste exemplo, a definição preStop faz uma chamada HTTP para o endpoint /encerrar na porta 80 do próprio container. Isso permite que a aplicação execute um procedimento de término personalizado, que pode incluir operações de limpeza ou notificação a outros serviços antes de ser interrompida.</p><p>Lembre-se de adaptar esses exemplos de acordo com a sua aplicação e os requisitos específicos de término que você deseja implementar.</p><h3>Java 17, Spring-boot 3 e Graceful Shutdown</h3><p>Agora que cobrimos a estratégia do ponto de vista do Kubernetes, é hora de explorar como preparar nossa aplicação para receber e executar corretamente o sinal de desligamento.</p><p>O Spring-Boot já oferece um conjunto de operações para realizar essa ação por meio de um endpoint. Para isso, incluiremos uma dependência no arquivo pom da aplicação e algumas linhas de configuração em nosso arquivo <strong>application.yaml</strong>.</p><h4>Spring Actuator: Dependência</h4><p>O Spring Actuator nos fornece todos os recursos necessários para monitorar e gerenciar nossa aplicação. Nesse caso, nosso foco é habilitar o endpoint de desligamento.</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-boot-starter-actuator&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><h4>Spring Actuator: Desligamento</h4><p>O endpoint de desligamento está desabilitado por padrão, então é necessário ativá-lo, conforme demonstrado abaixo:</p><pre># Actuator Shutdown<br>management:<br>  endpoints:<br>    web:<br>      exposure:<br>        include: shutdown<br>  endpoint:<br>    shutdown:<br>      enabled: true</pre><p>Agora, podemos enviar um POST para o endpoint <strong>/actuator/shutdown</strong> para iniciar o processo de desligamento.</p><h4>Spring Actuator e Configuração do Servidor</h4><p>Com a configuração anterior, a aplicação finalizará imediatamente após receber um POST no endpoint <strong>/actuator/shutdown</strong>, sem tentar desconectar recursos, semelhante a um SIGKILL. Para evitar isso, precisamos indicar ao servidor que desejamos que os recursos sejam desligados antes. Isso é feito usando o conceito de “<em>graceful shutdown</em>”.</p><p>Outro ponto importante é que, da mesma forma que o Kubernetes define um tempo entre os sinais SIGTERM e SIGKILL, aqui também temos um conceito semelhante. Portanto, definimos <strong>timeout-per-shutdown-phase</strong> para especificar um tempo. Se a aplicação não concluir o desligamento dentro desse período, o desligamento será concluído imediatamente.</p><pre># Configuração do Servidor<br>server:<br>  shutdown: graceful<br><br>spring:<br>  lifecycle:<br>    timeout-per-shutdown-phase: 80</pre><p>Com essa configuração, nossa aplicação estará pronta para receber o sinal de desligamento de forma adequada e garantir um desligamento controlado e seguro, respeitando o período especificado. Isso é crucial para manter a integridade de dados e garantir que todos os recursos sejam liberados corretamente durante o processo de encerramento.</p><h3>Considerações Finais</h3><p>Neste artigo, destacamos a importância do término grácil de aplicações Java 17 e Spring-Boot 3 no contexto do Kubernetes. Compreender como encerrar aplicações de forma controlada é fundamental para garantir que operações em andamento sejam finalizadas e recursos sejam liberados adequadamente.</p><p>A integração do Spring Actuator e a configuração de desligamento no servidor são passos cruciais para um desligamento seguro e eficiente. Isso mantém a integridade dos dados e a confiabilidade de todo o ambiente de containers.</p><p>Assim como o Kubernetes prioriza o término seguro dos pods, é vital que nossas aplicações sigam essas práticas para criar sistemas resilientes e confiáveis. Ao adotar estratégias de término grácil, contribuímos para uma experiência mais estável para nossos usuários e uma operação mais suave em ambientes dinâmicos.</p><p>Com as ferramentas e conhecimentos fornecidos, você está pronto para aprimorar a qualidade e a segurança de suas aplicações Java e Spring-Boot no Kubernetes. Lembre-se de adaptar essas práticas às necessidades específicas de sua aplicação e continue explorando maneiras de otimizar o ciclo de vida de seus aplicativos.</p><p>Encerramos esta jornada de exploração do “<em>Graceful Shutdown</em>” e esperamos que as informações compartilhadas tenham sido valiosas para aprimorar suas implementações de containers e desenvolvimento de software.</p><p>Agradecemos por nos acompanhar e desejamos a você muito sucesso em seus projetos e operações de containers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82ed846068a2" width="1" height="1" alt=""><hr><p><a href="https://xp4.dev/graceful-shutdown-82ed846068a2">Graceful Shutdown</a> was originally published in <a href="https://xp4.dev/">XP4Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Shell Script — Variáveis]]></title>
            <link>https://xp4.dev/shell-script-vari%C3%A1veis-51a633cd61ef?source=rss-7d8c2772b2e2------2</link>
            <guid isPermaLink="false">https://medium.com/p/51a633cd61ef</guid>
            <category><![CDATA[shell-script]]></category>
            <dc:creator><![CDATA[Italo Vendrameto]]></dc:creator>
            <pubDate>Wed, 10 Jan 2024 18:03:17 GMT</pubDate>
            <atom:updated>2024-01-10T18:03:17.748Z</atom:updated>
            <content:encoded><![CDATA[<h3>Shell Script — Variáveis</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LDUAxhAjAcnUW5BgMvIodQ.jpeg" /></figure><p>Shell script é uma linguagem de script usada em vários sistemas operativos (operacionais), com diferentes dialetos, dependendo do interpretador de comandos utilizado. Um exemplo de interpretador de comandos é o bash, usado na grande maioria das distribuições GNU/Linux.</p><p>Como qualquer recursos de desenvolvimento nós precisamos de uma forma de armazenar e manipular dados que geramos e coletamos durante a execução dos nossos scripts e não poderia ser diferente em shell script também utilizamos variáveis para esse fim. Vamos seguir com alguns exemplos de criação e manipulação de variáveis em shell.</p><p><strong>Observação</strong>:</p><p>Todos os scripts demonstrados nesse artigo iniciam com <strong>#!/bin/bash</strong> isso indica que esse é o interpretador de comandos a ser usado durante esse script, com isso mesmo que o usuário ou sistema não use o bash como padrão se ele estiver disponível seu script funcionará.</p><h3>Atribuição e uso</h3><p>Basicamente para criar uma variável em shell basta definir seu nome utilizar o = e definir seu valor, para utilizar uma variável incluímos o <strong>$</strong> junto ao seu nome.</p><blockquote><strong>Sintaxe criação</strong>: <em>NOME_DA_VARIAVEL=valor-da-variavel</em></blockquote><blockquote><strong>Sintaxe uso</strong>: <em>echo $NOME_DA_VARIAVEL</em></blockquote><p>Como convenção de nomes podemos citar:</p><ol><li>todas as letras maiusculas</li><li>separação de termos por underscore</li><li>são declaras no inicio do script</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/67f910f7342b5b04590f95e3873490fa/href">https://medium.com/media/67f910f7342b5b04590f95e3873490fa/href</a></iframe><h3>Variáveis String e Number</h3><p>Para variaveis simples que armazenam strings ou números seguimos basicamente a convenção de nomes e fazemos atribuição direta podemos fazer algumas operações e uso com essas variaveis como segue:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/524018861570a51fc611360f9946455a/href">https://medium.com/media/524018861570a51fc611360f9946455a/href</a></iframe><h3>Variáveis Array</h3><p>Para declarar um array nós colocamos seus elementos entre ( ) e entre os elementos utilizamos o espaço, isso já nos indica que se um elemento contenha espaços é necessário delimitá-lo com “”.</p><p>Sintaxe criação: NOME_DO_ARRAY=([elemento] [elemento] [element] … [elemento])</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5c13e5109988c44c8913dd56aa43cc4e/href">https://medium.com/media/5c13e5109988c44c8913dd56aa43cc4e/href</a></iframe><p>A utilização de um array em um loop ou mesmo algum tipo de iteração, exige que possamos referenciar alguns de seus elementos seu tamanho e para isso temos as seguintes formas.</p><p><strong>${NOME_DO_ARRAY[@]} </strong>— retorna todos os elementos do array</p><p><strong>${#NOME_DO_ARRAY[@]}</strong> — retorna o numero de elementos do array</p><p><strong>${!NOME_DO_ARRAY[@]} </strong>— retorna a lista de indices do array</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8c2de9e28027d6a80c9517bd31667eaf/href">https://medium.com/media/8c2de9e28027d6a80c9517bd31667eaf/href</a></iframe><p><strong>Buscando valor em um array</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b85ff2e93c8a2f1959c6f0404a2a17be/href">https://medium.com/media/b85ff2e93c8a2f1959c6f0404a2a17be/href</a></iframe><p><strong>Concatenando arrays</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3497f0d6889c755caa38cc7f4caa7fdd/href">https://medium.com/media/3497f0d6889c755caa38cc7f4caa7fdd/href</a></iframe><h3>Variáveis com resultado de comandos</h3><p>Qualquer comando que gere uma saida no console pode ter essa saída utilizada para criação de uma variável, podemos listar os arquivos de uma pasat e gerar um array com seus nomes, podemos consultar um recursos da máquina é possível chamar uma url e tratar seu retorno, ou seja, são inúmeras possibilidades, vamos abordar algumas.</p><blockquote><strong>Sintaxe</strong>: <em>NOME_DA_VARIAVEL=$(comando ou comandos)</em></blockquote><p><strong>Comando que retorna apenas um valor String ou Number</strong></p><p>Para fins de testes vamos utilizar o comando do <strong>docker -v</strong> esse comando imprime em no console apenas uma linha como esta: <strong>Docker version 20.10.7, build f0df350</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/52eda7b40ab67fcf65b314f09d8e0f78/href">https://medium.com/media/52eda7b40ab67fcf65b314f09d8e0f78/href</a></iframe><p><strong>Comando que retorna uma lista de valores</strong></p><p>Vamos utilizar também o comando docker apenas para listar o hash dos containers em execução <strong>docker container ls -a -q</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/69dece07a942f065b63802ae366a30ae/href">https://medium.com/media/69dece07a942f065b63802ae366a30ae/href</a></iframe><h3>Finalizando</h3><p>Essa é uma visão geral de como criar variáveis e utilizá-las no fluxo de execução de scripts ecom base nessas estruturas podemos compor estruturas mais complexas de execução.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=51a633cd61ef" width="1" height="1" alt=""><hr><p><a href="https://xp4.dev/shell-script-vari%C3%A1veis-51a633cd61ef">Shell Script — Variáveis</a> was originally published in <a href="https://xp4.dev/">XP4Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Shell Script — Iniciando]]></title>
            <link>https://xp4.dev/shell-script-iniciando-0d965b50249e?source=rss-7d8c2772b2e2------2</link>
            <guid isPermaLink="false">https://medium.com/p/0d965b50249e</guid>
            <category><![CDATA[bash]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[shell-script]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Italo Vendrameto]]></dc:creator>
            <pubDate>Mon, 16 Oct 2023 15:50:55 GMT</pubDate>
            <atom:updated>2023-10-30T12:05:43.432Z</atom:updated>
            <content:encoded><![CDATA[<h3>Shell Script — Iniciando</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*fWBICC72mCgEl81Z6Hz_Pw.jpeg" /></figure><p>Shell script é uma linguagem de script usada em vários sistemas operativos (operacionais), com diferentes dialetos, dependendo do interpretador de comandos utilizado. Um exemplo de interpretador de comandos é o bash, usado na grande maioria das distribuições GNU/Linux.</p><p>Antes de falarmos sobre Shell Script precisamos conhecer alguns comandos LINUX que são muito úteis no dia-a-dia e que serão um incremento aos nossos scripts.</p><p>Para facilitar os exemplos criei um projeto no GitHub com os conteúdos necessários para execução dos exemplos. Partiremos do principio que o projeto será clonado na pasta home do seu usuário. (~/)</p><p><a href="https://github.com/ivendrameto/xp4dev-shellscript">GitHub (xp4dev-shellscript)</a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9ae6b671ef26ff9d4b2024d3deb02261/href">https://medium.com/media/9ae6b671ef26ff9d4b2024d3deb02261/href</a></iframe><h3>Entendendo stdin, stdout e stderr</h3><p><strong>stdin</strong> — STandarD INput ou Entrada Padrão: utilizado quando recebemos parâmetros em nosso script via linha comando ou leitura via teclado com comando read por exemplo</p><p><strong>stdout</strong> — STandarD OUTput ou Saída Padrão: representa a saída de dados de um comando/programa na linha de comando — pode ser representado pelo 1 na linha de comando</p><p><strong>stderr</strong> — STandarD ERRor ou Erro Padrão: representa a saída de erros de um comando/programa na linha de comando — pode ser representado pelo 2 na linha de comando</p><p><strong>Dicas:</strong></p><ol><li>o uso de ‘&gt; arquivo’ limpa o conteúdo do arquivo e adiciona stdout</li><li>o uso de ‘1&gt; arquivo’ limpa o conteúdo do arquivo e adiciona stdout</li><li>o uso de ‘2&gt; arquivo’ limpa o conteúdo do arquivo e adiciona stderr</li><li>o uso de ‘&amp;&gt; arquivo’ limpa o conteúdo do arquivo e adiciona stdout e stderr</li><li>o uso de ‘&gt;&gt;’ faz um append do novo conteúdo no final do arquivo destino</li></ol><h3>Comando: cat</h3><p>O cat é um dos comandos usados com mais frequência em sistemas operacionais do tipo Unix. Tem três funções relacionadas aos arquivos de texto: exibi-los, combinando cópias deles e criando novos.</p><blockquote><strong>Sintaxe</strong>: <em>cat [options] [filenames] [-] [filenames]</em></blockquote><p><strong>Lendo um arquivo</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/26e203aa46cdba08339d6db76d258573/href">https://medium.com/media/26e203aa46cdba08339d6db76d258573/href</a></iframe><p><strong>Concatenando arquivos</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f9e1a6c33e937ea8a8fee276df0de54/href">https://medium.com/media/4f9e1a6c33e937ea8a8fee276df0de54/href</a></iframe><p><strong>Criando arquivo</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/57727e37543651a735b239f6f2df044a/href">https://medium.com/media/57727e37543651a735b239f6f2df044a/href</a></iframe><h3>Comando: find</h3><p>O find realiza busca de arquivos em uma hierarquia de diretórios com base em um critério.</p><blockquote><strong>Sintaxe completa</strong>: <em>find [-H] [-L] [-P] [-D debugopts] [-Olevel] [starting-point…] [expression]</em></blockquote><blockquote><strong>Sintaxe mais utilizada</strong>: <em>find [diretório-inicio] -type &lt;type&gt; -name &lt;expression&gt;</em></blockquote><p><strong>Buscando pelo nome do arquivo</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d9e1a6d1deada335d7265582a509a4b0/href">https://medium.com/media/d9e1a6d1deada335d7265582a509a4b0/href</a></iframe><ol><li>inicialmente filtramos todos os arquivos .log</li><li>na sequencia filtramos arquivos com nome iniciando com ser e finalizado com .log</li><li>na sequencia filtramos arquivos com nome iniciando com app e finalizado com .log</li><li>na sequencia filtramos arquivos com nome iniciando com app e finalizado com .log e concluimos removendo arquivos com 3 no nome</li></ol><p><strong>Buscando diretórios</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8ff4c76caf9e1820d7c5abc547040ab5/href">https://medium.com/media/8ff4c76caf9e1820d7c5abc547040ab5/href</a></iframe><p><strong>Dicas:</strong></p><ol><li>outro parâmetro de busca que pode ser util -user &lt;usuário&gt;</li><li>para suprimir mensagens de “Permission denied” complementar o comando com: -print 2&gt;/dev/null (como exemplificado acima 2&gt; redireciona todas as mensagens de erro ‘stderr’ para /dev/null que é um dispositivo nulo utilizado para suprimir qualquer ‘saída’)</li></ol><h3>Comando: grep</h3><p>O grep filtra linhas em um arquivo que contém um determinado pattern.</p><blockquote><strong>Sintaxe</strong>: <em>grep [options] PATTERN [file…]</em></blockquote><p><strong>Filtro simples</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b2f02f679c1229ba61b3e7e012d15789/href">https://medium.com/media/b2f02f679c1229ba61b3e7e012d15789/href</a></iframe><p><strong>Filtrando por um conjunto</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/94dddf33f7e63ae1b7590eeea8386da0/href">https://medium.com/media/94dddf33f7e63ae1b7590eeea8386da0/href</a></iframe><p><strong>Dicas:</strong></p><ol><li>o grep faz distinção entre letras maiúsculas e minúsculas, caso queira filtrar tanto maiúsculas quanto minúsculas utilize a opção -i</li><li>a opção -n exibe o número da linha no arquivo</li><li>a opção -c exibe o número de ocorrências do pattern no arquivo</li></ol><h3>Comando: awk</h3><p>Na verdade o awk não é um simples comando, ele é uma linguagem de programação criada em 1977 nos laboratórios da Bell Labs. O nome awk é uma abreviatura dos seus criadores Alfred Aho, Peter J. Weinberger e Brian Kernighan — (Aho, Weinberger e Kernighan)</p><blockquote><strong>Sintaxe</strong>: <em>awk ‘/search_pattern/ { action_on_matches; another_action; }’ file</em></blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3f9bf3f2de95ea440319a513a0267b8c/href">https://medium.com/media/3f9bf3f2de95ea440319a513a0267b8c/href</a></iframe><p>No primeiro exemplo fazemos um filtro no arquivo procurando pela palavra Stark no ação é imprimir a linha, retornando duas linhas com isso validamos que o pattern é case-sensitive.</p><p>No segundo exemplo nós ajustamos a action para imprimir apenas o primeiro item de cada linha.</p><p>No terceiro exemplo adicionamos a opção <strong>-F</strong> para especificar que o separador de itens na linha deve ser o “<strong>;</strong>”</p><p>No último exemplo retiramos o pattern de filtro para que o awk processe o arquivo todo e na action montamos um String para impressão utilizando o primeiro item da linha “<strong>$1</strong>” e o último item da linha “<strong>$NF</strong>”</p><p><strong>Dicas:</strong></p><ol><li>o pattern de pesquisa é opcional, permitindo que o awk seja utilizado para organização dos dados</li><li>se não for informada a opção -F para definir o separador, o awk irá utilizar por padrão o espaço</li></ol><h3>Encadeando comandos com pipe (|)</h3><p>Um dos recursos mais utilizados em shell é compor saidas de dados resultante da execução de vários comandos em conjunto.</p><blockquote><strong>Sintaxe</strong>:<em> comando-1 [| comando-2]…[| comando-n]</em></blockquote><p>De forma geral o comando-1 será executado sua saida será repassada para o comando-2 como um “arquivo” que irá executar sobre esses dados e repassando o resultado para o comando subsequente até o ultimo comando da cadeia.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5b8203f8b158f966e00beaf3555e478e/href">https://medium.com/media/5b8203f8b158f966e00beaf3555e478e/href</a></iframe><p>No primeiro exemplo usamos o <strong>cat</strong> para listar todo o arquivo, e com o resultado aplicamos um <strong>grep -in</strong> onde ignoramos o case e imprimimos o número da linha no arquivo.</p><p>No segundo exemplo adicionamos o <strong>awk</strong> para manipular o resultado do <strong>grep</strong> para imprimir um resultado mais amigável.</p><h3>Encadeando comandos com ponto e vírgula (;)</h3><p>Usado para executar vários comandos sequencialmente em uma única operação. Diferente do pipe esse operador garante a execução de todos os comandos independentemente do status de saída do comando anterior, ou seja, são executados mesmo que o comando anterior tenha um status de conclusão diferente de zero.</p><blockquote><strong>Sintaxe</strong>:<em> comando-1 [; comando-2]…[; comando-n]</em></blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9f02146c6caf7e618e6220c423b211fe/href">https://medium.com/media/9f02146c6caf7e618e6220c423b211fe/href</a></iframe><p>Note que no segundo exemplo os comandos foram executado mesmo como o erro gerado pelo echox que não existe.</p><h3>Encadeando comandos com AND (&amp;&amp;)</h3><p>O comando que sucede a este AND só será executado se o comando anterior for executado com sucesso. É útil quando queremos executar um comando se o primeiro comando foi executado com sucesso.</p><blockquote><strong>Sintaxe</strong>:<em> comando-1 [&amp;&amp; comando-2]…[&amp;&amp; comando-n]</em></blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2dfa2216def1cb393b860740fe595c00/href">https://medium.com/media/2dfa2216def1cb393b860740fe595c00/href</a></iframe><p>Note que no segundo exemplo os comandos foram interrompidos após o erro gerado pelo echox que não existe.</p><h3>Encadeando comandos com OR lógico (||)</h3><p>O comando que sucede a este operador só será executado se a execução do comando anterior falhar. É muito parecido com uma declaração else. Se o status de execução do primeiro comando for diferente de zero, o segundo comando será executado.</p><blockquote><strong>Sintaxe</strong>:<em> comando-1 [|| comando-2]</em></blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5feb3de6af3200feda9660f4811c24de/href">https://medium.com/media/5feb3de6af3200feda9660f4811c24de/href</a></iframe><p>Note que no primeiro exemplo apenas o primeiro comando é executado e que no segundo exemplo o segundo comando foi executado após o erro gerado pelo <strong>echox</strong> que não existe.</p><h3><strong>Finalizando</strong></h3><p>Essa é uma visão geral de alguns comandos e controles que podemos utilizar em Shell Script, irei abordar em outros artigos temas como: criando variáveis, leitura de arquivos, controle de fluxo, etc.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0d965b50249e" width="1" height="1" alt=""><hr><p><a href="https://xp4.dev/shell-script-iniciando-0d965b50249e">Shell Script — Iniciando</a> was originally published in <a href="https://xp4.dev/">XP4Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Utilizando Shell Script — parte 1]]></title>
            <link>https://medium.com/contabilizei-tecnologia/utilizando-shell-script-parte-1-2dd9dcf8e9dd?source=rss-7d8c2772b2e2------2</link>
            <guid isPermaLink="false">https://medium.com/p/2dd9dcf8e9dd</guid>
            <category><![CDATA[find]]></category>
            <category><![CDATA[bash]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[shell-script]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Italo Vendrameto]]></dc:creator>
            <pubDate>Tue, 14 May 2019 11:31:00 GMT</pubDate>
            <atom:updated>2019-05-14T11:31:00.884Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f-xhcNBtIEf4Rz5mmIkMmg.jpeg" /></figure><h3>Utilizando Shell Script — parte 1</h3><p><strong>Shell script</strong> é uma linguagem de script usada em vários sistemas operativos (operacionais), com diferentes dialetos, dependendo do interpretador de comandos utilizado. Um exemplo de interpretador de comandos é o bash, usado na grande maioria das distribuições GNU/Linux.</p><p>Antes de falarmos sobre Shell Script precisamos conhecer alguns comandos LINUX que são muito úteis no dia-a-dia e que serão um incremento aos nossos scripts.</p><p>Para facilitar os exemplos criei um projeto no GitHub com os conteúdos necessários para execução dos exemplos. Partiremos do principio que o projeto será clonado na pasta home do seu usuário. (~/)</p><p>GitHub (comandos-linux)</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d1b6e888355356b3600498da432e9a02/href">https://medium.com/media/d1b6e888355356b3600498da432e9a02/href</a></iframe><h3>Entendendo stdin, stdout e stderr</h3><p><strong>stdin — STandarD INput ou Entrada Padrão</strong>: utilizado quando recebemos parâmentos em nosso script via linha comando ou leitura via teclado com comando read por exemplo</p><p><strong>stdout — STandarD OUTput ou Saída Padrão</strong>: representa a saída de dados de um comando/programa na linha de comando — pode ser representado pelo 1 na linha de comando</p><p><strong>stderr — STandarD ERRor ou Erro Padrão</strong>: representa a saída de erros de um comando/programa na linha de comando — pode ser representado pelo 2 na linha de comando</p><p><strong>Dicas</strong>:</p><ol><li><em>o uso de ‘</em><strong><em>&gt; arquivo</em></strong><em>’ limpa o conteúdo do arquivo e adiciona stdout</em></li><li><em>o uso de ‘1</em><strong><em>&gt; arquivo</em></strong><em>’ limpa o conteúdo do arquivo e adiciona stdout</em></li><li><em>o uso de ‘2</em><strong><em>&gt; arquivo</em></strong><em>’ limpa o conteúdo do arquivo e adiciona stderr</em></li><li><em>o uso de ‘&amp;</em><strong><em>&gt; arquivo</em></strong><em>’ limpa o conteúdo do arquivo e adiciona stdout e stderr</em></li><li><em>o uso de ‘</em><strong><em>&gt;&gt;</em></strong><em>’ faz um append do novo conteúdo no final do arquivo destino</em></li></ol><h3><strong>Comando: cat</strong></h3><p><em>O </em><strong><em>cat</em></strong><em> é um dos comandos usados com mais frequência em sistemas operacionais do tipo Unix. Tem três funções relacionadas aos arquivos de texto: exibi-los, combinando cópias deles e criando novos.</em></p><pre><strong>Sintaxe</strong>: <em>cat [options] [filenames] [-] [filenames]</em></pre><p><strong>Exemplos</strong>:</p><p>## Lendo um arquivo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b16fbc8613ffe232329eb83a0977c88e/href">https://medium.com/media/b16fbc8613ffe232329eb83a0977c88e/href</a></iframe><p>## Contatenando arquivos</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c19f71217b92a44dd794e3e71ef61bcd/href">https://medium.com/media/c19f71217b92a44dd794e3e71ef61bcd/href</a></iframe><p>## Criando arquivo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/50cbab73b4ca940097a244ebbb5e5ed0/href">https://medium.com/media/50cbab73b4ca940097a244ebbb5e5ed0/href</a></iframe><h3><strong>Comando: find</strong></h3><p><em>O </em><strong><em>find</em></strong><em> realiza busca de arquivos em uma hierarquia de diretórios com base em um critério.</em></p><pre><strong>Sintaxe completa</strong>: <em>find [-H] [-L] [-P] [-D debugopts] [-Olevel] [starting-point…] [expression]</em></pre><pre><strong>Sintaxe mais utilizada</strong>: <em>find [diretório-inicio] -type &lt;type&gt; -name &lt;expression&gt;</em></pre><p><strong>Exemplos</strong>:</p><p>## Buscando pelo nome do arquivo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a861553a13550de39958abe6fb75cb09/href">https://medium.com/media/a861553a13550de39958abe6fb75cb09/href</a></iframe><ol><li>inicialmente filtramos todos os arquivos .log</li><li>na sequencia filtramos arquivos com nome iniciando com <strong>ser</strong> e finalizado com <strong>.log</strong></li><li>na sequencia filtramos arquivos com nome iniciando com <strong>app</strong> e finalizado com <strong>.log</strong></li><li>na sequencia filtramos arquivos com nome iniciando com <strong>app</strong> e finalizado com <strong>.log </strong>e concluimos removento arquivos com <strong>3</strong> no nome</li></ol><p>## Buscando diretórios</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d56687eaaf0061fed7593f22b1ce88c6/href">https://medium.com/media/d56687eaaf0061fed7593f22b1ce88c6/href</a></iframe><p><strong>Dicas:</strong></p><ol><li><em>outro parâmetro de busca que pode ser util -user &lt;usuário&gt;</em></li><li><em>para suprimir mensagens de “</em><strong><em>Permission denied</em></strong><em>” complementar o comando com: </em><strong><em>-print 2&gt;/dev/null </em></strong>(como exemplificado acima 2&gt; redireciona todas as mensagens de erro ‘stderr’ para /dev/null que é um dispositivo nulo utilizado para suprimir qualquer ‘saída’)</li></ol><h3>Comando: grep</h3><p><em>O </em><strong><em>grep</em></strong><em> filtra linhas em um arquivo que contém um determinado pattern.</em></p><pre><strong>Sintaxe</strong>: <em>grep [options] PATTERN [file…]</em></pre><p><strong>Exemplos</strong>:</p><p>## Filtro simples</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bf2c89c302a62253ef7cfe5c0f75828e/href">https://medium.com/media/bf2c89c302a62253ef7cfe5c0f75828e/href</a></iframe><p>## Filtrando por um conjunto</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a1e1c23da5da4503bf82ceddce75b3ea/href">https://medium.com/media/a1e1c23da5da4503bf82ceddce75b3ea/href</a></iframe><p><strong>Dicas</strong>:</p><ol><li>O grep faz distinção entre letras maiúsculas e minúsculas, caso queira filtrar tanto maiúsculas quanto minúsculas utilize a opção -i</li><li><em>a opção </em><strong><em>-n</em></strong><em> exibe o número da linha no arquivo</em></li><li><em>a opção </em><strong><em>-c</em></strong><em> exibe o número de ocorrências do pattern no arquivo</em></li></ol><h3>Comando: awk</h3><p><em>Na verdade o awk não é um simples comando, ele é uma linguagem de programação criada em 1977 nos laboratórios da Bell Labs. O nome awk é uma abreviatura dos seus criadores Alfred Aho, Peter J. Weinberger e Brian Kernighan — (</em><strong><em>A</em></strong><em>ho, </em><strong><em>W</em></strong><em>einberger e </em><strong><em>K</em></strong><em>ernighan)</em></p><pre><strong>Sintaxe</strong>: <em>awk ‘/search_pattern/ { action_on_matches; another_action; }’ file</em></pre><p><strong>Exemplos</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d417af6f31822f4794b8876edd9157fb/href">https://medium.com/media/d417af6f31822f4794b8876edd9157fb/href</a></iframe><p>No primeiro exemplo fazemos um filtro no arquivo procurando pela palavra Stark no ação é imprimir a linha, retornando duas linhas com isso validamos que o pattern é case-sensitive.</p><p>No segundo exemplo nós ajustamos a action para imprimir apenas o primeiro item de cada linha.</p><p>No terceiro exemplo adicionamos a opçãp <strong>-F</strong> para especificar que o separador de itens na linha deve ser o <strong>“;”</strong></p><p>No último exemplo retiramos o pattern de filtro para que o awk processe o arquivo todo e na action montamos um String para impressão utilizando o primeiro item da linnha <strong>“$1”</strong> e o último item da linha <strong>“$NF”</strong></p><p><strong>Dicas</strong>:</p><ol><li><em>o pattern de pesquisa é opcional, permitindo que o awk seja utilizado para organização dos dados</em></li><li><em>se não for informada a opção </em><strong><em>-F</em></strong><em> para definir o separador, o </em><strong><em>awk</em></strong><em> irá utilizar por padrão o espaço</em></li></ol><h3>Encadeando comandos com pipe (|)</h3><p>Um dos recursos mais utilizados em shell é compor saidas de dados resultante da execução de vários comandos em conjunto.</p><pre><strong>Sintaxe</strong>: <em>comando-1 [| comando-2]…[| comando-n]</em></pre><p><em>De forma geral o comando-1 será executado sua saida será repassada para o comando-2 como um “arquivo” que irá executar sobre esses dados e repassando o resultado para o comando subsequente até o ultimo comando da cadeia.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/64c2ee2e6eddcc12abe94a366a282a64/href">https://medium.com/media/64c2ee2e6eddcc12abe94a366a282a64/href</a></iframe><p>No primeiro exemplo usamos o <strong>cat</strong> para listar todo o arquivo, e com o resultado aplicamos um <strong>grep</strong> <strong>-in</strong> onde ignoramos o case e imprimimos o número da linha no arquivo.</p><p>No segundo exemplo adicionamos o <strong>awk</strong> para manipular o resultado do <strong>grep</strong> para imprimir um resultado mais amigável.</p><h3>Finalizando</h3><p>Com isso concluimos a primeira parte deste estudo de shell script.</p><p>Nos próximos artigos vamos abordar programação em shell propriamente dita, criando variáveis, leitura de arquivos, controle de fluxo, etc.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2dd9dcf8e9dd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/contabilizei-tecnologia/utilizando-shell-script-parte-1-2dd9dcf8e9dd">Utilizando Shell Script — parte 1</a> was originally published in <a href="https://medium.com/contabilizei-tecnologia">Contabilizei</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>