<?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 Henrique Junkes on Medium]]></title>
        <description><![CDATA[Stories by Henrique Junkes on Medium]]></description>
        <link>https://medium.com/@henriquejunkes887?source=rss-d8d38febb3c2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*_mn8M2RnHlxGT90ki0GJaA@2x.jpeg</url>
            <title>Stories by Henrique Junkes on Medium</title>
            <link>https://medium.com/@henriquejunkes887?source=rss-d8d38febb3c2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 05:50:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@henriquejunkes887/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[Concurrency in Java]]></title>
            <link>https://medium.com/@henriquejunkes887/concurrency-in-java-f1df74264297?source=rss-d8d38febb3c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1df74264297</guid>
            <dc:creator><![CDATA[Henrique Junkes]]></dc:creator>
            <pubDate>Tue, 16 Jul 2024 00:31:20 GMT</pubDate>
            <atom:updated>2024-07-16T00:31:20.369Z</atom:updated>
            <content:encoded><![CDATA[<p>Enhancing Performance and Scalability in Modern Applications</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*7uu6UD7fzOSsW6DZCHTGmw.jpeg" /></figure><p>In the modern age of multi-core processors and high-performance computing, leveraging concurrency is crucial for building efficient and responsive applications. Java, being a robust and versatile language, offers a multitude of features and utilities to make concurrent programming more manageable and effective.</p><h3>🌟 Key Concepts in Java Concurrency 🌟</h3><p><strong>1. Threads:</strong> Java’s built-in support for multithreading allows us to run multiple threads simultaneously, enhancing the performance of our applications. We can create threads by extending the Thread class or implementing the Runnable interface.</p><h4>Example: Creating Threads</h4><pre>// Extending Thread class<br>class MyThread extends Thread {<br>    public void run() {<br>        System.out.println(&quot;Thread is running&quot;);<br>    }<br>}<br><br>public class Main {<br>    public static void main(String[] args) {<br>        MyThread t1 = new MyThread();<br>        t1.start();<br>    }<br>}<br><br>// Implementing Runnable interface<br>class MyRunnable implements Runnable {<br>    public void run() {<br>        System.out.println(&quot;Thread is running&quot;);<br>    }<br>}<br><br>public class Main {<br>    public static void main(String[] args) {<br>        Thread t1 = new Thread(new MyRunnable());<br>        t1.start();<br>    }<br>}</pre><p><strong>2. Synchronization:</strong> To ensure thread safety when multiple threads access shared resources, Java provides synchronized methods and blocks. This helps prevent race conditions and ensures data consistency.</p><h4>Example: Synchronized Method</h4><pre>class Counter {<br>    private int count = 0;<br><br>    public synchronized void increment() {<br>        count++;<br>    }<br><br>    public int getCount() {<br>        return count;<br>    }<br>}<br><br>public class Main {<br>    public static void main(String[] args) {<br>        Counter counter = new Counter();<br>        <br>        for (int i = 0; i &lt; 1000; i++) {<br>            new Thread(counter::increment).start();<br>        }<br><br>        try {<br>            Thread.sleep(1000); // Ensure all threads have finished<br>        } catch (InterruptedException e) {<br>            e.printStackTrace();<br>        }<br><br>        System.out.println(&quot;Final count: &quot; + counter.getCount());<br>    }<br>}</pre><p><strong>3. The </strong><strong>java.util.concurrent Package:</strong> Java&#39;s java.util.concurrent package offers high-level concurrency utilities, making it easier to develop scalable and thread-safe applications. This includes:</p><ul><li><strong>Executors:</strong> For managing a pool of threads.</li><li><strong>Locks:</strong> More flexible locking mechanisms, like ReentrantLock.</li><li><strong>Concurrent Collections:</strong> Thread-safe collections like ConcurrentHashMap and BlockingQueue.</li></ul><h4>Example: Using ExecutorServic</h4><pre>import java.util.concurrent.ExecutorService;<br>import java.util.concurrent.Executors;<br><br>public class Main {<br>    public static void main(String[] args) {<br>        ExecutorService executor = Executors.newFixedThreadPool(10);<br>        for (int i = 0; i &lt; 100; i++) {<br>            executor.submit(() -&gt; {<br>                System.out.println(&quot;Thread is running&quot;);<br>            });<br>        }<br>        executor.shutdown();<br>    }<br>}</pre><p><strong>4. Atomic Variables:</strong> For lock-free thread-safe programming on single variables, Java provides atomic classes like AtomicInteger, ensuring high performance in multi-threaded environments.</p><h4>Example: AtomicInteger</h4><pre>import java.util.concurrent.atomic.AtomicInteger;<br><br>public class Main {<br>    private static AtomicInteger counter = new AtomicInteger(0);<br>    public static void main(String[] args) {<br>        for (int i = 0; i &lt; 1000; i++) {<br>            new Thread(() -&gt; counter.incrementAndGet()).start();<br>        }<br>        try {<br>            Thread.sleep(1000);<br>        } catch (InterruptedException e) {<br>            e.printStackTrace();<br>        }<br>        System.out.println(&quot;Final counter value: &quot; + counter.get());<br>    }<br>}</pre><p><strong>5. BlockingQueue:</strong> A thread-safe queue that supports operations that wait for the queue to become non-empty when retrieving an element and wait for space to become available in the queue when storing an element.</p><h4>Example: Using BlockingQueue</h4><pre>import java.util.concurrent.BlockingQueue;<br>import java.util.concurrent.LinkedBlockingQueue;<br><br>public class Main {<br>    public static void main(String[] args) {<br>        BlockingQueue&lt;String&gt; queue = new LinkedBlockingQueue&lt;&gt;();<br>        new Thread(() -&gt; {<br>            try {<br>                queue.put(&quot;data&quot;);<br>                System.out.println(&quot;Data added to queue&quot;);<br>            } catch (InterruptedException e) {<br>                Thread.currentThread().interrupt();<br>            }<br>        }).start();<br>        new Thread(() -&gt; {<br>            try {<br>                String data = queue.take();<br>                System.out.println(&quot;Data retrieved from queue: &quot; + data);<br>            } catch (InterruptedException e) {<br>                Thread.currentThread().interrupt();<br>            }<br>        }).start();<br>    }<br>}</pre><h3>🌐 Why Concurrency Matters 🌐</h3><ul><li><strong>Improved Performance:</strong> Efficiently utilizing multiple cores.</li><li><strong>Responsiveness:</strong> Keeping applications responsive, especially in I/O operations.</li><li><strong>Scalability:</strong> Building scalable applications that handle numerous tasks simultaneously.</li></ul><p>Java’s rich set of concurrency tools and techniques empowers developers to build robust, efficient, and scalable applications.🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1df74264297" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SQLC — Escrevendo consultas SQL em GO]]></title>
            <link>https://medium.com/@henriquejunkes887/sqlc-escrevendo-consultas-sql-em-go-d94c0491b03d?source=rss-d8d38febb3c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/d94c0491b03d</guid>
            <category><![CDATA[sqlc]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[Henrique Junkes]]></dc:creator>
            <pubDate>Thu, 21 Sep 2023 02:07:38 GMT</pubDate>
            <atom:updated>2023-09-21T23:00:56.969Z</atom:updated>
            <content:encoded><![CDATA[<h3>SQLC — Escrevendo consultas SQL em GO</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DpFUTHyj_A_Zc8Ez.png" /></figure><p>O SQLC é uma ferramenta de código aberto utilizada para geração de código GO a partir de consultas SQL. O nome “SQLC” deriva de “SQL Compiler”. Essa ferramenta permite que os desenvolvedores escrevam consultas SQL em arquivos separados e, em seguida, gere código GO tipado com base nessas consultas.</p><h3>Como usar</h3><p>Crie um arquivo chamado sqlc.yaml com o seguinte conteúdo:</p><pre>version: &quot;2&quot;<br>sql:<br>  - engine: &quot;mysql&quot;<br>    schema: &quot;sql/schema/&quot;<br>    queries: &quot;sql/queries/&quot;<br>    gen:<br>      go:<br>        package: &quot;database&quot;<br>        out: &quot;internal/database&quot;</pre><ul><li>engine: Banco de dados usado como postgresql, mysql ou sqlite .</li><li>schema: Diretório de migrações SQL ou caminho para arquivo SQL único ou uma lista de caminhos.</li><li>queries: Diretório de consultas SQL ou caminho para arquivo SQL único ou uma lista de caminhos.</li><li>package: O nome do pacote a ser usado para o código gerado. O padrão é o nome da base.</li><li>out: Diretório de saída para código gerado.</li></ul><p>Depois crie uma pasta chamada internal onde o código será gerado, e um sql com as pastas schema e queries dentro dela e adicione os arquivos sql nelas.</p><h4>schema:</h4><pre>CREATE TABLE IF NOT EXISTS `users` (id int PRIMARY KEY AUTO_INCREMENT, name varchar(255) NOT NULL);<br><br>CREATE TABLE IF NOT EXISTS `itens` (id int PRIMARY KEY AUTO_INCREMENT, name varchar(255) NOT NULL, user_id INTEGER NOT NULL, FOREIGN KEY (user_id) REFERENCES users(id));Links</pre><h4>queries:</h4><pre>-- name: CreateUser :exec<br>INSERT INTO users (id, name) VALUES(?,?);<br><br>-- name: GetUser :one<br>SELECT * FROM users WHERE id = ?;<br><br>-- name: GetUsers :many<br>SELECT * FROM users;<br><br>-- name: CreateIten :exec<br>INSERT INTO itens (id, name, user_id) VALUES(?,?,?);<br><br>-- name: GetIten :one<br>SELECT * FROM itens WHERE id = ?;<br><br>-- name: GetItens :many<br>SELECT * FROM itens;</pre><p>Em seguida rode o comando a sqlc generate .</p><h3>Implementação</h3><p>Como podemos ver no código abaixo vamos apenas precisar importar o código gerado, toda a implementação já foi feita pelo próprio SQLC.</p><pre>con, err := sql.Open(&quot;mysql&quot;, &quot;root:root@tcp(localhost:3306)/test&quot;)<br>if err != nil {<br>    panic(err.Error())<br>}<br>defer con.Close()<br>db := database.New(con)<br>ctx := context.Background()<br><br>db.CreateUser(ctx, database.CreateUserParams{ID: 1, Name: &quot;John&quot;})<br>db.CreateIten(ctx, database.CreateItenParams{Name: &quot;pen&quot;, UserID: 1})<br><br>itens, _ := db.GetItens(ctx)<br>for _, iten := range itens {<br>    user, _ := db.GetUser(ctx, iten.UserID)<br>    fmt.Printf(&quot;Item id: %d, Item name: %s, User id: %d, User name: %s \n&quot;, iten.ID, iten.Name, user.ID, user.Name)<br>}</pre><h3>Links</h3><ul><li><a href="https://docs.sqlc.dev/en/stable/overview/install.html">Link de como instalar</a></li><li><a href="https://docs.sqlc.dev/en/stable/reference/config.html">Arquivo de configuração</a></li><li><a href="https://github.com/Junkes887/sqlc">Repositório</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d94c0491b03d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploy de Funções Lambda GO com GitHub Actions]]></title>
            <link>https://medium.com/@henriquejunkes887/deploy-de-fun%C3%A7%C3%B5es-lambda-go-com-github-actions-4c4f5332be75?source=rss-d8d38febb3c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c4f5332be75</guid>
            <category><![CDATA[go]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[lambda]]></category>
            <dc:creator><![CDATA[Henrique Junkes]]></dc:creator>
            <pubDate>Tue, 12 Sep 2023 23:23:51 GMT</pubDate>
            <atom:updated>2023-09-12T23:32:53.269Z</atom:updated>
            <content:encoded><![CDATA[<h3>Deploy de Lambda GO com GitHub Actions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*qSPbOfm4m4gf3dXI.png" /></figure><p>Em um mundo cada vez mais voltado para a automação e integração contínua, a implantação de funções Lambda na AWS se tornou uma tarefa essencial para muitos desenvolvedores. A AWS oferece várias maneiras de fazer isso, mas uma das abordagens mais eficazes e simplificadas é o uso das GitHub Actions. Neste artigo, vou explicar como você pode automatizar o processo de implantação de funções Lambda na AWS usando o GitHub Actions, economizando tempo e esforço.</p><h4>Pré-requisitos</h4><ul><li>Uma conta na AWS.</li><li>Um repositório no GitHub com o código da sua função Lambda.</li><li>Conhecimento básico sobre GitHub Actions.</li></ul><h3>Configurando Sua Conta AWS</h3><h4>Etapa 1: crie um provedor OIDC em sua conta</h4><ol><li>Acesse a AWS Console e vá para a seção “IAM”.</li><li>Em seguida vá em “Provedores de identidade”, e adicione um novo provedor do tipo OpenID Connect.</li><li>Em Provider URL , insira a URL do IdP GitHub OIDC para esta solução: <a href="https://token.actions.githubusercontent.com/">https://token.actions.githubusercontent.com</a></li><li>Para Público, insira “sts.amazonaws.com”.</li><li>Verifique as informações que você inseriu. Seu console deve corresponder à captura de tela da Figura 1. Após a verificação, escolha Adicionar provedor.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*Fz3dA-qba_1bRvuzbfWd_w.png" /><figcaption>Figura 1</figcaption></figure><h4>Etapa 2: criar uma função do IAM e definir o escopo da política de confiança</h4><ol><li>No console do IAM, na tela Provedores de identidade , escolha o botão Atribuir função para o IdP recém-criado.</li><li>Na caixa Atribuir função para, escolha Criar uma nova função e, em seguida escolha Próximo.</li><li>A página Criar função apresenta algumas opções. A identidade da Web já está selecionada como entidade confiável e o campo Provedor de identidade está preenchido com seu IdP. Na lista Público, selecione “sts.amazonaws.com” e escolha Próximo.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IDX3zHCVD5Likb3j9OSeSw.png" /></figure><ol><li>Na página Permissões, escolha Próximo. Para esta demonstração, você não adicionará permissões à função.</li><li>(Opcional) Na página Tags, adicione tags a essa nova função e escolha Próximo: revisar.</li><li>Na página Criar função, adicione um nome de função. Para esta demonstração, insira GitHubAction-AssumeRoleWithAction. Opcionalmente, adicione uma descrição.</li><li>Para criar a função, escolha Criar função.</li></ol><h4>Etapa 3: definir o escopo da política de confiança (console do IAM)</h4><ol><li>No console do IAM, abra a função recém-criada e escolha Editar relação de confiança.</li><li>Em permissões atribua a permissão de UpdateFunctionCode.</li><li>Na página Editar política de confiança, modifique a política de confiança para permitir que sua organização, repositório e branch exclusivos do GitHub assumam a função. Este exemplo confia na organização GitHub &lt;aws-samples&gt;. Atualize o ARN federado com o ARN do IdP do GitHub que você copiou anteriormente.</li></ol><pre>{<br>    &quot;Version&quot;: &quot;2012-10-17&quot;,<br>    &quot;Statement&quot;: [<br>        {<br>            &quot;Effect&quot;: &quot;Allow&quot;,<br>            &quot;Principal&quot;: {<br>                &quot;Federated&quot;: &quot;&lt;arn:aws:iam::111122223333:oidc-provider/token.actions.githubusercontent.com&gt;&quot;<br>            },<br>            &quot;Action&quot;: &quot;sts:AssumeRoleWithWebIdentity&quot;,<br>            &quot;Condition&quot;: {<br>                &quot;StringEquals&quot;: {<br>                    &quot;token.actions.githubusercontent.com:aud&quot;: &quot;sts.amazonaws.com&quot;<br>                },&quot;StringLike&quot;: {<br>                    &quot;token.actions.githubusercontent.com:sub&quot;: &quot;repo:&lt;aws-samples&gt;/*&quot;<br>                }<br>            }<br>        }<br>    ]<br>}</pre><h3>Criando Uma Action No GitHub</h3><p>Crie um arquivo de fluxo de trabalho básico, como main.yml, no diretório .github/workflows do seu repositório.</p><pre>name: Deploy<br><br>on:<br>  push:<br>    branches:<br>    - main<br>    <br>permissions:<br>  id-token: write<br>  contents: read<br><br>jobs:<br>  Deploy:<br>    name: Deploy<br>    runs-on: ubuntu-latest<br>    environment: secrets<br>    steps:<br>      - name: Checkout<br>        uses: actions/checkout@v3<br>      - name: Test<br>        env:<br>          TEST_AWS_ROLE: ${{ secrets.AWS_ROLE }}<br>        run: |<br>          echo ${#TEST_AWS_ROLE}<br>      - name: Set up Go<br>        uses: actions/setup-go@v3<br>        with:<br>          go-version: 1.19<br>      - name: Install<br>        run: go mod tidy<br>      - name: Build<br>        run: go build -v main.go<br>      - name: Zip<br>        run: zip -j deploy.zip main<br>      - name: Configure AWS Credentials<br>        uses: aws-actions/configure-aws-credentials@v1.7.0<br>        env:<br>          AWS_ROLE: ${{ secrets.AWS_ROLE }}<br>        with:<br>          role-to-assume: ${{env.AWS_ROLE}}<br>          role-session-name: GitHub_to_AWS_via_FederatedOIDC<br>          aws-region: us-east-2<br>      - name: Upload Zip<br>        run: aws lambda update-function-code --function-name lambda-deploy --zip-file fileb://deploy.zip</pre><p>Vá settings do seu repositório e depois em environments, e crie uma nova environment, nesse exemplo vamos criar uma com o nome secrets, depois é só ir em Environment secrets e adicionar uma nova secret com o nome AWS_ROLE contendo o arn da sua role do provedor OIDC.</p><h3>Criando Lambda GO</h3><ol><li>No console AWS vá em lambda e no botão criar função.</li><li>De um nome ao seu lambda nesse nosso exemplo vamos chamar de lambda-deploy.</li><li>Selecione o tipo GO 1.x</li><li>E vá no botão criar função.</li></ol><p>Após ter realizado todos esses passos é só rodar a action e esperar a sua lambda ser atualizada na AWS.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c4f5332be75" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mutexes em GO]]></title>
            <link>https://medium.com/@henriquejunkes887/mutexes-em-go-40c41113bf6e?source=rss-d8d38febb3c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/40c41113bf6e</guid>
            <category><![CDATA[mutex]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[Henrique Junkes]]></dc:creator>
            <pubDate>Mon, 04 Sep 2023 22:19:01 GMT</pubDate>
            <atom:updated>2023-09-04T22:19:01.444Z</atom:updated>
            <content:encoded><![CDATA[<h3>Mutex em GO</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*vYDmj89NHnum06P_NntoLg.jpeg" /></figure><p>Ao trabalhar com concorrência em Go, uma das principais preocupações é garantir que recursos compartilhados sejam acessados de forma segura por múltiplas goroutines. Duas ferramentas essenciais para alcançar esse objetivo são os Mutexes e os RWMutexes. Neste artigo, vamos explorar as diferenças entre essas duas estruturas e discutir quando cada uma é a escolha certa para o seu problema.</p><h4>Mutex</h4><p>Um Mutex (mutual exclusion) é uma ferramenta que impede o acesso de várias goroutines simultaneamente a um recurso compartilhado. Ele funciona como uma trava, permitindo que apenas uma goroutine por vez execute uma seção crítica do código.</p><pre>import (<br>   &quot;sync&quot;<br>)<br><br>type Recurso struct {<br>   valor int<br>   mux   sync.Mutex<br>}<br><br>func funcao(recurso *Recurso) {<br>   // Para travar recurso compartilhado<br>   recurso.mux.Lock()<br>  <br>   recurso.valor = 1<br>  <br>   // Para destravar recurso compartilhado<br>   recurso.mux.Unlock()<br>}</pre><h4>RWMutex</h4><p>Temos também o RWMutex, que significa “Read-Write Mutex” ou Mutex de Leitura e Escrita. O RWMutex é uma extensão do Mutex que oferece acesso a recursos compartilhados permitindo com leituras concorrentes, mas ainda garante somente um poderá realizar a escrita.</p><pre>import (<br>   &quot;fmt&quot;<br>   &quot;sync&quot;<br>)<br><br>type Recurso struct {<br>   valor int<br>   mux   sync.RWMutex<br>}<br><br>func escrita(recurso *Recurso) {<br>   // Para travar recurso compartilhado<br>   recurso.mux.Lock()<br>  <br>   recurso.valor = 1<br>  <br>   // Para destravar recurso compartilhado<br>   recurso.mux.Unlock()<br>}<br><br>func leitura(recurso *Recurso) {<br>   // Para travar leitura do recurso compartilhado<br>   //Múltiplas goroutines podem chamar este método simultaneamente.<br>   recurso.mux.RLock()<br><br>   fmt.Println(recurso.valor)<br><br>   // Para destravar leitura do recurso compartilhado<br>   recurso.mux.RUnlock()<br>}</pre><h4>Qual eu deve usar?</h4><p>Ao escolher entre eles deve-se levar em consideração o padrão de acesso ao seu recurso compartilhado. Caso o recurso compartilhado seja escrito com frequência, o uso do <strong>Mutex</strong> deve ser a escolha ideal. Caso ao contrário a escrita seja feita de forma pouco solicitada, a utilização do <strong>RWMutex</strong> será a melhor escolha de desempenho.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=40c41113bf6e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando um Load Balancer em Golang]]></title>
            <link>https://medium.com/@henriquejunkes887/implementando-um-load-balancer-em-golang-409696e5e2fc?source=rss-d8d38febb3c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/409696e5e2fc</guid>
            <category><![CDATA[load-balancer]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[Henrique Junkes]]></dc:creator>
            <pubDate>Sat, 02 Sep 2023 01:43:43 GMT</pubDate>
            <atom:updated>2023-09-02T01:46:05.442Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NX9Dh90v9xCyIoMo3H2rSA.jpeg" /></figure><h4>O que é um Load Balancer?</h4><p>Um <strong>load balancer</strong> é um componente de rede que distribui o tráfego de forma equilibrada entre vários servidores ou recursos de computação. Ele melhora o desempenho, a disponibilidade e a confiabilidade de serviços online, evitando sobrecargas e permitindo a recuperação automática em caso de falhas. É essencial para lidar com grandes volumes de tráfego e garantir a alta disponibilidade de aplicativos e serviços.</p><p>Nesse projeto iremos construir um <strong>load balancer </strong>usando Go!</p><h4>Implementação</h4><p>Para isso iremos criar algumas estruturas:</p><ul><li><strong>Backend</strong><em> </em>que irá armazenar a url e a configuração de proxy do serviço.</li><li><strong>ServerPool</strong><em> </em>que vai armazenar todos os serviços, e agrupá-los por serviços que estão em funcionamento e os que não estão.</li><li><strong>LoadBalancer</strong><em> </em>que somente contém o <em>ServerPool.</em></li></ul><pre>type Backend struct {<br>   URL          *url.URL<br>   ReverseProxy *httputil.ReverseProxy<br>}<br><br>type ServerPool struct {<br>   Backends          []*backend.Backend<br>   BackendsAlive     []*backend.Backend<br>   BackendsDontAlive []*backend.Backend<br>   Current           int<br>   Mux               sync.RWMutex<br>}<br><br>type LoadBalancer struct {<br>   SP *serverpool.ServerPool<br>}</pre><h4>ServerPool</h4><p>No pacote de ServerPool iremos criar algumas funções para manipular os slices de backends.</p><ul><li><strong>AddBack, AddBackAlive e AddBackDontAlive</strong>, que <em>iriam</em> salvar os serviços conforme seu status de rodando ou não.</li><li><strong>GetNextPeer</strong> que irá retornar retornar o serviço que <em>receberá</em> a requisição.</li></ul><pre>func (s *ServerPool) AddBackend(backend *backend.Backend) {<br>   s.Mux.Lock()<br>   s.Backends = append(s.Backends, backend)<br>   s.BackendsAlive = append(s.BackendsAlive, backend)<br>   s.Mux.Unlock()<br>}<br><br>func (s *ServerPool) AddBackendAlive(backend *backend.Backend) {<br>   s.Mux.Lock()<br>   s.BackendsAlive = append(s.BackendsAlive, backend)<br>   index := filterBack(s.BackendsDontAlive, backend)<br>   s.BackendsDontAlive = append(s.BackendsDontAlive[:index], s.BackendsDontAlive[index+1:]...)<br>   s.Mux.Unlock()<br>}<br><br>func (s *ServerPool) AddBackendDontAlive(backend *backend.Backend) {<br>   s.Mux.Lock()<br>   s.BackendsDontAlive = append(s.BackendsDontAlive, backend)<br>   index := filterBack(s.BackendsAlive, backend)<br>   s.BackendsAlive = append(s.BackendsAlive[:index], s.BackendsAlive[index+1:]...)<br>   s.Mux.Unlock()<br>}<br><br>func filterBack(list []*backend.Backend, backend *backend.Backend) (index int) {<br>   for i, back := range list {<br>      if back.URL.String() == backend.URL.String() {<br>         index = i<br>         return<br>      }<br>   }<br>   index = 0<br>   return<br>}<br><br>func (s *ServerPool) GetNextPeer() *backend.Backend {<br>   next := s.nextIndex()<br>   l := len(s.BackendsAlive) + next<br>   for i := next; i &lt; l; i++ {<br>      idx := i % len(s.BackendsAlive)<br>      if i == next {<br>         s.Current = idx<br>      }<br>         return s.BackendsAlive[idx]<br>   }<br>   return nil<br>}<br><br>func (s *ServerPool) nextIndex() int {<br>   return (s.Current + 1) % len(s.BackendsAlive)<br>}</pre><h4><em>Health Check</em></h4><p>Teremos um pacote para poder verificar se os servidores estão realmente de pé. Para esse pacote iremos chamar de HealthCheck, onde vai realizar uma requisição para esses serviços a cada 5 minutos para ver se os serviços estão de pé ou se ainda não estão.</p><pre>func LauchHealthCheck(serverPool *serverpool.ServerPool) {<br>   t := time.NewTicker(time.Minute * 5)<br>   for {<br>      select {<br>      case &lt;-t.C:<br>         log.Println(&quot;Starting health check...&quot;)<br>         healthCheck(serverPool)<br>         log.Println(&quot;Health check completed&quot;)<br>      }<br>   }<br>}<br><br>func healthCheck(serverPool *serverpool.ServerPool) {<br>   for _, back := range serverPool.BackendsAlive {<br>      status := &quot;up&quot;<br>      alive := isBackendAlive(back.URL)<br>      if !alive {<br>         status = &quot;down&quot;<br>         serverPool.AddBackendDontAlive(back)<br>      }<br>      log.Printf(&quot;%s [%s]\n&quot;, back.URL, status)<br>   }<br>   for _, back := range serverPool.BackendsDontAlive {<br>      status := &quot;down&quot;<br>      alive := isBackendAlive(back.URL)<br>      if alive {<br>         status = &quot;up&quot;<br>         serverPool.AddBackendAlive(back)<br>      }<br>      log.Printf(&quot;%s [%s]\n&quot;, back.URL, status)<br>   }<br>}<br><br>func isBackendAlive(u *url.URL) bool {<br>   timeout := 2 * time.Second<br>   conn, err := net.DialTimeout(&quot;tcp&quot;, u.Host, timeout)<br>   if err != nil {<br>      log.Println(&quot;Site unreachable, error: &quot;, err)<br>      return false<br>   }<br>   defer conn.Close()<br>   return true<br>}</pre><h4><em>LoadBalancer</em></h4><p>No pacote de LoadBalancer<em> </em>vamos implementar algumas funções para gerenciar as requisições entre os servidores.</p><ul><li><strong>AddBackends</strong> que irá adicionar os serviços no nosso ServerPool.</li><li><strong>Proxy</strong> que vai buscar um serviço disponível e fazer o proxy.</li></ul><pre>func (lb LoadBalancer) Proxy(w http.ResponseWriter, r *http.Request) {<br>   peer := lb.SP.GetNextPeer()<br>   if peer != nil {<br>      peer.ReverseProxy.ServeHTTP(w, r)<br>      return<br>   }<br>   http.Error(w, &quot;Service not available&quot;, http.StatusServiceUnavailable)<br>}<br><br>func (lb LoadBalancer) AddBackends(urls []string) {<br>   for _, u := range urls {<br>      serverUrl, err := url.Parse(u)<br>      if err != nil {<br>         log.Fatal(err)<br>      }<br>    <br>      proxy := httputil.NewSingleHostReverseProxy(serverUrl)<br>      proxy.ErrorHandler = func(writer http.ResponseWriter, request *http.Request, e error) {<br>         log.Printf(&quot;[%s] %s\n&quot;, serverUrl.Host, e.Error())<br>      <br>         lb.dontAlive(serverUrl)<br>      }<br>    <br>      lb.SP.AddBackend(&amp;backend.Backend{<br>         URL:          serverUrl,<br>         ReverseProxy: proxy,<br>      })<br>      log.Printf(&quot;Configured server: %s\n&quot;, serverUrl)<br>   }<br>}<br><br>func (lb LoadBalancer) dontAlive(backendUrl *url.URL) {<br>   for _, b := range lb.SP.BackendsAlive {<br>      if b.URL.String() == backendUrl.String() {<br>         lb.SP.AddBackendDontAlive(b)<br>         break<br>      }<br>   }<br>}</pre><p>agora na <strong>main</strong> vamos chamar essas funções.</p><pre>func main() {<br>   godotenv.Load()<br>   serverPool := &amp;serverpool.ServerPool{}<br>  <br>   port, _ := strconv.Atoi(os.Getenv(&quot;PORT&quot;))<br>   serverList := os.Getenv(&quot;SERVER_LIST&quot;)<br>  <br>   urls := strings.Split(serverList, &quot;,&quot;)<br>  <br>   lb := loadbalancer.LoadBalancer{SP: serverPool}<br>  <br>   lb.AddBackends(urls)<br>  <br>   server := http.Server{<br>      Addr:    fmt.Sprintf(&quot;:%d&quot;, port),<br>      Handler: http.HandlerFunc(lb.Proxy),<br>   }<br>  <br>   go healthcheck.LauchHealthCheck(serverPool)<br>  <br>   log.Printf(&quot;Load Balancer started at :%d\n&quot;, port)<br>   if err := server.ListenAndServe(); err != nil {<br>      log.Fatal(err)<br>   }<br>}</pre><h4><strong>Conclusão</strong></h4><p>Vimos como implementar um load balancer básico em GO. Os load balancer modernos possuem muitos mais recursos incluídos, mas neste projeto foi apenas o básico para poder criar um balanceador de carga. Para caso queira ver o código final do projeto é só acessar o <a href="https://github.com/Junkes887/load-balancer">repositório do projeto</a>. Espero que tenha gostado desse post! Obrigado por chegar até o fim!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=409696e5e2fc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Acelerando o Desempenho em Go: Substituindo encoding/json por jsoniter]]></title>
            <link>https://medium.com/@henriquejunkes887/acelerando-o-desempenho-em-go-substituindo-encoding-json-por-jsoniter-5e3071e24348?source=rss-d8d38febb3c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e3071e24348</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[perfomance]]></category>
            <category><![CDATA[json]]></category>
            <dc:creator><![CDATA[Henrique Junkes]]></dc:creator>
            <pubDate>Wed, 30 Aug 2023 16:18:33 GMT</pubDate>
            <atom:updated>2023-08-30T16:19:59.483Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/477/1*q-SODSiHH2OzTxw4FJuaAA.png" /></figure><h4>Introdução</h4><p>Quando se trata de trabalhar com dados JSON em Go, a biblioteca padrão encoding/json sempre foi uma escolha sólida. No entanto, se você estiver procurando por um desempenho ainda melhor e uma alternativa mais eficiente, jsoniter é uma opção que merece sua atenção. Neste artigo, exploraremos como jsoniter pode acelerar o desempenho do seu código Go ao lidar com JSON.</p><h4>O Poder do jsoniter</h4><p>jsoniter é uma biblioteca JSON de alta performance para Go que oferece uma alternativa mais rápida e eficiente ao pacote padrão encoding/json. Ela foi projetada para ser compatível com a API encoding/json, o que significa que você pode substituir facilmente o uso do encoding/json pelo jsoniter em seu código existente.</p><p>A principal razão por trás do desempenho superior do jsoniter é a sua abordagem de serialização e desserialização altamente otimizada. Ela utiliza técnicas avançadas, como reflexão otimizada e alocação mínima de memória, para tornar as operações de JSON significativamente mais rápidas. Se você lida com grandes volumes de dados JSON ou tem preocupações com a latência em seu aplicativo, o jsoniter pode ser a solução que você estava procurando.</p><h4>Aqui estão alguns benchmarks</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/560/1*VzF-CQVIuhbFG1PrL8zXIg.png" /></figure><h4>Como Começar</h4><p>Para começar a usar o jsoniter, você precisará adicioná-lo ao seu projeto Go. Isso pode ser feito facilmente usando o gerenciador de pacotes Go. Execute o seguinte comando no terminal:</p><pre>go get github.com/json-iterator/go</pre><p>Após a instalação bem-sucedida, você pode importar a biblioteca em seu código da seguinte maneira:</p><pre>import (<br>    jsoniter &quot;github.com/json-iterator/go&quot;<br>)</pre><h4>Usando o jsoniter em Comparação com encoding/json</h4><p>Aqui está um exemplo simples de como usar o jsoniter em comparação com o encoding/json:</p><pre>package main<br><br>import (<br>    &quot;encoding/json&quot;<br>    &quot;fmt&quot;<br>    jsoniter &quot;github.com/json-iterator/go&quot;<br>)<br><br>type Person struct {<br>    Name   string<br>    Age    int<br>    Gender string<br>}<br><br>func main() {<br>    // Usando jsoniter<br>    jsoniter := jsoniter.ConfigCompatibleWithStandardLibrary<br>    personJSON, _ := jsoniter.Marshal(Person{Name: &quot;Alice&quot;, Age: 30, Gender: &quot;Female&quot;})<br>    fmt.Println(string(personJSON))<br><br>    // Usando encoding/json<br>    personJSON, _ = json.Marshal(Person{Name: &quot;Bob&quot;, Age: 28, Gender: &quot;Male&quot;})<br>    fmt.Println(string(personJSON))<br>}</pre><h4>Conclusão</h4><p>Ao substituir encoding/json por jsoniter em seu código Go, você pode experimentar melhorias significativas no desempenho ao lidar com operações JSON. A otimização que o jsoniter oferece pode ser particularmente valiosa quando se trata de lidar com grandes volumes de dados ou quando a latência é uma preocupação. Experimente o jsoniter em seu projeto e aproveite os benefícios de uma biblioteca JSON de alta performance.</p><h4>Recursos Adicionais:</h4><ul><li><a href="https://jsoniter.com/">Documentação do jsoniter</a></li><li><a href="https://github.com/json-iterator/go">Repositório do jsoniter no GitHub</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e3071e24348" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JSON Web Tokens (JWT) em Go]]></title>
            <link>https://medium.com/@henriquejunkes887/json-web-tokens-jwt-em-go-367e6a73780a?source=rss-d8d38febb3c2------2</link>
            <guid isPermaLink="false">https://medium.com/p/367e6a73780a</guid>
            <category><![CDATA[go]]></category>
            <category><![CDATA[jwt]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[golang-tutorial]]></category>
            <dc:creator><![CDATA[Henrique Junkes]]></dc:creator>
            <pubDate>Wed, 30 Aug 2023 00:07:12 GMT</pubDate>
            <atom:updated>2023-08-30T15:53:07.271Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*P_1_i6dNSbrqQDkg.jpg" /></figure><h4><strong>Passo 1: Configuração do Projeto</strong></h4><ol><li>Crie uma nova pasta para o seu projeto.</li><li>Inicie um novo módulo Go usando o comando: go mod init nome-do-seu-projeto.</li><li>Instale a biblioteca JWT: go get github.com/dgrijalva/jwt-go.</li></ol><h4><strong>Passo 2: Estrutura Básica</strong></h4><p>Crie um arquivo chamado main.go para começar a construir sua aplicação.</p><pre>package main<br><br>import (<br>    &quot;fmt&quot;<br>    &quot;github.com/dgrijalva/jwt-go&quot;<br>    &quot;net/http&quot;<br>    &quot;time&quot;<br>)<br><br>var secretKey = []byte(&quot;seu-secret-key-aqui&quot;)<br><br>func main() {<br>    http.HandleFunc(&quot;/login&quot;, loginHandler)<br>    http.HandleFunc(&quot;/protected&quot;, protectedHandler)<br><br>    fmt.Println(&quot;Servidor rodando na porta 8080...&quot;)<br>    http.ListenAndServe(&quot;:8080&quot;, nil)<br>}</pre><h4><strong>Passo 3: Implementação do Login</strong></h4><pre>func loginHandler(w http.ResponseWriter, r *http.Request) {<br>    // Verifique as credenciais (normalmente contra um banco de dados)<br>    username := &quot;usuario&quot;<br>    password := &quot;senha&quot;<br><br>    // Simples exemplo de autenticação<br>    if r.FormValue(&quot;username&quot;) == username &amp;&amp; r.FormValue(&quot;password&quot;) == password {<br>        // Crie um token JWT<br>        token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{<br>            &quot;username&quot;: username,<br>            &quot;exp&quot;:      time.Now().Add(time.Hour * 24).Unix(),<br>        })<br><br>        tokenString, err := token.SignedString(secretKey)<br>        if err != nil {<br>            http.Error(w, &quot;Erro ao gerar token&quot;, http.StatusInternalServerError)<br>            return<br>        }<br><br>        w.Write([]byte(tokenString))<br>    } else {<br>        http.Error(w, &quot;Credenciais inválidas&quot;, http.StatusUnauthorized)<br>    }<br>}</pre><h4><strong>Passo 4: Protegendo Rotas com JWT</strong></h4><pre>func protectedHandler(w http.ResponseWriter, r *http.Request) {<br>    tokenString := r.Header.Get(&quot;Authorization&quot;)<br>    if tokenString == &quot;&quot; {<br>        http.Error(w, &quot;Token ausente&quot;, http.StatusUnauthorized)<br>        return<br>    }<br><br>    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {<br>        return secretKey, nil<br>    })<br><br>    if err != nil {<br>        http.Error(w, &quot;Token inválido&quot;, http.StatusUnauthorized)<br>        return<br>    }<br><br>    if token.Valid {<br>        w.Write([]byte(&quot;Acesso permitido a rota protegida!&quot;))<br>    } else {<br>        http.Error(w, &quot;Token inválido&quot;, http.StatusUnauthorized)<br>    }<br>}</pre><h4><strong>Passo 5: Testando a Aplicação</strong></h4><ul><li>Inicie o servidor executando go run main.go.</li><li>Faça uma solicitação POST para http://localhost:8080/login com as credenciais (username e password) no corpo da solicitação.</li><li>Anote o token retornado.</li><li>Faça uma solicitação GET para http://localhost:8080/protected com o token no cabeçalho de autorização (Bearer Token).</li></ul><blockquote>Lembre-se de que esta é apenas uma implementação básica para entender o funcionamento do JWT em Go. Em um ambiente de produção, você precisaria adicionar recursos de segurança mais robustos, como gerenciamento de usuários, armazenamento seguro de chaves, etc.</blockquote><h4>Recursos Adicionais:</h4><ul><li><a href="https://github.com/Junkes887/jwt-go">Link do projeto</a></li><li><a href="https://github.com/dgrijalva/jwt-go">Documentação do jwt-go</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=367e6a73780a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>