<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Blog on José Hisse</title><link>https://www.josehisse.dev/</link><description>Recent content in Blog on José Hisse</description><generator>Hugo</generator><language>pt-br</language><lastBuildDate>Sat, 08 Aug 2026 00:00:00 -0300</lastBuildDate><atom:link href="https://www.josehisse.dev/index.xml" rel="self" type="application/rss+xml"/><item><title>[TIL] O link-checker do blog pegou a doc da MinIO CE saindo do ar</title><link>https://www.josehisse.dev/blog/documentacao-do-minio-community-edition-saiu-do-ar/</link><pubDate>Sat, 08 Aug 2026 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/documentacao-do-minio-community-edition-saiu-do-ar/</guid><description>&lt;p>Ao rodar o &lt;a href="https://github.com/lycheeverse/lychee" target="_blank" rel="noreferrer noopener">lychee&lt;/a> como verificador de links do blog, um alerta chamou atenção: uma URL da documentação da MinIO Community Edition, citada num post antigo sobre object storage self-hosted, não retorna mais o conteúdo original. Não é um &lt;code>404&lt;/code>: o link ainda responde &lt;code>200&lt;/code>. Ele redireciona para a documentação do AIStor, o produto enterprise pago, mas a página, embora carregue normalmente, não é mais a que o post pretendia citar.&lt;/p></description></item><item><title>Mitigando possíveis ameaças de segurança em sites estáticos</title><link>https://www.josehisse.dev/blog/mitigando-ameacas-de-seguranca-em-sites-estaticos/</link><pubDate>Sun, 13 Apr 2025 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/mitigando-ameacas-de-seguranca-em-sites-estaticos/</guid><description>&lt;h2 id="introdução">Introdução&lt;/h2>
&lt;p>Parece engraçado e até absurdo, mas sites estáticos também precisam de atenção à segurança. Sem uma linguagem de backend, consultas ao banco de dados ou processamento no servidor, muitos desenvolvedores subestimam as vulnerabilidades que podem ser exploradas, deixando seus sites e infraestrutura expostos a diversos tipos de ataques. Mesmo um site puramente estático (HTML, CSS, JS) servido via plataformas como Cloudflare Pages, como é o caso deste blog, necessita de camadas de proteção adequadas.&lt;/p></description></item><item><title>Entre a escassez e o excesso de postmortems</title><link>https://www.josehisse.dev/blog/entre-escassez-excesso-postmortem/</link><pubDate>Fri, 11 Apr 2025 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/entre-escassez-excesso-postmortem/</guid><description>&lt;h2 id="introdução">Introdução&lt;/h2>
&lt;blockquote>
&lt;p>Este dispositivo falhará. A questão não é se falhará, mas quando falhará. [&amp;hellip;] Sempre tenha um plano para lidar com as falhas.&lt;/p>
&lt;p>&amp;ndash; Trecho do manual do Shearwater Swift Air Transmitter&lt;/p>&lt;/blockquote>
&lt;p>O trecho que acabamos de ler foi extraído do manual de um dispositivo de medição de ar em cilindros de mergulho. Quando o li pela primeira vez achei um tanto preocupante; um dispositivo que mede a quantidade de ar que resta em um mergulho não deveria ser à prova de falhas? No entanto, é óbvio que o dispositivo falhará em algum momento, isso é inevitável. Nenhum dispositivo ou sistema é imune a falhas. O que importa é o quanto você estará preparado para lidar com essa falha e o que você aprenderá caso o incidente aconteça. O princípio que ele transmite é universal: falhas e incidentes são inevitáveis, mas o que importa é como respondemos a elas e como nos preparamos para lidar com elas antes que aconteçam.&lt;/p></description></item><item><title>Abrindo links externos em nova página com Hugo</title><link>https://www.josehisse.dev/blog/abrindo-links-externos-em-nova-pagina-com-hugo/</link><pubDate>Tue, 11 Feb 2025 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/abrindo-links-externos-em-nova-pagina-com-hugo/</guid><description>&lt;p>Neste post, vamos ver como identificar links externos em posts em Markdown e renderizar os links em HTML para que sejam abertos em uma nova página. Esse recurso melhora a experiência do usuário, mantendo seu blog aberto enquanto o leitor acessa links para outros domínios.&lt;/p>
&lt;h2 id="como-o-hugo-renderiza-links">Como o Hugo renderiza links&lt;/h2>
&lt;p>O Hugo utiliza o que ele chama de &lt;a href="https://gohugo.io/render-hooks/" target="_blank" rel="noreferrer noopener">render hooks&lt;/a> para customizar a forma como os links são renderizados. Para alterar o comportamento padrão de links, basta criar um render hook personalizado, nesse caso, &lt;code>layouts/_default/_markup/render-link.html&lt;/code>.&lt;/p></description></item><item><title>Exportando eventos do Kubernetes com o FluentBit</title><link>https://www.josehisse.dev/blog/exportando-eventos-do-kubernetes-com-o-fluentbit/</link><pubDate>Fri, 02 Aug 2024 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/exportando-eventos-do-kubernetes-com-o-fluentbit/</guid><description>&lt;p>O &lt;a href="https://fluentbit.io/" target="_blank" rel="noreferrer noopener">FluentBit&lt;/a> é utilizado para coletar, filtrar e encaminhar logs, métricas e traces. Ele é super leve e tem suporte a várias fontes de dados e destinos. Neste post vamos ver como coletar eventos do Kubernetes e enviar para um destino de nossa escolha. É esperado que você tenha algum conhecimento sobre Kubernetes e observabilidade, para que você possa tirar o máximo proveito deste post.&lt;/p>
&lt;h2 id="criação-do-ambiente-de-testes">Criação do ambiente de testes&lt;/h2>
&lt;p>Para nosso ambiente de testes, vamos precisar de um cluster Kubernetes. Vamos continuar utilizando o &lt;a href="https://kind.sigs.k8s.io/" target="_blank" rel="noreferrer noopener">Kind&lt;/a> para criar um cluster local, assim como fizemos em diversos posts anteriores. Daremos o nome ao nosso cluster de &lt;code>events-exporter-test&lt;/code>.&lt;/p></description></item><item><title>Desempoeirando uma Impressora Samsung SCX-3405W</title><link>https://www.josehisse.dev/blog/desempoeirando-uma-impressora-samsung-scx-3405w/</link><pubDate>Sat, 15 Jun 2024 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/desempoeirando-uma-impressora-samsung-scx-3405w/</guid><description>&lt;p>Esse artigo é um pouco diferente dos que eu costumo escrever aqui no site. Talvez seja mais útil para que eu mantenha um registro que como eu fiz a impressora funcionar de forma correta, mas pode ser útil para outras pessoas que tenham o mesmo modelo de impressora e estejam com problemas semelhantes ao meu.&lt;/p>
&lt;p>

&lt;picture>
 &lt;source srcset="https://www.josehisse.dev/blog/desempoeirando-uma-impressora-samsung-scx-3405w/images/samsung-scx-3405w_hu_c24844ae1453af9a.aab7945c9ac63056ed699c9681c04d10c0220348c43e57471381cd806e158915.webp" type="image/webp">
 &lt;img src="https://www.josehisse.dev/blog/desempoeirando-uma-impressora-samsung-scx-3405w/images/samsung-scx-3405w_hu_bffaa85458020d0f.79b5b9e4709f3050cc33c90f2de9c707288f3e948ebc44d0fc3514789ab23d89.jpg" alt="Samsung SCX 3405W"decoding="async"
 loading="lazy"
 width="1280">
&lt;/picture>
&lt;/p>
&lt;p>Eu tenho em casa uma ótima impressora multifuncional Samsung SCX-3405W. Apesar de ser um modelo muito antigo, a minha tem como data de fabricação setembro de 2013, ela ainda imprime com uma qualidade muito boa e com rapidez. Toners compatíveis estão custando em torno de R$ 50,00 e consigo imprimir mais de 1200 páginas com um único toner. Ele geralmente dura mais de um ano, já que eu não tenho o hábito de imprimir muita coisa, prefiro utilizar a tela para leitura, mas as vezes precisamos ter algum documento ou um artigo impresso para levar à algum lugar.&lt;/p></description></item><item><title>Gerando imagens WebP com Hugo</title><link>https://www.josehisse.dev/blog/gerando-imagens-webp-com-hugo/</link><pubDate>Fri, 31 May 2024 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/gerando-imagens-webp-com-hugo/</guid><description>&lt;p>Alguns meses atrás decidi que iria migrar do Jekyll para o Hugo. Estava procurando um SSG (gerador de site estático) mais rápido e flexível, que tivesse features mais avançadas. Ainda não escrevi nenhum artigo sobre essa migração, mas pretendo falar um pouco sobre isso em outro post.&lt;/p>
&lt;p>Hoje, utilizo o Hugo como gerador de site estático, e ele tem oferecido boas features para o blog. Uma dessas funcionalidades é o suporte ao processamento de imagens no tempo do build. Ao processar as imagens, posso aplicar transformações, como conversão e redimensionamento, permitindo que otimizações sejam feitas antes de entregar essas imagens aos leitores.&lt;/p></description></item><item><title>Evitando links quebrados com lychee</title><link>https://www.josehisse.dev/blog/evitando-links-quebrados-com-lychee/</link><pubDate>Thu, 16 May 2024 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/evitando-links-quebrados-com-lychee/</guid><description>&lt;p>Manter um blog de tecnologia atualizado é uma tarefa desafiadora. Com a constante evolução das tecnologias, é essencial garantir que o conteúdo permaneça relevante e útil. Um dos desafios recorrentes é manter a integridade das URLs externas, que podem se tornar obsoletas à medida que sites são modificados, páginas são removidas ou domínios são alterados sem redirecionamento adequado. Isso resulta em links quebrados que prejudicam a experiência do leitor e a credibilidade do blog. Para evitar que links quebrados atrapalhem a experiência do leitor e prejudique o SEO do seu site, é possível utilizar ferramentas de checagem, como o &lt;a href="https://github.com/lycheeverse/lychee" target="_blank" rel="noreferrer noopener">lychee&lt;/a>.&lt;/p></description></item><item><title>Guia ilustrado sobre Taint e Toleration no Kubernetes</title><link>https://www.josehisse.dev/blog/guia-ilustrado-sobre-taint-e-toleration-no-kubernetes/</link><pubDate>Thu, 09 May 2024 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/guia-ilustrado-sobre-taint-e-toleration-no-kubernetes/</guid><description>&lt;p>

&lt;picture>
 &lt;source srcset="https://www.josehisse.dev/blog/guia-ilustrado-sobre-taint-e-toleration-no-kubernetes/images/capa_hu_a275e42170e6003a.93c04d68e3fccc6dd07af73991d03e1809f5e11a1af145fd87b8083cf4883ef2.webp" type="image/webp">
 &lt;img src="https://www.josehisse.dev/blog/guia-ilustrado-sobre-taint-e-toleration-no-kubernetes/images/capa_hu_e115c11fec0809a0.2c9bef65b664627501a73e43d2cf0db4b53da7c9c963f72409d656d4d8e604db.jpg" alt="Capa: uma casa com uma placa de aviso pendurada, uma chave ao lado e a porta da casa aberta, representando o acesso concedido"decoding="async"
 loading="lazy"
 width="1344">
&lt;/picture>
&lt;/p>
&lt;p>Nem sempre é trivial entender os conceitos de &lt;em>Taint&lt;/em> e &lt;em>Toleration&lt;/em> do Kubernetes. Neste guia, vamos explicar de forma didática e ilustrada o que são e como funcionam.&lt;/p>
&lt;p>Com eles podemos garantir que determinados pods sejam executados em determinados nodes, isso é essencial para realizar tarefas específicas em determinados nodes, como por exemplo, garantir que um pod que consome muita CPU seja executado em um node com muita CPU disponível, ou que um treinamento de modelo de machine learning seja executado em um node com uma GPU disponível.&lt;/p></description></item><item><title>Gerando amostras de teste para o Prometheus via Remote Write</title><link>https://www.josehisse.dev/blog/gerando-amostras-de-teste-para-o-prometheus-via-remote-write/</link><pubDate>Fri, 12 Apr 2024 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/gerando-amostras-de-teste-para-o-prometheus-via-remote-write/</guid><description>&lt;p>O Prometheus é uma das ferramentas mais utilizadas para coletar e armazenar métricas. Durante minha busca por uma maneira de demonstrar o comportamento de certas funções do Prometheus com uma amostra de dados, encontrei um desafio: como gerar essas amostras com timestamps precisos? Minha intenção não era lidar com variações de alguns milissegundos em torno de um ponto de coleta de métricas, mas sim ter um controle mais rigoroso sobre esses timestamps.&lt;/p></description></item><item><title>Aplicações fundamentais para o Amazon EKS</title><link>https://www.josehisse.dev/blog/aplicacoes-fundamentais-para-o-amazon-eks/</link><pubDate>Sun, 07 Apr 2024 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/aplicacoes-fundamentais-para-o-amazon-eks/</guid><description>&lt;p>Meu primeiro contato com o Kubernetes ocorreu no início de 2018, quando utilizamos a cloud do Google e seu serviço gerenciado do Kubernetes, chamado Google Kubernetes Engine (GKE). Algum tempo depois, já em outra empresa, passamos a utilizar o Amazon Elastic Kubernetes Service (EKS) da AWS. Este artigo se concentrará no EKS, destacando as principais ferramentas e práticas que considero fundamentais para gerenciar e manter um cluster de forma eficaz, baseando-se nos acertos e desafios enfrentados durante minha experiência.&lt;/p></description></item><item><title>Ferramentas que considero essenciais para Kubernetes</title><link>https://www.josehisse.dev/blog/ferramentas-que-considero-essenciais-para-kubernetes/</link><pubDate>Sun, 24 Mar 2024 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/ferramentas-que-considero-essenciais-para-kubernetes/</guid><description>&lt;p>O Kubernetes tem se tornado uma plataforma de orquestração de contêineres cada vez mais essencial para equipes de desenvolvimento ao redor do mundo. Apesar das facilidades que a plataforma oferece para a execução de aplicações, gerenciar clusters Kubernetes pode revelar-se uma tarefa complexa. Desafios como depurar aplicações, monitorar recursos e logs exigem ferramentas adequadas e conhecimento aprofundado para serem superados com eficiência.&lt;/p>
&lt;p>Este post visa compartilhar, com base em minha experiência, ferramentas não necessariamente populares, mas essenciais para o cotidiano de quem trabalha com Kubernetes. A seleção que apresentarei é fruto da experiência que adquiri no decorrer dos anos, durante os quais busquei otimizar meu tempo e aumentar a eficiência no gerenciamento de clusters Kubernetes.&lt;/p></description></item><item><title>Como este blog foi desenvolvido</title><link>https://www.josehisse.dev/blog/como-este-blog-foi-desenvolvido/</link><pubDate>Sun, 15 May 2022 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/como-este-blog-foi-desenvolvido/</guid><description>&lt;p>A seguir apresentarei as decisões tomadas na construção deste blog e apresentar as principais tecnologias utilizadas. Buscarei ao máximo descrever o porquê de cada decisão tomada e explicar qual o pensamento por trás. Um aviso, se você estiver lendo este artigo em uma data futura a da publicação, ele pode não descrever mais a realidade do atual blog.&lt;/p>
&lt;h2 id="objetivo-do-blog">Objetivo do blog&lt;/h2>
&lt;p>O objetivo do blog é compartilhar com os leitores um pouco da minha maneira de pensar e meus principais aprendizados, aos quais envolvem assuntos diversos, quase sempre presentes no meu dia-a-dia. Assuntos simples ou complexos, sempre é um desafio explicar de forma clara cada etapa que compõem um pensamento que leva a determinada decisão.&lt;/p></description></item><item><title>Políticas como código com o Kyverno</title><link>https://www.josehisse.dev/blog/politicas-como-codigo-com-o-kyverno/</link><pubDate>Mon, 22 Nov 2021 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/politicas-como-codigo-com-o-kyverno/</guid><description>&lt;p>Gerenciar políticas e garantir que recursos do Kubernetes sigam determinadas regras pré definidas são as principais funções do &lt;a href="https://kyverno.io/" target="_blank" rel="noreferrer noopener">Kyverno&lt;/a>. Com ele podemos definir um conjunto de regras que se aplicarão a deployments, statefulsets, pods ou qualquer outro tipo de recurso. E tudo isso é definido da mesma forma que bem conhecemos quando estamos acostumados com o Kubernetes, através de arquivos yaml.&lt;/p>
&lt;h2 id="pré-requisitos">Pré requisitos&lt;/h2>
&lt;p>Como este artigo busca explorar de forma prática o funcionamento do Kyverno, precisamos que alguns softwares estejam instalados na máquina. Segue a lista dos que serão usados:&lt;/p></description></item><item><title>Como exportar métricas do Trino para o Prometheus</title><link>https://www.josehisse.dev/blog/como-exportar-metricas-do-trino-para-o-prometheus/</link><pubDate>Mon, 11 Oct 2021 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/como-exportar-metricas-do-trino-para-o-prometheus/</guid><description>&lt;p>Monitorar a saúde da stack de dados é essencial para promover um ambiente analítico mais robusto. Ao longo desse artigo mostraremos como exportar algumas métricas do Trino para o Prometheus.&lt;/p>
&lt;h2 id="pré-requisitos">Pré-requisitos&lt;/h2>
&lt;p>Você deverá ter instalado em sua máquina:&lt;/p>
&lt;ul>
&lt;li>Docker&lt;/li>
&lt;li>Docker-compose&lt;/li>
&lt;li>Trino cli&lt;/li>
&lt;/ul>
&lt;h2 id="trino">Trino&lt;/h2>
&lt;p>O Trino, antes denominado PrestoSQL, é um componente essencial em uma stack de big data. Com ele é possível realizarmos consultas SQL de modo distribuído e escalável. Ele é responsável por se conectar em diversas fontes diferentes e processar um grande volume de dados. Ele se conecta, por exemplo, em um data lake no S3, em uma base no Postgres ou até em um cluster Kafka.&lt;/p></description></item><item><title>Um ou múltiplos arquivos yaml no Kubernetes</title><link>https://www.josehisse.dev/blog/um-ou-multiplos-arquivos-yaml-no-kubernetes/</link><pubDate>Sun, 20 Jun 2021 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/um-ou-multiplos-arquivos-yaml-no-kubernetes/</guid><description>&lt;p>Neste artigo, vamos explorar diferentes formas de organizar seus arquivos yaml. Os arquivos yaml para o Kubernetes contem as definições de services, deployments, pods, namespaces, configmaps, secrets e outros objetos. Vamos perceber que determinadas formas de organização podem trazer vantagens e desvantagens. Ao final, iremos utilizar o &lt;em>Kustomize&lt;/em>, já presente no &lt;em>kubectl&lt;/em>.&lt;/p>
&lt;h2 id="ambiente-de-testes">Ambiente de testes&lt;/h2>
&lt;p>Para você poder ter um entendimento maior deste artigo, recomendo configurar em sua máquina um ambiente de testes. Assim você poderá reproduzir todos os passos a seguir.&lt;/p></description></item><item><title>Aumentando a disponibilidade no k8s com inter-pod anti-affinity</title><link>https://www.josehisse.dev/blog/aumentando-disponibilidade-com-inter-pod-anti-affinity/</link><pubDate>Sat, 03 Apr 2021 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/aumentando-disponibilidade-com-inter-pod-anti-affinity/</guid><description>&lt;p>O objetivo deste artigo é entender como funciona o recurso de anti afinidade entre pods e como os diferentes modos, soft e hard, podem influenciar na disponibilidade de uma aplicação que esteja sendo executada no Kubernetes. Veremos os diferentes modos de anti afinidade e faremos uma sequência de testes para entender seus mais variados comportamentos.&lt;/p>
&lt;h2 id="ambiente-de-teste">Ambiente de teste&lt;/h2>
&lt;p>Para realizarmos as simulações propostas ao longo deste artigo iremos precisar de um cluster Kubernetes. Para isso iremos utilizar &lt;a href="https://kind.sigs.k8s.io/" target="_blank" rel="noreferrer noopener">Kind&lt;/a>. O Kind, significa Kubernetes in Docker, ou seja, ele irá levantar alguns containers e recursos de rede, permitindo o acesso ao cluster através do &lt;a href="https://kubernetes.io/docs/tasks/tools/#kubectl" target="_blank" rel="noreferrer noopener">kubectl&lt;/a>.&lt;/p></description></item><item><title>Introdução aos princípios FAIR</title><link>https://www.josehisse.dev/blog/introducao-aos-principios-fair/</link><pubDate>Tue, 16 Mar 2021 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/introducao-aos-principios-fair/</guid><description>&lt;p>É latente a necessidade de distribuir dados científicos de maneira mais acessível e com a capacidade de serem facilmente reproduzíveis. A correta governança dos dados permitirá torná-los um ativo duradouro ao longo do tempo, mantendo seu valor e história.&lt;/p>
&lt;p>Em 2016, um artigo na revista Nature intitulado &amp;ldquo;&lt;a href="https://www.nature.com/articles/sdata201618" target="_blank" rel="noreferrer noopener">The FAIR Guiding Principles for scientific data management and stewardship&lt;/a>&amp;rdquo;, um grupo de cientistas propôs quatro princípios para a publicação de dados científicos. Eles o denominaram &lt;a href="https://www.go-fair.org/fair-principles/" target="_blank" rel="noreferrer noopener">FAIR&lt;/a>, o acrônimo formado por cada um dos princípios citados.&lt;/p></description></item><item><title>Transformando modelo preditivo em produto com R</title><link>https://www.josehisse.dev/blog/deploy-de-modelo-em-r/</link><pubDate>Thu, 13 Aug 2020 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/deploy-de-modelo-em-r/</guid><description>&lt;p>O objetivo deste artigo é transformar em produto um modelo desenvolvido com a linguagem R, no caso, criando uma API Rest preditiva. Para isso vamos utilizar uma base contendo dados de pessoas diabéticas, cuja as variáveis de entradas serão pré determinadas e teremos como output uma probabilidade daquela pessoa ter ou não diabete. Vamos utilizar também a plataforma Docker para treinarmos nosso modelo com o RStudio e transformamos em container nossa API.&lt;/p></description></item><item><title>Vulnerabilidades em containers com Trivy e GitLab CI/CD</title><link>https://www.josehisse.dev/blog/verificando-vulnerabilidades-em-containers-com-trivy-e-gitlab-ci-cd/</link><pubDate>Sat, 13 Jun 2020 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/verificando-vulnerabilidades-em-containers-com-trivy-e-gitlab-ci-cd/</guid><description>&lt;p>

&lt;picture>
 &lt;source srcset="https://www.josehisse.dev/blog/verificando-vulnerabilidades-em-containers-com-trivy-e-gitlab-ci-cd/images/capa_hu_74939721f34cb094.e381b606c00cfdd1954aa1e5984352c363394be9b16b988e5cdfb9f746a2c821.webp" type="image/webp">
 &lt;img src="https://www.josehisse.dev/blog/verificando-vulnerabilidades-em-containers-com-trivy-e-gitlab-ci-cd/images/capa_hu_cd48cd8f20b0d7e8.a1609cae8231a54885e6c9dc0f0ba3f65cdc30af02f62e6d662c6a5f28b31f96.jpg" alt="Capa: pilha de imagens de container inspecionada por uma lupa, que encontra vulnerabilidades e as resolve com um check"decoding="async"
 loading="lazy"
 width="1344">
&lt;/picture>
&lt;/p>
&lt;p>Neste artigo vamos criar uma API na linguagem golang, armazenar o código-fonte em um repositório do GitLab e construir um pipeline de continuous integration para build, teste de vulnerabilidade e push para o docker registry. Ao final teremos o fluxo de continuous integration de uma aplicação, desde o código-fonte até a disponibilização da imagem docker em um container registry.&lt;/p></description></item><item><title>Diferença entre explode e explode_outer no PySpark</title><link>https://www.josehisse.dev/blog/diferenca-entre-explode-e-explode-outer-no-pyspark/</link><pubDate>Sun, 22 Mar 2020 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/diferenca-entre-explode-e-explode-outer-no-pyspark/</guid><description>&lt;p>É comum em transformações de dados nos depararmos com estruturas de arrays de strings, inteiros ou algum outro tipo de arrays de objetos. Em alguns casos podemos querer transformar esses arrays em colunas. Usando o PySpark podemos usar as funções &lt;a href="https://archive.apache.org/dist/spark/docs/3.3.0/api/python/reference/pyspark.sql/api/pyspark.sql.functions.explode.html" target="_blank" rel="noreferrer noopener">explode&lt;/a> ou &lt;a href="https://archive.apache.org/dist/spark/docs/3.3.0/api/python/reference/pyspark.sql/api/pyspark.sql.functions.explode_outer.html" target="_blank" rel="noreferrer noopener">explode_outer&lt;/a> para isso. Vamos entender a diferença entre essas duas funções.&lt;/p>
&lt;h2 id="preparação-do-ambiente">Preparação do ambiente&lt;/h2>
&lt;p>Para acompanhar o que vem a seguir sugiro que você tenha o docker instalado em sua máquina. No terminal executaremos uma imagem docker do jupyter contendo o PySpark já instalado. Com isso teremos acesso no navegador a interface de desenvolvimento do jupyter notebook.&lt;/p></description></item><item><title>Saindo do zero com expressões regulares</title><link>https://www.josehisse.dev/blog/saindo-do-zero-com-expressoes-regulares/</link><pubDate>Sat, 14 Mar 2020 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/saindo-do-zero-com-expressoes-regulares/</guid><description>&lt;p>Você já precisou procurar em um texto sequências de caracteres que correspondiam a um padrão? Validar um número de telefone? Analisar logs de um servidor? São inúmeros os casos de uso das expressões regulares, porém seu uso pode parecer um pouco complicado à primeira vista. Ao longo deste texto, vamos entender o contexto em que elas surgiram e aprender suas principais funções.&lt;/p>
&lt;h2 id="história">História&lt;/h2>
&lt;p>Tudo começou em 1943, quando Warren McCulloch e Walter Pitts publicaram um artigo intitulado &amp;ldquo;&lt;a href="https://link.springer.com/article/10.1007/BF02478259" target="_blank" rel="noreferrer noopener">A logical calculus of the ideas immanent in nervous activity&lt;/a>&amp;rdquo; onde eles associaram a atividade neuronal com a lógica proposicional: eles modelaram através da lógica a forma que os neurônios interagiam entre si.&lt;/p></description></item><item><title>Construindo uma API de machine learning (Continuação)</title><link>https://www.josehisse.dev/blog/api-modelos-machine-learning-continuacao/</link><pubDate>Fri, 28 Feb 2020 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/api-modelos-machine-learning-continuacao/</guid><description>&lt;p>Este post é &lt;a href="https://www.josehisse.dev/blog/api-modelos-machine-learning/">complementar ao anterior&lt;/a>. No primeiro vimos como construir modelos de machine learning e salvá-los como pickle, em seguida vimos como construir uma API serverless nativa na AWS. O objetivo deste é utilizamos o mesmo modelo salvo anteriormente e criamos uma API agnóstica com container, o que isso significa é que poderemos executar nossa API em qualquer ambiente em que o Docker esteja disponível.&lt;/p>
&lt;h2 id="falcon-api">Falcon API&lt;/h2>
&lt;p>Vamos contar com a ajuda de um framework web chamado &lt;a href="https://falcon.readthedocs.io" target="_blank" rel="noreferrer noopener">Falcon&lt;/a>.&lt;/p></description></item><item><title>Construindo uma API de machine learning</title><link>https://www.josehisse.dev/blog/api-modelos-machine-learning/</link><pubDate>Sun, 16 Feb 2020 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/api-modelos-machine-learning/</guid><description>&lt;p>O objetivo deste post é mostrar com detalhes um dos métodos que pode ser utilizado para disponibilizarmos uma interface de consumo de modelos de machine learning. A ideia geral deste método é a criação de um modelo que após o treinamento com uma parcela dos dados, poderemos utilizar uma API REST como uma interface padrão de comunicação entre outras aplicações.&lt;/p>
&lt;p>

&lt;picture>
 &lt;source srcset="https://www.josehisse.dev/blog/api-modelos-machine-learning/images/diagrama_geral_hu_2a039ed0d083bf1b.1395102f47963a8b9133b1b7cc3dad6f12e707e72ceb911f0cf0754d73ecaec9.webp" type="image/webp">
 &lt;img src="https://www.josehisse.dev/blog/api-modelos-machine-learning/images/diagrama_geral_hu_2d910d482b45a94e.0a6869b308350e748a916cff0f7d5ec6e03e5c5fda4731fd3cfe9d94b2e20862.jpg" alt="Diagrama da ideia geral de criação da solução"decoding="async"
 loading="lazy"
 width="656">
&lt;/picture>
&lt;/p>
&lt;h2 id="construção-do-modelo">Construção do modelo&lt;/h2>
&lt;p>A primeira coisa que temos que ter como finalidade nesta etapa é ter o modelo treinado de tal modo que possamos utilizar à qualquer momento. Tendo isso em mente podemos enumerar alguns passos que terão que ser cumpridos:&lt;/p></description></item><item><title>Autenticando com oauth2_proxy, nginx e Github</title><link>https://www.josehisse.dev/blog/autenticando-com-oauth2-proxy-nginx-e-github/</link><pubDate>Sat, 19 Oct 2019 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/autenticando-com-oauth2-proxy-nginx-e-github/</guid><description>&lt;p>O objetivo deste artigo é implementarmos um método de autenticação de um website estático por oauth2 utilizando &lt;a href="https://www.nginx.org/" target="_blank" rel="noreferrer noopener">nginx&lt;/a> como servidor de arquivos estáticos e proxy reverso, &lt;a href="https://oauth2-proxy.github.io/oauth2-proxy/" target="_blank" rel="noreferrer noopener">oauth2_proxy&lt;/a> como backend para validação das requisições e o &lt;a href="https://github.com/" target="_blank" rel="noreferrer noopener">Github&lt;/a> como provedor de autorização.&lt;/p>
&lt;p>Todo o projeto está disponível &lt;a href="https://github.com/jhisse/nginx-oauth2_proxy-github" target="_blank" rel="noreferrer noopener">neste repositório&lt;/a>.&lt;/p>
&lt;p>Para executar esse projeto é recomendado ter o Docker e o Docker-Compose instalado em sua máquina.&lt;/p>
&lt;h2 id="nginx-para-arquivos-estáticos">Nginx para arquivos estáticos&lt;/h2>
&lt;p>Aqui iremos configurar o básico do nginx para servir uma página HTML estática, neste caso pode ser um build do Jekyll, Hugo ou um simples HTML.&lt;/p></description></item><item><title>Sequência de Collatz</title><link>https://www.josehisse.dev/blog/sequencia-de-collatz/</link><pubDate>Sat, 12 Oct 2019 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/sequencia-de-collatz/</guid><description>&lt;h2 id="problema">Problema&lt;/h2>
&lt;p>A seguinte questão foi proposta no &lt;a href="https://www.projecteuler.net/problem=14" title="Problema 14 do Project Euler" target="_blank" rel="noreferrer noopener">problema 14 do Project Euler&lt;/a>.&lt;/p>
&lt;p>A sequência de Collatz é gerada pela seguinte regra:&lt;/p>
&lt;p>\[ n = \begin{cases} &amp;amp; n/2 \text{, se } n \text{ é par } \\ &amp;amp; 3n+1 \text{, se } n \text{ é ímpar } \end{cases} \]&lt;/p>
&lt;p>Conforme a regra acima e começando pelo número 13, temos a seguinte sequência:&lt;/p>
&lt;p>\[ 13 \rightarrow 40 \rightarrow 20 \rightarrow 10 \rightarrow 5 \rightarrow 16 \rightarrow 8 \rightarrow 4 \rightarrow 2 \rightarrow 1 \]&lt;/p></description></item><item><title>Os V's do Big Data (Volume - Velocity - Variety)</title><link>https://www.josehisse.dev/blog/os-vs-do-big-data/</link><pubDate>Sun, 06 Oct 2019 00:00:00 -0300</pubDate><guid>https://www.josehisse.dev/blog/os-vs-do-big-data/</guid><description>&lt;p>No ano de 2001 Doug Laney propôs os primeiros 3 V&amp;rsquo;s em seu artigo &amp;ldquo;3D Data Management: Controlling Data Volume, Velocity, and Variety&amp;rdquo;. O autor define o primeiro V como Volume. O volume se caracteriza pela grande quantidade de dados, lembrando que o que é considerado de grande volume hoje, por exemplo, petabytes, pode ser normal daqui a uns anos, e o que foi gigantesco no passado, por exemplo, terabytes, hoje é considerado algo mais comum.&lt;/p></description></item></channel></rss>