<?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 Oops Telecom on Medium]]></title>
        <description><![CDATA[Stories by Oops Telecom on Medium]]></description>
        <link>https://medium.com/@araujo_89059?source=rss-89d5a2cdae47------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*ylcJY10Tr9w7RcKj</url>
            <title>Stories by Oops Telecom on Medium</title>
            <link>https://medium.com/@araujo_89059?source=rss-89d5a2cdae47------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 01:21:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@araujo_89059/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[Configuração do Keycloak em HTTPS]]></title>
            <link>https://medium.com/@araujo_89059/configura%C3%A7%C3%A3o-do-keycloak-em-https-7d2c2d816a44?source=rss-89d5a2cdae47------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d2c2d816a44</guid>
            <category><![CDATA[https]]></category>
            <category><![CDATA[keycloak]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[certbot]]></category>
            <dc:creator><![CDATA[Oops Telecom]]></dc:creator>
            <pubDate>Mon, 25 Nov 2024 19:30:45 GMT</pubDate>
            <atom:updated>2024-11-25T19:30:45.223Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Escrito por <a href="https://medium.com/u/8aca91f021a1">Lessaapolinario</a></blockquote><p>Neste artigo iriei abordar a instalação e configuração do Keycloak em HTTPS em um servidor usando Docker e certbot.</p><p>Usarei o Keycloak 26.0.4, se for usar outra versão verifique as variáveis de ambiente na documentação da ferramenta aqui <a href="https://www.keycloak.org/server/all-config"><strong>https://www.keycloak.org/server/all-config</strong></a></p><pre>services:<br>  keycloak:<br>    image: quay.io/keycloak/keycloak:26.0.4<br>    container_name: keycloak<br>    command: start<br>    env_file:<br>      - .env<br>    ports:<br>      - 3030:3030<br>    depends_on:<br>      - db<br>    networks:<br>      - keycloak-network<br>    volumes:<br>      - /home/keycloak-certificates:/etc/x509/https:ro<br><br>  db:<br>    image: postgres:16.3<br>    container_name: db<br>    volumes:<br>      - ./postgres-data:/var/lib/postgresql/data<br>    env_file:<br>      - .env<br>    ports:<br>      - 5432:5432<br>    networks:<br>      - keycloak-network<br><br>networks:<br>  keycloak-network:<br>    driver: bridge</pre><pre># Banco de dados<br>KC_DB=postgres<br>KC_DB_URL=jdbc:postgresql://db:5432/keycloak<br>KC_DB_USERNAME=root<br>KC_DB_PASSWORD=mysecretpass<br><br># Admin<br>KEYCLOAK_ADMIN=<br>KEYCLOAK_ADMIN_PASSWORD=<br><br># Configurações HTTPS<br>KC_HOSTNAME=<br>KC_HTTPS_PORT=<br>KC_HTTPS_CERTIFICATE_FILE=<br>KC_HTTPS_CERTIFICATE_KEY_FILE=<br>KC_HTTPS_PROTOCOLS=TLSv1.3,TLSv1.2<br><br># Configurações adicionais para o proxy<br>KC_HTTP_ENABLED=false<br>PROXY_ADDRESS_FORWARDING=true<br><br># Configuração do PostgreSQL<br>POSTGRES_USER=root<br>POSTGRES_HOST=db<br>POSTGRES_DB=keycloak<br>POSTGRES_PASSWORD=mysecretpass<br>POSTGRES_PORT=5432<br>TZ=America/Sao_Paulo</pre><p>Essa é a configuração do docker-compose.yaml e logo abaixo .env.example (que serve para mostrar o formato das envs do projeto).</p><p>Em services temos dois serviços, o keycloak onde estará nosso servidor de autenticação e db onde estará o Postgres.</p><p>No serviço keycloak carregamos o arquivo .env que deve ser criado no formato do .env.example mas com valores. Neste container está exporta a porta 3030 para o HTTPS e além disso a pasta /home/keycloak-certificates deve ser criada no servidor para guardar os certificados HTTPS. Podemos criar a pasta no ubuntu server da seguinte maneira:</p><pre>sudo mkdir -p /home/keycloak-certificates</pre><p>Usaremos a ferramenta certbot para obter os certificados para o domínio.</p><p>Para instalar o certbot usamos o comando:</p><pre>sudo apt-get update<br>sudo apt-get install certbot python3-certbot-nginx</pre><p>Para gerar os certificados usamos o comando:</p><pre>sudo certbot certonly --nginx -d keycloak.oopssmarthome.com.br</pre><p>A opção <strong>-d</strong> indica para qual domínio ou subdomínio (no caso desse exemplo) iremos gerar os certificados.</p><p>Após gerar os certificados devemos copiar para a pasta /home/keycloak-certificates, aquela do volume do Docker. Para fazer isso use:</p><pre>sudo cp /etc/letsencrypt/live/keycloak.oopssmarthome.com.br/fullchain.pem /home/lessa/keycloak-certificates/</pre><pre>sudo cp /etc/letsencrypt/live/keycloak.oopssmarthome.com.br/privkey.pem /home/lessa/keycloak-certificates/</pre><p>Defina as seguintes permissões para os arquivos serem acessíveis pelo container:</p><pre>sudo chmod 644 /home/lessa/keycloak-certificates/fullchain.pem</pre><pre>sudo chmod 644 /home/lessa/keycloak-certificates/privkey.pem</pre><p>Após isso devemos fazer com que os certificados sejam renovados, já que eles expiram. Para fazer isso precisamos acessar o crontab:</p><pre>sudo crontab -e</pre><p>Essa será a tela vista no terminal:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AMazCnOH0PVlfElkhZKrJw.png" /><figcaption>visão inicial do crontab</figcaption></figure><p>Precisamos editar esse arquivo apertando a tecla <strong>i</strong> para usar o modo de edição do vim. Depois de editar apertamos <strong>ESC</strong> e digitamos <strong>:wq</strong> e teclamos <strong>Enter</strong>.</p><p>Adicione essas linhas no final do arquivo:</p><pre>0 0 1 * * /usr/bin/certbot renew --quiet --renew-hook &quot;cp -f /etc/letsencrypt/live/keycloak.oopssmarthome.com.br/fullchain.pem /home/keycloak-certificates/ &amp;&amp; cp -f /etc/letsencrypt/live/keycloak.oopssmarthome.com.br/privkey.pem /home/keycloak-certificates/ &amp;&amp; chmod +x /home/keycloak-certificates/fullchain.pem &amp;&amp; chmod +x /home/keycloak-certificates/privkey.pem &amp;&amp; systemctl reload nginx&quot;</pre><p>Após isso, a cada um mês os certificados serão renovados e copiados para a pasta /home/keycloak-certificates e deixa suas permissões livres para o container. O arquivo final deve ser parecer com isso:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MG8ShCfenZTUgfeNOxNkOQ.png" /><figcaption>crontab atualizado</figcaption></figure><p>Depois disso é só usar o comando a seguir na pasta do projeto:</p><pre>docker compose up -d</pre><p>Para verificar se os containers subiram use:</p><pre>docker compose ps</pre><p>O resultado deve se parecer com isso:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*899dT1oMEJYdGT4UBu6LaQ.png" /><figcaption>containers do keycloak e do postgres</figcaption></figure><p>Agora é só acessar a url <strong>https:/</strong><a href="http://keycloak.oopssmarthome.com.br:3030/"><strong>/keycloak.oopssmarthome.com.br:3030/</strong></a>. Após acessar, a tela vista deve ser essa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WcQ_lxXwuv8hGffo2mm-ZA.png" /><figcaption>Painel administrativo do Keycloak</figcaption></figure><p>Agora é importante fazer backup do realm e dos usuários do Keycloak. Para isso precisamos alguns passos.</p><p>Primeiro, entrar no container:</p><pre>docker compose exec keycloak bash</pre><p>Segundo, fazer o backup:</p><pre>/opt/keycloak/bin/kc.sh export --dir /opt/keycloak/data/import --users realm_file --realm oops-sso</pre><p>O resultado é o seguinte:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dWiPzpLjLyJi1amkzeR2Xw.png" /><figcaption>Esses logs mostram que o backup fopi feito com sucesso</figcaption></figure><p>O caminho completo do arquivo gerado é: <strong>/opt/keycloak/data/import/oops-sso-realm.json</strong></p><p>Agora se faz necessário copiar a pasta de backup do Docker para o servidor. Para isso usamos:</p><pre>sudo docker cp keycloak:/opt/keycloak/data/import ./backup-keycloak</pre><p>Agora precisamos transferir esse arquivo do servidor para uma máquina local, nesse exemplo considero que temos o Linux numa máquina local. Para realizar essa tarefa usamos:</p><pre>scp &lt;USUARIO_DO_SERVIDOR&gt;@&lt;IP_DO_SERVIDOR&gt;:/home/&lt;USUARIO_DO_SERVIDOR&gt;/backup-keycloak/import/oops-sso-realm.json ./Downloads</pre><p>Para importar basta criar um novo realm e carregar o arquivo json gerado e agora salvo na pasta do computador pessoal. Para realizar essa tarefa basta seguir esses dois passos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ETRAIgA-sXrFWCLX12jmXw.png" /><figcaption>Clique em Create realm</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W0uEKRRVIxNYC6aZIW3G8g.png" /><figcaption>Clique em Browse…</figcaption></figure><p>Feito isso, agora é possível criar usuários e usar o Keyloak nas suas aplicações.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d2c2d816a44" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como ler os Binlogs do MySQL via Golang]]></title>
            <link>https://medium.com/@araujo_89059/como-ler-os-binlogs-do-mysql-via-golang-54799b707fdd?source=rss-89d5a2cdae47------2</link>
            <guid isPermaLink="false">https://medium.com/p/54799b707fdd</guid>
            <category><![CDATA[mysql-binlog]]></category>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Oops Telecom]]></dc:creator>
            <pubDate>Wed, 07 Aug 2024 13:48:56 GMT</pubDate>
            <atom:updated>2024-08-07T14:19:03.514Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Escrito por <a href="https://github.com/micledson">Micledson Carlos</a></blockquote><p>Neste artigo, será explicado como ler os binlogs gerados pelo MySQL em Go e inseri-los em outro banco de dados. Este tutorial assume que você já seguiu os passos de <a href="https://medium.com/@araujo_89059/como-ativar-os-binlogs-no-mysql-3beed4314da6">como ativar binlogs no MySQL</a>, conforme descrito em um artigo anterior, e que tudo está funcionando corretamente.</p><p>Primeiramente, é necessário importar duas dependências no arquivo main.go:</p><pre>&quot;github.com/go-mysql-org/go-mysql/canal&quot;<br>&quot;github.com/go-mysql-org/go-mysql/mysql&quot;</pre><p>Em seguida, vamos criar a função setupBinLog, responsável por configurar o acesso aos logs:</p><pre>func main() {<br>  setupBinLog()<br>}<br><br>// myEventHandler é a struct que ira nos permitir ter acesso aos canal<br>type myEventHandler struct {<br> canal.DummyEventHandler<br>}<br><br>// configura e inicia o canal para ouvir os eventos do binlog do MySQL.<br>func setupBinLog() {<br> // Configurações do canal<br> cfg := canal.NewDefaultConfig()<br> cfg.Addr = &quot;127.0.0.1:3306&quot; // endereço do banco de dados<br> cfg.User = &quot;root&quot; // usuário do banco de dados<br> cfg.Password = &quot;12345678&quot; // senha do banco de dados<br> cfg.Dump.TableDB = &quot;empresa&quot; // nome do banco de dados<br> cfg.Dump.ExecutionPath = &quot;&quot; // caminho de execução<br><br> // Cria uma nova instância do canal<br> c, err := canal.NewCanal(cfg)<br> if err != nil {<br>  log.Fatalf(&quot;Erro ao criar canal: %v&quot;, err)<br> }<br> defer c.Close()<br><br> // Define o manipulador de eventos personalizado<br> c.SetEventHandler(&amp;myEventHandler{})<br><br> // Posição inicial do binlog<br> pos := mysql.Position{Name: &quot;&quot;, Pos: uint32(0)}<br><br> // Executa o canal a partir da posição inicial do binlog<br> err = c.RunFrom(pos)<br> if err != nil {<br>  log.Fatalf(&quot;Erro ao executar o canal: %v&quot;, err)<br> }<br>}</pre><p>Com isso, temos o canal configurado. Agora, é necessário adicionar a função OnRow, que é chamada toda vez que há alguma alteração no MySQL, seja INSERT, UPDATE ou DELETE:</p><pre>func (h *myEventHandler) OnRow(e *canal.RowsEvent) error {<br> fmt.Printf(&quot;Ação: %v Tabela: %v Dados: %v\n&quot;, e.Action, e.Table, e.Rows)<br> return nil<br>}</pre><p>A variável e *canal.RowsEvent possui os seguintes atributos:</p><ul><li><strong>Action</strong>: exibe qual ação foi feita (INSERT, UPDATE ou DELETE).</li><li><strong>Table</strong>: exibe o nome da tabela que teve seus dados alterados.</li><li><strong>Rows</strong>: exibe os dados que foram adicionados, alterados ou deletados.</li></ul><p>Para testes, crie um banco de dados chamado empresa e uma tabela chamada pessoa:</p><pre>CREATE DATABASE empresa;<br><br>USE empresa;<br><br>CREATE TABLE pessoa (<br> id INT AUTO_INCREMENT PRIMARY KEY,<br>  nome varchar(100),<br>  CPF varchar(14) UNIQUE<br>);</pre><p>Inserindo uma nova linha a tabela:</p><pre>insert into pessoa values (1, &#39;Carlos Almeida&#39;, &#39;111.111.111-11&#39;);</pre><p>Executando o código com go run main.go, obtemos a seguinte saída:</p><pre>$ go run main.go<br>[2024/08/07 09:40:30] [info] binlogsyncer.go:180 create BinlogSyncer with config {ServerID:1401 Flavor:mysql Host:127.0.0.1 Port:3306 User:root Password: Localhost: Charset:utf8 SemiSy<br>ncEnabled:false RawModeEnabled:false TLSConfig:&lt;nil&gt; ParseTime:false TimestampStringLocation:UTC UseDecimal:false RecvBufferSize:0 HeartbeatPeriod:0s ReadTimeout:0s MaxReconnectAttempt<br>[2024/08/07 09:44:05] [info] binlogsyncer.go:418 begin to sync binlog from position (, 0)<br>[2024/08/07 09:44:05] [info] sync.go:22 start sync binlog at binlog file (, 0)<br>[2024/08/07 09:44:05] [info] binlogsyncer.go:821 rotate to (mysql-bin.000001, 4)<br>[2024/08/07 09:44:05] [info] sync.go:58 received fake rotate event, next log name is mysql-bin.000001<br>[2024/08/07 09:44:05] [info] sync.go:60 log name changed, the fake rotate event will be handled as a real rotate event<br>[2024/08/07 09:44:05] [info] sync.go:95 rotate binlog to (mysql-bin.000001, 4)<br>[2024/08/07 09:44:05] [info] sync.go:244 table structure changed, clear table cache: empresa.pessoa<br>[2024/08/07 09:44:05] [info] sync.go:244 table structure changed, clear table cache: empresa.plano<br>[2024/08/07 09:44:05] [info] sync.go:244 table structure changed, clear table cache: empresa.cliente<br>Ação: insert Tabela: empresa.pessoa Dados: [[1 Carlos Almeida 111.111.111-11]]</pre><p>Observe que a última linha exibe a saída da função OnRow, informando a ação realizada, a tabela afetada e os dados envolvidos.</p><p>Agora, vamos criar a função para configurar a conexão com o PostgreSQL:</p><pre>// Função que configura a conexão com o banco de dados PostgreSQL<br>func setupPostgres() {<br>   user := &quot;postgres&quot;<br>   password := &quot;12345678&quot;<br>   dbName := &quot;empresa&quot;<br>   host := &quot;localhost:5432&quot;<br>   sslMode := &quot;disable&quot;<br><br>   // URI de conexão com o banco de dados PostgreSQL<br>   uri := fmt.Sprintf(&quot;postgres://%s:%s@%s/%s?sslmode=%s&quot;, user, password, host, dbName, sslMode)<br><br>   // Abre a conexão com o PostgreSQL<br>   db, err := sqlx.Open(&quot;postgres&quot;, uri)<br>   if err != nil {<br>      log.Fatalf(&quot;Erro ao acessar o banco de dados: %v&quot;, err)<br>   }<br><br>   // Configurações de conexão<br>   db.SetConnMaxLifetime(time.Minute * 3)<br>   db.SetMaxOpenConns(10)<br>   db.SetMaxIdleConns(10)<br><br>   // Atribui a conexão ao variável global<br>   postgres = db<br>}</pre><p>Vamos atualizar a função OnRow para que, ao identificar uma inserção, chame a função de inserção no PostgreSQL:</p><pre>// OnRow é chamado sempre que há uma alteração em uma linha na tabela do banco de dados MySQL.<br>func (h *myEventHandler) OnRow(e *canal.RowsEvent) error {<br>   fmt.Printf(&quot;Ação: %v Tabela: %v Dados: %v\n&quot;, e.Action, e.Table, e.Rows)<br><br>   // Converte os dados da linha em um mapa para facilitar a manipulação<br>   // independente de qual tabela e quais dados foram modificados<br>   tableRow := map[string]interface{}{}<br>   for _, row := range e.Rows {<br>      for i, col := range e.Table.Columns {<br>         tableRow[col.Name] = row[i]<br>      }<br>   }<br><br>   // Insere os dados no PostgreSQL se a ação for &quot;insert&quot;<br>   if e.Action == &quot;insert&quot; {<br>      err := insertPostgresData(tableRow, e.Table.Name)<br>      if err != nil {<br>         fmt.Println(err)<br>         return err<br>      }<br>   }<br>   return nil<br>}</pre><p>Finalmente, vamos criar a função para inserir os dados no PostgreSQL:</p><pre>// Função que insere dados no PostgreSQL<br>func insertPostgresData(data map[string]interface{}, tableName string) error {<br>   columns := make([]string, 0, len(data))<br>   values := make([]interface{}, 0, len(data))<br>   placeholders := make([]string, 0, len(data))<br><br>   // Prepara colunas, valores e placeholders para a query de inserção<br>   // para que seja possivel inserir quaisquer quantidades de valores<br>   i := 1<br>   for column, value := range data {<br>      columns = append(columns, column)<br>      values = append(values, value)<br>      placeholders = append(placeholders, fmt.Sprintf(&quot;$%d&quot;, i))<br>      i++<br>   }<br><br>   // Constrói a query de inserção<br>   query := fmt.Sprintf(&quot;INSERT INTO %s (%s) VALUES (%s)&quot;, tableName, strings.Join(columns, &quot;,&quot;), strings.Join(placeholders, &quot;,&quot;))<br>   // Query formatada com os valores para serem inseridos<br>   // INSERT INTO pessoa (id,nome,CPF) VALUES ($1,$2,$3)<br><br><br>   // Executa a query no PostgreSQL<br>   _, err := postgres.Exec(query, values...)<br>   if err != nil {<br>      fmt.Println(err)<br>      return err<br>   }<br><br>   return nil<br>}</pre><p>Com esta configuração, qualquer dado inserido no MySQL será automaticamente inserido no PostgreSQL, independentemente da tabela e do tamanho dela.</p><p>Código completo</p><pre>package main<br><br>import (<br>   &quot;fmt&quot;<br>   &quot;github.com/go-mysql-org/go-mysql/canal&quot;<br>   &quot;github.com/go-mysql-org/go-mysql/mysql&quot;<br>   &quot;github.com/jmoiron/sqlx&quot;<br>   _ &quot;github.com/lib/pq&quot;<br>   &quot;log&quot;<br>   &quot;strings&quot;<br>   &quot;time&quot;<br>)<br><br>// Variável global para a conexão com o banco de dados PostgreSQL<br>var postgres *sqlx.DB<br><br>// myEventHandler define um manipulador de eventos personalizado que embute DummyEventHandler.<br>type myEventHandler struct {<br>   canal.DummyEventHandler<br>}<br><br>// Função principal que configura e inicia o canal para ouvir os eventos do binlog do MySQL.<br>func main() {<br>   setupPostgres()<br><br>   // Configurações do canal para conexão com o MySQL<br>   cfg := canal.NewDefaultConfig()<br>   cfg.Addr = &quot;127.0.0.1:3306&quot;<br>   cfg.User = &quot;root&quot;<br>   cfg.Password = &quot;12345678&quot;<br>   cfg.Dump.TableDB = &quot;empresa&quot;<br>   cfg.Dump.ExecutionPath = &quot;&quot;<br><br>   // Cria uma nova instância do canal<br>   c, err := canal.NewCanal(cfg)<br>   if err != nil {<br>      log.Fatalf(&quot;Erro ao criar canal: %v&quot;, err)<br>   }<br>   defer c.Close()<br><br>   // Define o manipulador de eventos personalizado<br>   c.SetEventHandler(&amp;myEventHandler{})<br><br>   // Posição inicial do binlog<br>   pos := mysql.Position{Name: &quot;&quot;, Pos: uint32(0)}<br><br>   // Executa o canal a partir da posição inicial do binlog<br>   err = c.RunFrom(pos)<br>   if err != nil {<br>      log.Fatalf(&quot;Erro ao executar o canal: %v&quot;, err)<br>   }<br>}<br><br>// OnRow é chamado sempre que há uma alteração em uma linha na tabela do banco de dados MySQL.<br>func (h *myEventHandler) OnRow(e *canal.RowsEvent) error {<br>   fmt.Printf(&quot;Ação: %v Tabela: %v Dados: %v\n&quot;, e.Action, e.Table, e.Rows)<br><br>   // Converte os dados da linha em um mapa<br>   tableRow := map[string]interface{}{}<br>   for _, row := range e.Rows {<br>      for i, col := range e.Table.Columns {<br>         tableRow[col.Name] = row[i]<br>      }<br>   }<br><br>   // Insere os dados no PostgreSQL se a ação for &quot;insert&quot;<br>   if e.Action == &quot;insert&quot; {<br>      err := insertPostgresData(tableRow, e.Table.Name)<br>      if err != nil {<br>         fmt.Println(err)<br>         return err<br>      }<br>   }<br>   return nil<br>}<br><br>// Função que insere dados no PostgreSQL<br>func insertPostgresData(data map[string]interface{}, tableName string) error {<br>   columns := make([]string, 0, len(data))<br>   values := make([]interface{}, 0, len(data))<br>   placeholders := make([]string, 0, len(data))<br><br>   // Prepara colunas, valores e placeholders para a query de inserção<br>   i := 1<br>   for column, value := range data {<br>      columns = append(columns, column)<br>      values = append(values, value)<br>      placeholders = append(placeholders, fmt.Sprintf(&quot;$%d&quot;, i))<br>      i++<br>   }<br><br>   // Constrói a query de inserção<br>   query := fmt.Sprintf(&quot;INSERT INTO %s (%s) VALUES (%s)&quot;, tableName, strings.Join(columns, &quot;,&quot;), strings.Join(placeholders, &quot;,&quot;))<br><br>   // Executa a query no PostgreSQL<br>   _, err := postgres.Exec(query, values...)<br>   if err != nil {<br>      fmt.Println(err)<br>      return err<br>   }<br><br>   return nil<br>}<br><br>// Função que configura a conexão com o banco de dados PostgreSQL<br>func setupPostgres() {<br>   user := &quot;postgres&quot;<br>   password := &quot;12345678&quot;<br>   dbName := &quot;empresa&quot;<br>   host := &quot;localhost:5432&quot;<br>   sslMode := &quot;disable&quot;<br><br>   // URI de conexão com o banco de dados PostgreSQL<br>   uri := fmt.Sprintf(&quot;postgres://%s:%s@%s/%s?sslmode=%s&quot;, user, password, host, dbName, sslMode)<br><br>   // Abre a conexão com o PostgreSQL<br>   db, err := sqlx.Open(&quot;postgres&quot;, uri)<br>   if err != nil {<br>      log.Fatalf(&quot;Erro ao acessar o banco de dados: %v&quot;, err)<br>   }<br><br>   // Configurações de conexão<br>   db.SetConnMaxLifetime(time.Minute * 3)<br>   db.SetMaxOpenConns(10)<br>   db.SetMaxIdleConns(10)<br><br>   // Atribui a conexão ao variável global<br>   postgres = db<br>}</pre><p>Para qualquer dúvida ou sugestão, deixe um comentário.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=54799b707fdd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Documentação New Relic em GO— Parte 1, Backend]]></title>
            <link>https://medium.com/@araujo_89059/documenta%C3%A7%C3%A3o-new-relic-em-go-parte-1-backend-fea1bcadbf58?source=rss-89d5a2cdae47------2</link>
            <guid isPermaLink="false">https://medium.com/p/fea1bcadbf58</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[new-relic]]></category>
            <dc:creator><![CDATA[Oops Telecom]]></dc:creator>
            <pubDate>Mon, 22 Jul 2024 13:00:46 GMT</pubDate>
            <atom:updated>2024-07-22T13:04:41.689Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Escrito por </em><a href="http://github.com/micledson"><em>Micledson Carlos</em></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*174i0hDQRxfrbVOJgTn_Sg.png" /><figcaption>Imagem obtida em <a href="https://pt.wikipedia.org/wiki/Ficheiro:New_Relic_logo.png">Ficheiro:New Relic logo.png — Wikipédia, a enciclopédia livre (wikipedia.org)</a></figcaption></figure><h3>A Importância do Monitoramento de Aplicações</h3><p>O monitoramento de aplicações é essencial para garantir o desempenho, a confiabilidade e a eficiência dos sistemas e serviços digitais. À medida que as empresas e organizações dependem cada vez mais da tecnologia para as suas operações, a necessidade de monitorizar continuamente o desempenho das aplicações torna-se essencial<strong>.</strong></p><h4>1. Identificação Proativa de Problemas</h4><p>Os programas de monitoramento permitem<strong> </strong>que as equipes de desenvolvimento e gerenciamento identifiquem problemas antes que afetem os usuários finais. Métricas como tempo de resposta, utilização de recursos e erros podem ser monitoradas em tempo real, fornecendo informações sobre a integridade do sistema.</p><h4>2. Otimização de Desempenho</h4><p>Com dados detalhados de<strong> </strong>desempenho de aplicações, você pode otimizar recursos e melhorar a eficiência operacional. Isso inclui identificar gargalos de desempenho, ajustar configurações e otimizar código para fornecer uma experiência mais rápida e responsiva aos usuários.</p><h4>3. Melhoria da Experiência do Usuário</h4><p>Aplicações lentas ou instáveis podem levar a uma experiência do usuário insatisfatória, o que pode resultar em perda de clientes. Monitorar continuamente o desempenho das aplicações ajuda a garantir uma experiência do usuário consistente e de alta qualidade.</p><h4>4. Planejamento de Capacidade</h4><p>Compreender padrões de uso e tendências de desempenho ao longo do tempo é essencial para um planejamento eficaz. O monitoramento de aplicações fornece dados históricos e previsões que ajudam as equipes a dimensionar recursos adequadamente e evitar surpresas relacionadas ao crescimento repentino da demanda.</p><h3>Código</h3><p>Indo para a parte do código, para o exemplo, teremos a seguinte estrutura de pastas</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/473/1*8IIelS8UNPn-0oTFlugCCg.png" /></figure><p>Vamos comecar pela pasta <strong>utils</strong>, nela, vamos configurar nossa conta com o new relic</p><pre>//new_relic.go<br>var (<br> App *newrelic.Application<br> Log *log.Logger<br>)<br><br>func init() {<br> if _, err := os.Stat(&quot;.env&quot;); err == nil {<br>  err := godotenv.Load()<br>  if err != nil {<br>   log.Fatalf(&quot;Error loading .env file: %v&quot;, err)<br>  }<br> } else if !os.IsNotExist(err) {<br>  log.Fatalf(&quot;Error checking existence of .env file: %v&quot;, err)<br> }<br><br> viper.SetConfigType(&quot;.env&quot;)<br> viper.AutomaticEnv()<br><br> license := os.Getenv(&quot;NEW_RELIC_LICENSE&quot;)<br><br> var err error<br> App, err = newrelic.NewApplication(<br>  newrelic.ConfigAppName(&quot;new_relic_example&quot;),<br>  newrelic.ConfigLicense(license),<br>  newrelic.ConfigAppLogForwardingEnabled(true),<br> )<br> if err != nil {<br>  log.Fatalf(&quot;Error initializing New Relic application: %v&quot;, err)<br> }<br><br> writer := logWriter.New(os.Stdout, App)<br> writer.DebugLogging(true)<br><br> Log = log.New(&amp;writer, &quot;&quot;, log.Default().Flags())<br>}</pre><p>Estamos pegando o arquivo <strong>.env</strong>, que contem nossa chave do new relic.</p><p>Onde tem “new_relic_example” é o nome que ficara salvo a nossa aplicação dentro do site do new relic.</p><pre>//main.go<br>func main() {<br> txn := utils.App.StartTransaction(&quot;[MAIN] Start Transaction&quot;)<br> defer txn.End()<br><br> e := echo.New()<br><br> routes.RegisterRoutes(e)<br><br> e.Logger.Fatal(e.Start(&quot;:8080&quot;))<br>}</pre><p>No arquivo main estamos iniciando uma transaction, essa é a forma que o new relic quantifica o tempo de uma operação, ou seja, vamos adicionar uma transaction para toda função que fizermos, assim podemos ver quais as funções que estão levando mais tempo para serem processadas.</p><pre><br>//user.go<br>type User struct {<br> id    uuid.UUID<br> name  string<br> email string<br>}<br><br><br>func (user User) toResponse() *UserResponse {<br> return &amp;UserResponse{<br>  Id:    user.id,<br>  Name:  user.name,<br>  Email: user.email,<br> }<br>}</pre><pre>//userRequest.go<br>type UserRequest struct {<br> Name  string `json:&quot;name&quot;`<br> Email string `json:&quot;email&quot;`<br>}<br><br>func (user UserRequest) toUser() *User {<br> return &amp;User{<br>  name:  user.Name,<br>  email: user.Email,<br> }<br>}<br><br>//userResponse.go<br>type UserResponse struct {<br> Id    uuid.UUID `json:&quot;id&quot;`<br> Name  string    `json:&quot;name,omitempty&quot;`<br> Email string    `json:&quot;email,omitempty&quot;`<br>}</pre><pre>//handler.go<br>func CreateUser(c echo.Context) error {<br>   txn := utils.App.StartTransaction(&quot;[Create User] Start Transaction&quot;)<br>   defer txn.End()<br><br>   var userRequest UserRequest<br><br>   if err := c.Bind(&amp;userRequest); err != nil {<br>      utils.Log.Println(&quot;bind user request failed&quot;)<br>      return c.JSON(http.StatusBadRequest, map[string]string{&quot;error&quot;: &quot;Invalid request&quot;})<br>   }<br><br>   user, err := createUser(userRequest)<br>   if err != nil {<br>      utils.Log.Println(&quot;error when creating user: &quot;, err)<br>   }<br><br>   return c.JSON(http.StatusOK, user.toResponse())<br>}<br><br>func GetUsers(c echo.Context) error {<br>   txn := utils.App.StartTransaction(&quot;[Get Users] Start Transaction&quot;)<br>   defer txn.End()<br><br>   users, err := getUsers()<br>   if err != nil {<br>      utils.Log.Println(&quot;error when getting user: &quot;, err)<br>      c.JSON(http.StatusUnprocessableEntity, map[string]string{&quot;error&quot;: fmt.Sprintf(&quot;error when getting user: %s&quot;, err)})<br>   }<br><br>   var usersResponse []UserResponse<br><br>   for _, user := range users {<br>      usersResponse = append(usersResponse, *user.toResponse())<br>   }<br><br>   return c.JSON(http.StatusOK, usersResponse)<br>}</pre><p>No arquivo de handler, temos duas funções, a de criar usuário [<strong>CreateUser</strong>] e de buscar os usuários [<strong>GetUser</strong>]</p><p>dentro do CreateUser temos o startTransaction, para iniciar a transaction do CreateUser, nela fazemos o bind dos arquivos enviados pelo usuário para o UserRequest e enviamos para o nosso arquivo de service.go, nota-se também que, caso o bind de erro temos a chamada da funcão utils.Log.Println, ela é a funcão de log que o new relic nos disponibiliza. Com ela podemos adicionar os logs que serão exibidos no servidor, mas eles também são exibidos na dashboard do <a href="https://newrelic.com/pt">new relic</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Vvd2ocHiXaxr_2ZYudsIQ.png" /></figure><p>No site do <a href="https://newrelic.com/pt">new relic</a>, mostrando quais as transactions rodaram e qual o tempo delas.</p><h4>Fazendo uma bad request</h4><p>Fiz uma bad request para a rota de criar um usuário [CreateUser], passando um json errado</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5n_ErqR9r8K4w1G1vF30yw.png" /></figure><p>Se olhar os logs da aplicação aparecera a mensagem de erro</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/458/1*Lnogg70W5ePHjKAKg1sMQA.png" /></figure><p>E olhando no new relic temos também a mensagem de erro.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wR8CdZqwZO3TOAW12MYhBg.png" /></figure><p>Dessa forma, temos uma aplicação funcional e que, por conta do new relic e do monitoramento podemos observar quais são os erros dela, por meio dos logs, e quais as funções (Transactions) que mais estão demorando para executar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fea1bcadbf58" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como ativar os Binlogs no MySQL]]></title>
            <link>https://medium.com/@araujo_89059/como-ativar-os-binlogs-no-mysql-3beed4314da6?source=rss-89d5a2cdae47------2</link>
            <guid isPermaLink="false">https://medium.com/p/3beed4314da6</guid>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[mysql-binlog]]></category>
            <category><![CDATA[binlog]]></category>
            <dc:creator><![CDATA[Oops Telecom]]></dc:creator>
            <pubDate>Thu, 11 Jul 2024 14:54:06 GMT</pubDate>
            <atom:updated>2024-07-12T11:24:24.913Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Escrito por <a href="https://github.com/micledson">Micledson Carlos</a></blockquote><p>Neste Artigo Irei mostrar como ativar os Binlogs no MySQL e como Adicionar um novo usuário com acesso aos binlogs.</p><p>Estou usando o MySQL 5.6 via Docker, mas o funcionamento será o mesmo para qualquer ambiente.</p><pre>#docker-compose.yml<br>version: &quot;3.8&quot;<br>services:<br>  db:<br>    image: mysql:5.6<br>    container_name: mysql_container<br>    environment:<br>      MYSQL_ROOT_PASSWORD: 12345678<br>    ports:<br>      - 3306:3306</pre><p>Dentro do container do MySQL será necessário encontrar o arquivo <strong>mysqld.cnf </strong>que está localizado na pasta /etc/mysql/mysql.conf.d/</p><p>⚠️ <strong>ATENÇÃO</strong>: A partir da versão 5.7 do MySQL foi adicionado um arquivo chamado <strong>my.cnf </strong>localizado dentro da pasta /etc, o conteúdo dele é o mesmo que o conteúdo do <strong>mysqld.cnf</strong>, bastando seguir os mesmos procedimentos.</p><p>o conteúdo do arquivo será esse:</p><pre># Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.<br>#<br># This program is free software; you can redistribute it and/or modify<br># it under the terms of the GNU General Public License, version 2.0,<br># as published by the Free Software Foundation.<br>#<br># This program is also distributed with certain software (including<br># but not limited to OpenSSL) that is licensed under separate terms,<br># as designated in a particular file or component or in included license<br># documentation.  The authors of MySQL hereby grant you an additional<br># permission to link the program and your derivative works with the<br># separately licensed software that they have included with MySQL.<br>#<br># This program is distributed in the hope that it will be useful,<br># but WITHOUT ANY WARRANTY; without even the implied warranty of<br># MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the<br># GNU General Public License, version 2.0, for more details.<br>#<br># You should have received a copy of the GNU General Public License<br># along with this program; if not, write to the Free Software<br># Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA<br><br>#<br># The MySQL  Server configuration file.<br>#<br># For explanations see<br># http://dev.mysql.com/doc/mysql/en/server-system-variables.html<br><br>[mysqld]<br>pid-file        = /var/run/mysqld/mysqld.pid<br>socket          = /var/run/mysqld/mysqld.sock<br>datadir         = /var/lib/mysql<br>#log-error      = /var/log/mysql/error.log<br># Disabling symbolic-links is recommended to prevent assorted security risks<br>symbolic-links=0</pre><p>Basta adicionar as seguintes linhas depois do <strong>[mysqld]</strong>:</p><pre>[mysqld]<br># Identifica de forma única este servidor na replicação. Deve ser único entre todos os servidores de replicação.<br>server-id=1<br><br># Ativa o registro binário e define o caminho e o nome do arquivo de log binário.<br>log-bin=/var/lib/mysql/mysql-bin.log<br><br># Especifica quais bancos de dados devem ser registrados no log binário. Neste caso, apenas o banco de dados &#39;logger_database&#39;.<br>binlog_do_db=logger_database<br><br># Define o formato dos eventos no log binário. &#39;row&#39; significa que eventos de linha (alterações nas linhas) serão registrados.<br>binlog_format=row<br><br># Define o nível de detalhe para eventos de linha. &#39;full&#39; significa que o registro incluirá todas as colunas das linhas alteradas.<br>binlog_row_image=full<br><br># Ativa o registro de consultas nas filas de eventos de linha, o que ajuda na auditoria e depuração.<br>binlog_rows_query_log_events=on<br><br># Define o número de dias antes que os logs binários expirem e sejam automaticamente excluídos. &#39;0&#39; significa que não expirarão.<br>expire_logs_days=0<br><br><br>pid-file        = /var/run/mysqld/mysqld.pid<br>socket          = /var/run/mysqld/mysqld.sock<br>datadir         = /var/lib/mysql<br>#log-error      = /var/log/mysql/error.log<br># Disabling symbolic-links is recommended to prevent assorted security risks<br>symbolic-links=0</pre><p>Pronto, basta reiniciar o container e pronto. Para verificar se os binlogs estão ativos basta rodar o comando</p><pre>SHOW VARIABLES LIKE &#39;log_bin&#39;;</pre><p>Caso esteja tudo certo ele ira exibir uma tabela, caso o valor seja ON significa que os logs foram ativados com sucesso.</p><pre>+---------------+-------+<br>| Variable_name | Value |<br>+---------------+-------+<br>| log_bin       |  ON   |<br>+---------------+-------+</pre><h3>Adicionando um novo usuário com permissão de leitura</h3><p>Algumas vezes acaba sendo mais interessante criar um novo usuário somente com acesso a leitura(select) para que ele tenha acesso aos logs, mas que não possa fazer nenhuma alteração ao banco de dados.</p><p>Ao entrar no MySQL como root podermos adicionar um novo usuário</p><p>Vamos rodar os seguintes comandos:</p><pre>-- Cria um novo usuário &#39;user_observer&#39; com acesso a partir de qualquer host e define sua senha.<br>CREATE USER &#39;user_observer&#39;@&#39;%&#39; IDENTIFIED BY &#39;senha_segura&#39;;<br><br>-- Concede permissão de leitura (SELECT) no banco de dados &#39;logger_database&#39; para o usuário &#39;user_observer&#39;.<br>GRANT SELECT ON logger_database.* TO &#39;user_observer&#39;@&#39;%&#39;;<br><br>-- Concede permissões de replicação (REPLICATION SLAVE, REPLICATION CLIENT) para o usuário &#39;user_observer&#39;, permitindo que ele consulte os binlogs.<br>GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO &#39;user_observer&#39;@&#39;%&#39;;<br><br>-- Aplica as alterações de privilégios, garantindo que todas as concessões de permissões entrem em vigor imediatamente.<br>FLUSH PRIVILEGES;</pre><p>Com isso conseguimos criar um novo usuário que só tem acesso a leitura e que é capaz de consultar os binlogs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3beed4314da6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Documentação new relic e vuejs — parte 2, frontend]]></title>
            <link>https://medium.com/@araujo_89059/documenta%C3%A7%C3%A3o-new-relic-e-vuejs-parte-2-frontend-6dc6ed1990d6?source=rss-89d5a2cdae47------2</link>
            <guid isPermaLink="false">https://medium.com/p/6dc6ed1990d6</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[new-relic]]></category>
            <category><![CDATA[vuejs]]></category>
            <dc:creator><![CDATA[Oops Telecom]]></dc:creator>
            <pubDate>Thu, 27 Jun 2024 19:11:04 GMT</pubDate>
            <atom:updated>2024-07-22T13:49:31.058Z</atom:updated>
            <content:encoded><![CDATA[<h3>Documentação new relic e vuejs — parte 2, frontend</h3><p>O presente artigo tem como objetivo documentar como monitorar uma aplicação vuejs com newrelic</p><blockquote>Escrito por <a href="https://medium.com/u/8aca91f021a1">Lessaapolinario</a></blockquote><p>New Relic é uma poderosa ferramenta de monitoramento de performance que fornece insights em tempo real sobre o comportamento da sua aplicação. Ela permite que desenvolvedores, equipes de operações e stakeholders acompanhem a saúde e a performance da aplicação, identifiquem problemas rapidamente e entendam a experiência do usuário em detalhes. Com New Relic, é possível monitorar aplicações web e móveis, infraestrutura e até mesmo o uso real do usuário.</p><p>Nesse Artigo será apresentado com integrar vuejs com o new relic.</p><h4>Configurando o projeto</h4><p>O primeiro passo é criar o projeto no painel do newrelic:</p><p>Clicamos em “Add Data”, no painel à esquerda ou na aba “All Capabilities” no botão “Add Data”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*msIvKupyZG9fwQv32emCug.png" /></figure><p>No lado esquerdo podemos instalar um sdk de um linguagem de progração ou framework.</p><p>No caso do Vuejs temos que escolher “Browser”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YcS3VBTBItkuKHq5FoTtBQ.png" /></figure><p>Escolhemos “Vue”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1pWw8CT9FECmFWMxlBwXyw.png" /></figure><p>Se Ainda não está monitorando sua aplicação escolha “Place a JavaScript snippet in frontend code” ou escolha “Connect browser data to an application’s APM data” se estiver usando APM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C2S9RQRRmq8M1NLOkB0bIQ.png" /></figure><p>Se escolher “Place a JavaScript snippet in frontend code”, digite o nome da aplicação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HuBbUPBMKmHF4-jzdXS3cA.png" /></figure><p>Deixamos como está clicamos em “Continue”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6hA9opF8wFDQyOm3yf9WcA.png" /></figure><p>Nesta etapa clicamos e “See your data”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O2sxitkb4kQSFJiZIF_IGA.png" /></figure><p>Feito isso podemos conectar o nosso app web com vuejs baseado nessa tag script ou usar a lib “@newrelic/browser-agent”.</p><p>Usando o script, basta copiar clicando em “Copy to clipboard” e colar na tag head.</p><p>Usando a lib “@newrelic/browser-agent” precisamos configurar o browser.</p><p><strong>Dica:</strong> Configure baseado no que tem na tag script, para ter os recursos do newrelic ativados. Pode usar o chatGPT pra isso, pegando os trechos que têm as permissões.</p><h4>Configurando o BrowserAgent</h4><blockquote>Crie um arquivo no caminho <strong><em>src/helpers/newrelic/agents/browser.js<br>OBS: Essas pastas devem ser criadas manualmente!</em></strong></blockquote><pre>import { JSErrors } from &quot;@newrelic/browser-agent/features/jserrors&quot;;<br>import { Spa } from &quot;@newrelic/browser-agent/features/spa&quot;;<br>import { BrowserAgent } from &quot;@newrelic/browser-agent/loaders/browser-agent&quot;;<br><br>const options = {<br>  info: {<br>    beacon: &quot;&lt;SEU-BEACON&gt;&quot;,<br>    errorBeacon: &quot;&lt;SEU-ERROOR-BEACON&gt;&quot;,<br>    applicationID: &quot;&lt;SEU-APP-ID&gt;&quot;,<br>    licenseKey: &quot;&lt;SUA-LICENSE-KEY&gt;&quot;,<br>    agent: &quot;@newrelic/browser-agent&quot;, // Seu agente<br>  },<br>  loader_config: {<br>    accountID: &quot;&lt;SEU-ACCOUNT-ID&gt;&quot;,<br>    trustKey: &quot;&lt;SUA-TRUST-KEY&gt;&quot;,<br>    agentID: &quot;&lt;SEU-AGENT_ID&gt;&quot;,<br>  },<br>  init: {<br>    distributed_tracing: {<br>      enabled: true,<br>    },<br>    privacy: {<br>      cookies_enabled: true,<br>    },<br>    ajax: {<br>      deny_list: [&quot;&lt;DENY&gt;&quot;], // sua DENY-LIST, um array<br>      block_internal: true,<br>      enabled: true,<br>      harvestTimeSeconds: 10,<br>      autoStart: true,<br>    },<br>    jserrors: {<br>      enabled: true,<br>      harvestTimeSeconds: 10,<br>      autoStart: true,<br>    },<br>    metrics: {<br>      enabled: true,<br>      autoStart: true,<br>    },<br>    page_action: {<br>      enabled: true,<br>      harvestTimeSeconds: 30,<br>      autoStart: true,<br>    },<br>    page_view_event: {<br>      enabled: true,<br>      autoStart: true,<br>    },<br>    page_view_timing: {<br>      enabled: true,<br>      harvestTimeSeconds: 30,<br>      long_task: false,<br>      autoStart: true,<br>    },<br>    session_trace: {<br>      enabled: true,<br>      harvestTimeSeconds: 10,<br>      autoStart: true,<br>    },<br>    spa: {<br>      enabled: true,<br>    },<br>  },<br>  features: [Spa, JSErrors],<br>};<br><br>export const browserAgent = new BrowserAgent(options);</pre><p>Explicação do arquivo:</p><h3>info</h3><ul><li><strong>beacon</strong>: URL do servidor onde os dados de monitoramento são enviados.</li><li><strong>errorBeacon</strong>: URL do servidor para envio de dados de erros.</li><li><strong>applicationID</strong>: ID da aplicação no New Relic.</li><li><strong>licenseKey</strong>: Chave de licença para autenticação com o New Relic.</li><li><strong>agent</strong>: Nome do agente usado.</li></ul><h3>loader_config</h3><ul><li><strong>accountID</strong>: ID da conta no New Relic.</li><li><strong>trustKey</strong>: Chave de confiança, geralmente o mesmo que accountID.</li><li><strong>agentID</strong>: ID do agente de monitoramento.</li></ul><h3>init</h3><ul><li><strong>distributed_tracing</strong>: Habilita a rastreamento distribuído para correlacionar dados de várias partes do sistema.</li><li><strong>privacy</strong>: Configurações de privacidade.</li><li><strong>cookies_enabled</strong>: Habilita o uso de cookies.</li><li><strong>ajax</strong>: Configurações para monitoramento de requisições AJAX.</li><li><strong>deny_list</strong>: Lista de URLs para as quais não devem ser monitoradas as requisições.</li><li><strong>block_internal</strong>: Bloqueia requisições internas do monitoramento.</li><li><strong>enabled</strong>: Habilita o monitoramento AJAX.</li><li><strong>harvestTimeSeconds</strong>: Intervalo de tempo para coletar dados AJAX.</li><li><strong>autoStart</strong>: Inicia automaticamente o monitoramento AJAX.</li><li><strong>jserrors</strong>: Configurações para monitoramento de erros JavaScript.</li><li><strong>enabled</strong>: Habilita o monitoramento de erros JavaScript.</li><li><strong>harvestTimeSeconds</strong>: Intervalo de tempo para coletar dados de erros.</li><li><strong>autoStart</strong>: Inicia automaticamente o monitoramento de erros.</li><li><strong>metrics</strong>: Configurações para coleta de métricas gerais.</li><li><strong>enabled</strong>: Habilita a coleta de métricas.</li><li><strong>autoStart</strong>: Inicia automaticamente a coleta de métricas.</li><li><strong>page_action</strong>: Configurações para monitoramento de ações na página.</li><li><strong>enabled</strong>: Habilita o monitoramento de ações na página.</li><li><strong>harvestTimeSeconds</strong>: Intervalo de tempo para coletar dados de ações na página.</li><li><strong>autoStart</strong>: Inicia automaticamente o monitoramento de ações na página.</li><li><strong>page_view_event</strong>: Configurações para eventos de visualização de página.</li><li><strong>enabled</strong>: Habilita o monitoramento de visualizações de página.</li><li><strong>autoStart</strong>: Inicia automaticamente o monitoramento de visualizações de página.</li><li><strong>page_view_timing</strong>: Configurações para tempos de carregamento de página.</li><li><strong>enabled</strong>: Habilita o monitoramento de tempos de carregamento de página.</li><li><strong>harvestTimeSeconds</strong>: Intervalo de tempo para coletar dados de tempos de carregamento.</li><li><strong>long_task</strong>: Habilita o monitoramento de tarefas longas (desabilitado neste caso).</li><li><strong>autoStart</strong>: Inicia automaticamente o monitoramento de tempos de carregamento.</li><li><strong>session_trace</strong>: Configurações para rastreamento de sessões.</li><li><strong>enabled</strong>: Habilita o rastreamento de sessões.</li><li><strong>harvestTimeSeconds</strong>: Intervalo de tempo para coletar dados de sessões.</li><li><strong>autoStart</strong>: Inicia automaticamente o rastreamento de sessões.</li><li><strong>spa</strong>: Configurações específicas para Single Page Applications.</li><li><strong>enabled</strong>: Habilita o monitoramento de SPAs.</li></ul><h3>features</h3><ul><li>Lista de funcionalidades a serem carregadas: Spa para monitoramento de Single Page Applications e JSErrors para monitoramento de erros JavaScript.</li></ul><p>É preciso inicializar o serviço:</p><blockquote>Modifique o arquivo no caminho: <strong><em>src/App.vue</em></strong></blockquote><pre>&lt;template&gt;<br>  &lt;router-view /&gt;<br>&lt;/template&gt;<br><br>&lt;script setup&gt;<br>import { onMounted } from &quot;vue&quot;;<br><br>import { browserAgent } from &quot;./helpers/newrelic/agents/browser&quot;;<br><br>const startAgentFeatures = () =&gt; {<br>  browserAgent.start();<br>};<br><br>onMounted(() =&gt; {<br>  startAgentFeatures();<br>});<br>&lt;/script&gt;</pre><p>Agora será mostrado o arquivo de utils e como suas funções são usadas no app Vue.</p><blockquote>Crie um arquivo no caminho <strong><em>src/helpers/newrelic/utils.js</em></strong></blockquote><pre>import { browserAgent } from &quot;./agents/browser&quot;;<br><br>export function monitorUserClick({ button, page, user }) {<br>  const { name, branch, company, department } = user;<br><br>  browserAgent.addPageAction(&quot;Clique de botão&quot;, {<br>    button,<br>    page,<br>    username: name,<br>    branch: branch ?? &quot;-&quot;,<br>    company: company ?? &quot;-&quot;,<br>    department: department ?? &quot;-&quot;,<br>  });<br>}<br><br>export function noticeError(error) {<br>  return browserAgent.noticeError(error);<br>}<br><br>export function createInteractionTracer(name, callback) {<br>  const interaction = browserAgent.interaction();<br>  interaction.setName(name);<br>  return interaction.createTracer(name, callback);<br>}</pre><p>Nesse arquivo é usado o browserAgent criado a partir das options.</p><p>A função addpageAction é usada para registrar um acontecimento que o newrelic não rastreia automaticamente, nesse caso está sendo usada em “<strong>monitorUserClick</strong>” para salvar quem clicou em certo botão, qual o botão e sua página.</p><p>A função noticeError notifica um erro no newrelic.</p><p>A função createTracer é usada para criar uma trace, que captura o tempo de execução de execução de uma ação. Segundo a documentação: “<strong>Cronometra os subcomponentes de uma interação SPA separadamente, incluindo tempo de espera e tempo de execução JS</strong>”.</p><blockquote>Crie o arquivo de boot do quasar no caminho <strong><em>src/boot/firebase.js</em></strong> para inicializar o firebase:</blockquote><pre>import { initializeApp } from &quot;firebase/app&quot;;<br>import { getAuth } from &quot;firebase/auth&quot;;<br>import { getFirestore } from &quot;firebase/firestore&quot;;<br>import { getStorage } from &quot;firebase/storage&quot;;<br><br>const firebaseConfig = {<br>  apiKey: &quot;&lt;SUA_API_KEY&gt;&quot;,<br>  authDomain: &quot;SEU_AUTH_DOMAIN&quot;,<br>  projectId: &quot;SEU_PROJECT_ID&quot;,<br>  storageBucket: &quot;SEU_STORAGE_BUCKET&quot;,<br>  messagingSenderId: &quot;SEU_MESSAGING_SENDER_ID&quot;,<br>  appId: &quot;SEU_APP_ID&quot;,<br>  measurementId: &quot;SEU_MEASUREMENT_ID&quot;,<br>};<br><br>// Initialize Firebase<br>const app = initializeApp(firebaseConfig);<br>// const analytics = getAnalytics(app);<br><br>const db = getFirestore(app);<br>const storage = getStorage(app);<br><br>export { app, db, storage };</pre><blockquote><strong>OBS: Os dados do firebase config podem ser copiados das configurações do projeto firebase na visão geral do projeto criado.</strong></blockquote><blockquote>Vamos criar um exemplo genérico para exemplificar.<br>Crie uma <strong>store</strong> <strong>product com vuex </strong>usando o comando <strong>quasar new s product. <br></strong>Crie uma <strong>action do vuex</strong> chamada <strong>createProduct</strong> conforme mostrado a seguir:</blockquote><pre>import { addDoc, collection, serverTimestamp } from &quot;firebase/firestore&quot;;<br>import { db } from &quot;src/boot/firebase&quot;;<br><br>export async function createProduct(context, { product }) {<br>  const { id, name, price } = product;<br><br>  try {<br>    const data = {<br>      id,<br>      name,<br>      price,<br>      createdAt: serverTimestamp(),<br>      updatedAt: serverTimestamp(),<br>    };<br><br>    const productCollection = collection(db, &quot;/products&quot;);<br>    await addDoc(productCollection, data);<br>  } catch (error) {<br>    console.error(error);<br>  }<br>}</pre><p>Neste exemplo é usado o noticeError das utils, observe que é preciso passar um erro como argumento. É usado também o addPageAction para salvar o tempo de execução da função.</p><p>No exemplo abaixo é mostrado como os cliques são salvos:</p><blockquote>Depois é só criar um componente para executar essa função.<br>Criamos usando o comando <strong><em>quasar new c product/CreateProduct<br></em></strong><em>Após isso será gerado o arquivo </em><strong><em>CreateProduct.vue</em></strong></blockquote><pre>&lt;script setup&gt;<br>import { monitorUserClick } from &quot;src/helpers/newrelic/utils&quot;;<br>import { reactive, toRefs } from &quot;vue&quot;;<br>import { useStore } from &quot;vuex&quot;;<br><br>const $store = useStore();<br><br>const references = reactive({ name: &quot;&quot;, price: 0 });<br>const { name, price } = toRefs(references);<br><br>const onSubmit = async () =&gt; {<br>  const data = {<br>    name: name.value,<br>    price: price.value,<br>  };<br><br>  await $store.dispatch(&quot;product/createProduct&quot;, {<br>    product: data,<br>  });<br>};<br><br>const monitorCreateProductClick = () =&gt; {<br>  monitorUserClick({<br>    button: &quot;Criar produto&quot;,<br>    page: &quot;Página de produtos&quot;,<br>    // Dados fictícios para a chave user, apenas um exemplo<br>    user: {<br>      id: &quot;test&quot;,<br>      name: &quot;test&quot;,<br>      email: &quot;test&quot;,<br>    },<br>  });<br>};<br>&lt;/script&gt;<br><br>&lt;template&gt;<br>  &lt;q-form<br>    class=&quot;column items-center justify-start q-gutter-sm&quot;<br>    @submit.prevent=&quot;onSubmit&quot;<br>  &gt;<br>    &lt;q-input<br>      disable<br>      square<br>      filled<br>      dense<br>      v-model=&quot;name&quot;<br>      class=&quot;col-xs-12 col-sm-5 col-md col-lg col-xl&quot;<br>      label=&quot;Nome&quot;<br>      label-color=&quot;dark&quot;<br>      :rules=&quot;[(val) =&gt; !!val || &#39;Nome é obrigatório&#39;]&quot;<br>    /&gt;<br><br>    &lt;q-input<br>      disable<br>      square<br>      filled<br>      dense<br>      v-model=&quot;price&quot;<br>      class=&quot;col-xs-12 col-sm-5 col-md col-lg col-xl&quot;<br>      label=&quot;Preço&quot;<br>      label-color=&quot;dark&quot;<br>      :rules=&quot;[(val) =&gt; !!val || &#39;Preço é obrigatório&#39;]&quot;<br>    /&gt;<br><br>    &lt;q-btn<br>      class=&quot;col-xs-12 col-sm-5 col-md col-lg col-xl&quot;<br>      type=&quot;submit&quot;<br>      color=&quot;secondary&quot;<br>      text-color=&quot;white&quot;<br>      rounded<br>      label=&quot;Criar&quot;<br>      no-caps<br>      @click=&quot;monitorCreateProductClick&quot;<br>    /&gt;<br>  &lt;/q-form&gt;<br>&lt;/template&gt;</pre><h3>Consultas</h3><p>Busca os botões clicados por página na última semana:</p><pre>SELECT button, page, username, branch, company, department, timestamp FROM PageAction WHERE actionName = &#39;Clique de botão&#39; SINCE 1 week ago</pre><p>Busca o tempo máximo de execução de uma função por dia:</p><pre>SELECT max(duration) FROM PageAction WHERE appId = 594490248 SINCE 1 week AGO FACET actionName TIMESERIES 1 day</pre><p>Busca a quantidade de cliques por botão:</p><pre>SELECT count(*) FROM PageAction WHERE actionName = &#39;Clique de botão&#39; SINCE 1 week ago FACET button, username</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6dc6ed1990d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conexão entre frontend e servidor gRPC]]></title>
            <link>https://medium.com/@araujo_89059/conex%C3%A3o-entre-frontend-e-servidor-grpc-9815f8d6155c?source=rss-89d5a2cdae47------2</link>
            <guid isPermaLink="false">https://medium.com/p/9815f8d6155c</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[grpc]]></category>
            <category><![CDATA[vuejs]]></category>
            <dc:creator><![CDATA[Oops Telecom]]></dc:creator>
            <pubDate>Wed, 26 Jun 2024 16:36:40 GMT</pubDate>
            <atom:updated>2024-06-26T16:36:40.774Z</atom:updated>
            <content:encoded><![CDATA[<p>No seguinte artigo será mostrado como realizar a conexão entre uma aplicação Vue.js e um servidor gRPC.</p><blockquote>Escrito por <a href="https://medium.com/u/8aca91f021a1">Lessaapolinario</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nDvtt3g97ShmPHX5mljlnA.jpeg" /><figcaption>Imagem retirada de <a href="https://blog.postman.com/what-is-grpc/">https://blog.postman.com/what-is-grpc/</a></figcaption></figure><p>A conexão entre o frontend e o servidor gRPC é uma parte crucial de muitos sistemas modernos de software. gRPC é um protocolo de chamada de procedimento remoto (RPC) de alto desempenho que pode rodar em qualquer ambiente. Ele permite a comunicação entre o frontend e o servidor, fazendo com que eles trabalhem em conjunto para realizar operações complexas.</p><h3>Tecnologias usadas 🖥️</h3><ul><li><a href="https://vuejs.org/">Vue.js</a></li><li><a href="https://quasar.dev/">Quasar</a></li><li><a href="https://www.typescriptlang.org/">TypeScript</a></li><li><a href="https://pinia.vuejs.org/">Pinia</a></li><li><a href="https://www.envoyproxy.io/docs">envoy</a></li></ul><p><em>O </em><a href="https://www.envoyproxy.io/docs"><em>envoy</em></a><em> é um proxy usado para intermediar a comunicação entre o frontend e o servidor gRPC, já que não é possível se comunicar diretamente.<br>O </em><a href="https://pinia.vuejs.org/"><em>Pinia</em></a><em> é um gerenciador de estado para aplicações frontend escritas em </em><a href="https://vuejs.org/"><em>Vue.js</em></a><em>.</em></p><h3>Configuração do proxy 🌐</h3><p>Ferramentas necessárias:</p><ul><li><a href="https://www.envoyproxy.io/docs">envoy</a></li><li><a href="https://www.docker.com/">Docker</a></li><li><a href="https://docs.docker.com/compose/">Docker Compose</a></li></ul><p>Arquivo de configuração do <a href="https://www.envoyproxy.io/docs">envoy</a>:</p><pre># Este arquivo serve para criar o proxy do envoy<br># admin é o painel de logs do envoy, que é uma página servida na porta 9901<br>admin:<br>  access_log_path: /dev/stdout<br>  address:<br>    socket_address: { address: 0.0.0.0, port_value: 9901 }<br># Esta seção define os recursos estáticos do Envoy (ouvintes e clusters).<br>static_resources:<br> # Define os ouvintes do Envoy, que escutam conexões de entrada.<br> # Foi configurado com o nome listener_0.<br> # Ouve em todas as interfaces de rede (0.0.0.0) na porta 8000.<br> # Utiliza um filtro HTTP (envoy.filters.network.http_connection_manager)<br> # para processar as solicitações HTTP recebidas.<br>  listeners:<br>    - name: listener_0<br>      address:<br>        socket_address: { address: 0.0.0.0, port_value: 8000 }<br>      filter_chains:<br>        - filters:<br>            - name: envoy.filters.network.http_connection_manager<br>              typed_config:<br>                &#39;@type&#39;: type.googleapis.com/envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager<br>                codec_type: auto<br>                stat_prefix: ingress_http<br>                route_config:<br>                  name: local_route<br>                  virtual_hosts:<br>                    - name: local_service<br>                      domains: [&#39;*&#39;]<br>                      routes:<br>                        - match: { prefix: &#39;/&#39; }<br>                          route:<br>                            cluster: data_service<br>                            max_grpc_timeout: 0s<br>                      cors:<br>                        allow_origin_string_match:<br>                          - safe_regex:<br>                              google_re2: {}<br>                              regex: &#39;.*&#39;<br>                        allow_methods: &#39;GET, PUT, DELETE, POST, OPTIONS&#39;<br>                        allow_headers: &#39;keep-alive,user-agent,cache-control,content-type,content-transfer-encoding,custom-header-1,x-accept-content-transfer-encoding,x-accept-response-streaming,x-user-agent,x-grpc-web,grpc-timeout&#39;<br>                        max_age: &#39;1728000&#39;<br>                        expose_headers: &#39;custom-header-1,grpc-status,grpc-message&#39;<br>                http_filters:<br>                  - name: envoy.filters.http.grpc_web<br>                  - name: envoy.filters.http.cors<br>                  - name: envoy.filters.http.router<br>  # **Esta seção define os clusters de serviços para os quais o<br>  # Envoy roteará solicitações.<br>  # O nome do cluster é &#39;data_service&#39;.**<br>  # A configuração de porta e nome do host de data_service esta em &#39;address&#39;<br>  clusters:<br>    - name: data_service<br>      connect_timeout: 0.25s<br>      type: logical_dns<br>      http2_protocol_options: {}<br>      lb_policy: round_robin<br>      load_assignment:<br>        cluster_name: data_service<br>        endpoints:<br>          - lb_endpoints:<br>              - endpoint:<br>                  address:<br>                    socket_address:<br>                      address: ${SERVER_NAME}<br>                      port_value: ${SERVER_PORT}</pre><p>Script para iniciar o envoy e carregar as variáveis de ambiente:</p><pre>#!/bin/bash<br><br># ATENÇÃO: Este script só deve ser executado no Dockerfile<br># substituir as env vars de /etc/envoy/envoy.yaml e salva em /tmp/envoy.yaml<br>envsubst &lt; /etc/envoy/envoy.yaml &gt; /tmp/envoy.yaml<br># Inicia o envoy com o arquivo de configuração gerado<br>exec /usr/local/bin/envoy -c /tmp/envoy.yaml -l trace --log-path /dev/stdout</pre><p><strong>Configuração do </strong><a href="https://docs.docker.com/reference/dockerfile/"><strong>Dockerfile</strong></a><strong>:</strong></p><pre>FROM envoyproxy/envoy:v1.15.0<br><br># pacotes necessários para carregar as env vars<br>RUN apt-get update &amp;&amp; apt-get install -y gettext-base<br># copia o arquivo de configuração do envoy para o container<br>COPY envoy.yaml /etc/envoy/envoy.yaml<br># libera as permissões para rodar o script<br>RUN chmod -R 777 /etc/envoy<br># copia o script que inicia o envoy<br>COPY start.sh /usr/local/bin/start.sh<br># libera as permissões do scritp que inicia o envoy<br>RUN chmod +x /usr/local/bin/start.sh<br># roda o script que inicia o envoy<br>CMD [&quot;/usr/local/bin/start.sh&quot;]</pre><p><strong>Configuração do </strong><a href="https://docs.docker.com/compose/"><strong>Docker Compose</strong></a><strong>:</strong></p><pre>version: &#39;3.7&#39;<br>services:<br>  envoy:<br>    build:<br>      context: .<br>      dockerfile: Dockerfile<br>    ports:<br>	    # A porta 8000 serve o envoy<br>      - &quot;8000:8000&quot;<br>      # A porta 9901 serve o admin do envoy<br>      - &quot;9901:9901&quot;<br>    restart: always<br>	   # carrega as variáveis de ambiente desse arquivo<br>    env_file:<br>      - .env</pre><h3>Configuração do frontend 🌅</h3><p>Ferramentas necessárias:</p><ul><li><a href="https://vuejs.org/">Vue.js</a></li><li><a href="https://quasar.dev/">Quasar</a></li><li><a href="https://www.typescriptlang.org/">TypeScript</a></li><li><a href="https://pinia.vuejs.org/">Pinia</a></li><li><a href="https://grpc.io/docs/protoc-installation/">Protocol Buffer Compiler</a></li></ul><p>Crie um projeto quasar:</p><pre>yarn create quasar</pre><p>Instale as dependências do package.json:</p><pre>yarn</pre><p>Instale os pacotes do gRPC:</p><pre>yarn add google-protobuf grpc-web protoc-gen-grpc-web</pre><p>⚠️ ATENÇÃO ⚠️: antes de gerar o arquivos do cliente gRPC tenha o arquivo .proto que é mesmo presente no backend do servidor gRPC.</p><p><strong><em>src/helpers/utils/proto/data.proto:</em></strong></p><pre>syntax = &quot;proto3&quot;;<br><br>option go_package = &quot;/&quot;;<br><br>message Empty {}<br><br>message DataResponse {<br>  int32 quantity = 1;<br>  string name = 2;<br>}<br><br>message DataResponseArray {<br>  repeated DataResponse response = 1;<br>}<br><br>service DataService {<br>  rpc GetData(Empty) returns (stream DataResponseArray) {}<br>}</pre><p>⚠️ ATENÇÃO ⚠️: antes de iniciar tenha certeza de ter insnstado o protoc conforme a documentação do <a href="https://grpc.io/docs/protoc-installation/">Protocol Buffer Compiler</a>.</p><p>Esta ferramenta é necessária para gerar o cliente gRPC, que são os arquivos JavaScript para realizar a comunicação com o proxy <a href="https://www.envoyproxy.io/docs">envoy</a>.</p><p>Script utilizado para gerar os clientes gRPC (arquivos .js):</p><pre>#!/bin/bash<br><br>PROTO_LOCATION=&quot;./src/helpers/utils/proto/data.proto&quot;<br>PROTO_PATH=&quot;./src/helpers/utils/proto&quot;<br>OUT_DIR_JS=&quot;./src/helpers/utils/proto/generated/data&quot;<br>clear<br>echo &quot;Removendo arquivos do proto!&quot;<br>rm -rf $OUT_DIR_JS/*<br>echo &quot;Gerando arquivos do proto!&quot;<br>protoc -I=$PROTO_PATH $PROTO_LOCATION  \\<br>  --plugin=protoc-gen-grpc-web=./node_modules/.bin/protoc-gen-grpc-web \\<br>  --js_out=import_style=commonjs,binary:$OUT_DIR_JS \\<br>  --grpc-web_out=import_style=commonjs,mode=grpcwebtext:$OUT_DIR_JS<br>echo &quot;Finalizado...&quot;</pre><p>Cliente gRPC gerado (arquivos JavaScript) 🧑‍💻:</p><ul><li><strong>src/helpers/utils/proto/generated/data/data_grpc_web_pb.js</strong>:</li><li>Este arquivo é gerado automaticamente e é utilizado para o cliente gRPC compatível com gRPC-Web.</li><li><strong>src/helpers/utils/proto/generated/data/data_pb.js</strong>:</li><li>Este arquivo é gerado automaticamente e contém as definições de mensagens protobuf (Protocol Buffers) geradas a partir do arquivo .proto fornecido.</li></ul><p>⚠️ ATENÇÃO ⚠️: antes consumir os dados no frontend, tenha certeza de que o servidor gRPC está funcionando e que o proxy esteja sendo servido.</p><p>Execute o container do envoy:</p><pre>docker compose up --build</pre><p>No presente documento subtende-se que o servidor gRPC está online ou está rodando localmente em sua máquina. 🤷‍♂️</p><p>Agora, iremos criar a store do pinia com a função que busca os dados:</p><pre>actions: {<br>  // Ação para obter dados do serviço gRPC<br>  getData() {<br>    try {<br>      // Instanciando o cliente gRPC para se comunicar com o serviço gRPC<br>      const client = new DataServiceClient(&#39;&lt;http://localhost:8000&gt;&#39;);<br><br>      // Criando uma mensagem vazia para enviar como requisição ao servidor<br>      const emptyRequest = new Empty();<br>      // Fazendo uma chamada gRPC para o servidor, obtendo um stream de dados<br>      const stream = client.getData(emptyRequest, {});<br>      // Adicionando um evento &#39;data&#39; para processar os dados recebidos do servidor<br>      stream.on(&#39;data&#39;, (response) =&gt; {<br>        // Convertendo a resposta do servidor para um array de dados<br>        const dataArray = response.getResponseList();<br>        // Mapeando os dados recebidos para o formato desejado e armazenando-os no estado da store<br>        const metricsData = dataArray.map((item) =&gt; ({<br>          quantity: item.getQuantity(),<br>          name: item.getName(),<br>        }));<br>        // Atualizando o estado da store com os dados recebidos<br>        this.metricsData = metricsData;<br>      });<br>      // Adicionando um evento &#39;error&#39; para lidar com erros durante a transmissão de dados<br>      stream.on(&#39;error&#39;, (err) =&gt; {<br>        console.error(&#39;Error receiving data:&#39;, err);<br>      });<br>      // Adicionando um evento &#39;end&#39; para lidar com o término da transmissão de dados<br>      stream.on(&#39;end&#39;, () =&gt; {<br>        console.log(&#39;Stream ended&#39;);<br>      });<br>    } catch (error) {<br>      // Capturando e registrando erros que ocorreram durante a execução da função<br>      console.error(&quot;Erro em &#39;getData&#39;&quot;, error);<br>    }<br>  },<br>},</pre><p>Abaixo serão mostrados os compoentes usados para consumir os dados de getData:</p><p><strong><em>src/components/metrics/MetricsDataComponent.vue:</em></strong></p><pre>&lt;script setup lang=&quot;ts&quot;&gt;<br>import { computed, ref, watch } from &#39;vue&#39;;<br><br>interface MetricsDataComponentProps {<br>  quantity?: number;<br>  name?: string;<br>  isFocused?: boolean;<br>}<br><br>const emit = defineEmits([&#39;set-focus&#39;, &#39;clear-focus&#39;]);<br>const props = withDefaults(defineProps&lt;MetricsDataComponentProps&gt;(), {<br>  quantity: 0,<br>  name: &#39;&#39;,<br>  isFocused: false,<br>});<br><br>const isInFocus = ref(false);<br><br>const formattedQuantity = computed(() =&gt; {<br>  if (props.quantity % 1000 === 0) {<br>    return `${props.quantity / 1000} Mil`;<br>  }<br>  return props.quantity;<br>});<br><br>const toggleCardFocus = () =&gt; {<br>  if (isInFocus.value) {<br>    emit(&#39;clear-focus&#39;);<br>  } else {<br>    emit(&#39;set-focus&#39;, props.name);<br>  }<br>};<br><br>watch(<br>  () =&gt; props.isFocused,<br>  (newVal) =&gt; {<br>    isInFocus.value = newVal;<br>  }<br>);<br>&lt;/script&gt;<br><br>&lt;template&gt;<br>  &lt;div<br>    @click.stop=&quot;toggleCardFocus&quot;<br>    :class=&quot;{ &#39;bg-tertiary&#39;: isInFocus, &#39; bg-secondary&#39;: !isInFocus }&quot;<br>    class=&quot;metrics-card row text-white rounded-borders cursor-pointer q-pa-sm col-xs-12 col-sm-4 col-md-3 col-lg col-xl&quot;<br>  &gt;<br>    &lt;div class=&quot;row items-center justify-between col-12&quot;&gt;<br>      &lt;div class=&quot;text-subtitle1 text-bold text-center no-margin no-padding&quot;&gt;<br>        {{ name }}<br>      &lt;/div&gt;<br>      &lt;div class=&quot;row flex-center q-gutter-xs no-margin no-padding&quot;&gt;<br>        &lt;q-btn outline size=&quot;xs&quot; color=&quot;white&quot; icon=&quot;settings&quot; /&gt;<br>        &lt;q-btn outline size=&quot;xs&quot; color=&quot;white&quot; icon=&quot;menu&quot; /&gt;<br>      &lt;/div&gt;<br>    &lt;/div&gt;<br>    &lt;div class=&quot;col-12 text-h4 text-bold text-center q-pa-sm&quot;&gt;<br>      {{ formattedQuantity }}<br>    &lt;/div&gt;<br>  &lt;/div&gt;<br>&lt;/template&gt;</pre><p><strong><em>src/pages/Indexpage.vue:</em></strong></p><pre>&lt;script setup lang=&quot;ts&quot;&gt;<br>import { computed, onBeforeUnmount, onMounted, onUnmounted, ref } from &#39;vue&#39;;import MetricsDataComponent from &#39;src/components/metrics/MetricsDataComponent.vue&#39;;<br><br>import { useDataStore } from &#39;src/stores/data&#39;;<br><br>const dataStore = useDataStore();<br><br>const focusedCard = ref&lt;string | null&gt;(null);<br><br>const metricsData = computed({<br>  get() {<br>    return dataStore.getMetricsData;<br>  },<br>  set(newMetricsData) {<br>    dataStore.metricsData = newMetricsData;<br>  },<br>});<br><br>const setFocus = (name: string) =&gt; {<br>  focusedCard.value = name;<br>};<br><br>const clearFocus = () =&gt; {<br>  focusedCard.value = null;<br>};<br><br>const handleClickOutside = (event: MouseEvent) =&gt; {<br>  const target = event.target as HTMLElement;<br>  if (target.closest(&#39;.metrics-card&#39;) === null) {<br>    clearFocus();<br>  }<br>};<br><br>onMounted(() =&gt; {<br>  dataStore.getData();<br>  document.addEventListener(&#39;click&#39;, handleClickOutside);<br>});<br><br>onBeforeUnmount(() =&gt; {<br>  document.removeEventListener(&#39;click&#39;, handleClickOutside);<br>});<br><br>onUnmounted(() =&gt; {<br>  dataStore.metricsData = [];<br>});<br>&lt;/script&gt;<br><br>&lt;template&gt;<br>  &lt;q-page padding class=&quot;bg-primary text-white&quot;&gt;<br>    &lt;div class=&quot;text-h4 text-bold q-mx-none q-mt-none q-mb-md no-padding&quot;&gt;<br>      Visão Geral<br>    &lt;/div&gt;<br>    &lt;div class=&quot;row items-center justify-start q-gutter-sm fit&quot;&gt;<br>      &lt;MetricsDataComponent<br>        v-for=&quot;item in metricsData&quot;<br>        :key=&quot;item.name&quot;<br>        :quantity=&quot;item.quantity&quot;<br>        :name=&quot;item.name&quot;<br>        :isFocused=&quot;focusedCard === item.name&quot;<br>        @set-focus=&quot;setFocus&quot;<br>        @clear-focus=&quot;clearFocus&quot;<br>      /&gt;<br>    &lt;/div&gt;<br>  &lt;/q-page&gt;<br>&lt;/template&gt;<br></pre><h3>Fim 🤓📕</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9815f8d6155c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando um chat realtime com Evolution API, WhatsApp e modelos de inteligência artificial]]></title>
            <link>https://medium.com/@araujo_89059/implementando-um-chat-realtime-com-evolution-api-whatsapp-e-modelos-de-intelig%C3%AAncia-artificial-95ba13092c82?source=rss-89d5a2cdae47------2</link>
            <guid isPermaLink="false">https://medium.com/p/95ba13092c82</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Oops Telecom]]></dc:creator>
            <pubDate>Wed, 26 Jun 2024 14:58:54 GMT</pubDate>
            <atom:updated>2024-06-26T16:35:57.845Z</atom:updated>
            <content:encoded><![CDATA[<p>No presente documento será exemplificado como integrar o WhatsApp através da Evolution API com um webhook que vai receber uma pergunta e retornar uma resposta a partir de um LLM (Large Language Model)</p><blockquote>Escrito por <a href="https://medium.com/u/8aca91f021a1">Lessaapolinario</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AlObyQUjmIsBoVk-TtoMZg.png" /><figcaption>Imagem obtida em <a href="https://ats.net/en/focus-ai-artificial-intelligence-and-the-new-doomsday-machine/">https://ats.net/en/focus-ai-artificial-intelligence-and-the-new-doomsday-machine/</a></figcaption></figure><h4>Configurando o webhook em Python</h4><blockquote>A Evolution API é uma aplicação que pode controlar funções do WhatsApp</blockquote><blockquote>“Webhook é um recurso que possibilita a comunicação entre duas ferramentas, fornecendo dados em tempo real sempre que um evento acontecer. Desta forma os dois aplicativos realizam troca de informações instantaneamente sem que nenhuma ação externa precise ser realizada.” — <a href="https://pluga.co/blog/webhook/">https://pluga.co/blog/webhook/</a></blockquote><blockquote>“Traduzido do inglês-Groq, Inc. é uma empresa americana de inteligência artificial que constrói um circuito integrado específico para aplicativos aceleradores de IA que eles chamam de Unidade de Processamento de Linguagem e hardware relacionado para acelerar o desempenho de inferência de cargas de trabalho de IA” — <a href="https://en.wikipedia.org/wiki/Groq">https://en.wikipedia.org/wiki/Groq</a></blockquote><p><strong>requirements.txt (arquivo de dependências)</strong></p><pre>groq<br>pandas<br>openpyxl<br>fastapi<br>python-dotenv<br>uvicorn<br>sentence-transformers</pre><p>— — — — — — — — — — — — — — — — — — — — — — — — — — —</p><p><strong>llm.py (arquivo de manipulação dos modelos de IA)</strong></p><pre>from typing import Generator, Any<br>from sentence_transformers import SentenceTransformer, util<br>from groq import Groq<br>import pandas as pd<br>import os<br>from dotenv import load_dotenv<br><br>load_dotenv()<br><br>excel_file_path = &#39;assets/Perguntas e Respostas OOPS.xlsx&#39;<br>qa_df = pd.read_excel(excel_file_path)<br><br>def get_models() -&gt; dict[str, dict[str, Any]]:<br>    return {<br>        &quot;gemma-7b-it&quot;: {&quot;name&quot;: &quot;Gemma-7b-it&quot;, &quot;tokens&quot;: 8192, &quot;developer&quot;: &quot;Google&quot;},<br>        &quot;llama3-70b-8192&quot;: {&quot;name&quot;: &quot;LLaMA3-70b-8192&quot;, &quot;tokens&quot;: 8192, &quot;developer&quot;: &quot;Meta&quot;},<br>        &quot;llama3-8b-8192&quot;: {&quot;name&quot;: &quot;LLaMA3-8b-8192&quot;, &quot;tokens&quot;: 8192, &quot;developer&quot;: &quot;Meta&quot;},<br>        &quot;mixtral-8x7b-32768&quot;: {&quot;name&quot;: &quot;Mixtral-8x7b-Instruct-v0.1&quot;, &quot;tokens&quot;: 32768, &quot;developer&quot;: &quot;Mistral&quot;},<br>    }<br><br>def get_models_options() -&gt; list[str]:<br>    models = get_models()<br>    return list(models.keys())<br><br>embedding_model = SentenceTransformer(&#39;paraphrase-multilingual-MiniLM-L12-v2&#39;)<br><br>qa_df[&#39;embedding&#39;] = qa_df[&#39;Pergunta&#39;].apply(lambda x: embedding_model.encode(x, convert_to_tensor=True))<br><br>def get_groq_client() -&gt; Groq:<br>    &quot;&quot;&quot;Returns an instance of the Groq client.&quot;&quot;&quot;<br>    return Groq(api_key=os.getenv(&quot;GROQ_API_KEY&quot;))<br><br><br>def retrieve_relevant_answer(question: str) -&gt; str:<br>    &quot;&quot;&quot;Retrieve the most relevant answer from the dataframe based on the question.&quot;&quot;&quot;<br>    question_embedding = embedding_model.encode(question, convert_to_tensor=True)<br>    similarities = qa_df[&#39;embedding&#39;].apply(lambda x: util.pytorch_cos_sim(x, question_embedding).item())<br>    best_match_idx = similarities.idxmax()<br>    best_match = qa_df.loc[best_match_idx]<br>    return best_match[&quot;Resposta&quot;]<br><br>def generate_chat_responses(chat_completion) -&gt; Generator[str, None, None]:<br>    &quot;&quot;&quot;Yield chat response content from the Groq API response.&quot;&quot;&quot;<br>    for chunk in chat_completion:<br>        if chunk.choices[0].delta.content:<br>            yield chunk.choices[0].delta.content<br><br><br>def get_final_response(question: str, max_tokens: int = 32768, model_option: str = &quot;mixtral-8x7b-32768&quot;) -&gt; str:<br>    &quot;&quot;&quot;Retrieve the final response from the LLM given a question.&quot;&quot;&quot;<br>    relevant_answer = retrieve_relevant_answer(question)<br>    augmented_prompt = (f&quot;Pergunta: &#39;{question}&#39;\n&quot;<br>                        f&quot;Caso a pergunta e resposta relevante abaixo faça sentido em relação à pergunta, use-a. Caso contrário, ignore-a e não fale sobre ela, nem para citar que não faz sentido, em seguida respoda a pergunta do usuário diretamente.\n&quot;<br>                        f&quot;Resposta relevante: {relevant_answer}\n&quot;<br>                        f&quot;Elabore um pouco mais a resposta\n&quot;<br>                        f&quot;Responda sempre em português\n&quot;<br>                        f&quot;Formate a resposta para ficar o mais legivel possivel, usando a pontuação e tudo mais.\n&quot;<br>                        f&quot;Resposta final:&quot;)<br><br>    client = get_groq_client()<br>    chat_completion = client.chat.completions.create(<br>        model=model_option,<br>        messages=[<br>            {&quot;role&quot;: &quot;system&quot;, &quot;content&quot;: &quot;Você é um assistente de IA em uma empresa de internet chamada Oops (é nome, não uma sigla) Telecom.&quot;},<br>            {&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: augmented_prompt}<br>        ],<br>        max_tokens=max_tokens,<br>        stream=True<br>    )<br><br>    full_response = &quot;&quot;.join(list(generate_chat_responses(chat_completion)))<br>    return full_response</pre><p><strong>Explicação:<br></strong>A função <strong><em>get_models</em></strong> retorna os modelos de <strong><em>IA</em></strong> disponíveis pelo <strong>groq</strong> para o tipo de conta usada.<br>A função <strong><em>get_models_options</em></strong> é usada apenas pega pegas as chaves do dicionário que contém os modelos de <strong><em>IA</em></strong>, nesse cenário não é usada.<br>A função <strong><em>get_groq_client</em></strong> é usada para retornar o client para se comunicar com <strong>groq</strong>.<br>A função <strong><em>retrieve_relevant_answer</em></strong> busca uma resposta relevante baseada numa questão.<br>A função <strong><em>generate_chat_responses</em></strong> monta a resposta a ser enviada.<br>A função <strong><em>get_final_response</em></strong> é responsável por usar o modelo de <strong><em>IA</em></strong> para retornar um texto com a resposta final a partir de um prompt</p><p><strong>.env.example (arquivo de exemplo das variáveis de ambiente)</strong></p><pre># evolution api<br>EVOLUTION_API_URL=&quot;&quot;<br>EVOLUTION_API_KEY=&quot;&quot;<br>EVOLUTION_API_INSTANCE=&quot;&quot;<br><br># groq<br>GROQ_API_KEY=&quot;&quot;</pre><p><strong>main.py (arquivo onde o webhook será executado)</strong></p><pre>from fastapi import FastAPI, Request<br>from llm import get_final_response<br>import requests<br>import os<br>import json<br>from dotenv import load_dotenv<br><br>load_dotenv()<br><br>app = FastAPI()<br><br>@app.get(&#39;/&#39;)<br>async def root():<br>    return {&quot;message&quot;: &quot;página inicial&quot;}<br><br>@app.post(&#39;/webhook&#39;)<br>async def webhook(request: Request):<br>    body = await request.body()<br>    json_body = json.loads(body)<br><br>    try:<br>        message = None<br>        if &quot;extendedTextMessage&quot; in json_body[&quot;data&quot;][&quot;message&quot;]:<br>            message = json_body[&quot;data&quot;][&quot;message&quot;][&quot;extendedTextMessage&quot;][&quot;text&quot;]<br>        elif &quot;conversation&quot; in json_body[&quot;data&quot;][&quot;message&quot;]:<br>            message = json_body[&quot;data&quot;][&quot;message&quot;][&quot;conversation&quot;]<br>        else:<br>            return {&quot;status&quot;: &quot;error&quot;, &quot;message&quot;: &quot;Chave &#39;message&#39; não contém &#39;extendedTextMessage&#39; ou &#39;conversation&#39;&quot;}, 400<br><br>        sender = json_body[&quot;data&quot;][&quot;key&quot;][&quot;remoteJid&quot;]<br>        isMessageFromMe = json_body[&quot;data&quot;][&quot;key&quot;][&quot;fromMe&quot;]<br> <br>        if not isMessageFromMe:<br>            answer = get_final_response(message)<br>            send_response_to_whatsapp(sender, answer)<br><br>        return {&quot;status&quot;: &quot;success&quot;}<br>    except KeyError as e:<br>        print(f&quot;KeyError: {e}&quot;)<br>        return {&quot;status&quot;: &quot;error&quot;, &quot;message&quot;: e}, 400<br>    except Exception as e:<br>        print(f&quot;ERROR = {e}&quot;)<br>        return {&quot;status&quot;: &quot;error&quot;, &quot;message&quot;: e}, 500<br><br>def send_response_to_whatsapp(phone, message):<br>    evolution_api_url = os.getenv(&quot;EVOLUTION_API_URL&quot;)<br>    evolution_api_instance = os.getenv(&quot;EVOLUTION_API_INSTANCE&quot;)<br>    evolution_api_key = os.getenv(&quot;EVOLUTION_API_KEY&quot;)<br><br>    route = f&quot;{evolution_api_url}/message/sendText/{evolution_api_instance}&quot;<br>    headers = {<br>        &#39;Content-Type&#39;: &#39;application/json&#39;,<br>        &#39;apikey&#39;: evolution_api_key<br>    }<br>    payload = {<br>        &quot;number&quot;: phone,<br>        &quot;textMessage&quot;: {<br>            &quot;text&quot;: message<br>        }<br>    }<br>    response = requests.post(route, json=payload, headers=headers)<br>    return response.json()</pre><p><strong>Explicação:<br></strong>O endpoint <strong>/webhook</strong> é responsável por receber uma mensagem do <strong>WhatsApp</strong> via <strong>Evolution API</strong> e retornar a resposta processada pelo LLM.<br>A função <strong><em>send_response_to_whatsapp</em></strong> chama um endpoint da <strong>Evolution API</strong> para mandar uma mensagem para o <strong>WhatsApp</strong> com a resposta relevante.</p><h4><strong>Como configurar o webhook no painel da Evolution API</strong></h4><p>Para criar uma instância clica no botão azul.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/153/1*U96fvfFhVwr3b7y65dcq8Q.png" /></figure><p>Vai aparecer um formulário para preencher o nome da instância.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/505/1*trKO3e-8bTbEle9PnpFrVA.png" /></figure><p>Depois é só clicar e conectar e escanear o QR code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GIIpGz-FGdttZu6WAmBMUw.png" /></figure><p>Depois escolhemos o serviço a se conectar, nesse caso o webhook.<br>Basta colocar a url do webhook e o endpoint que a Evolution API vai usar para mandar a pergunta e receber a resposta. Além disso é preciso escolher qual o evento que será necessário ser acionado para chamar o webhook, nesse caso aquele quando uma mensagem chegar <strong>(MESSAGES_UPSERT</strong>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XsT9fiOo7kjovHcrFRuhuA.png" /></figure><p>Após isso é só mandar uma mensagem para o número conectado e a resposta será enviada.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95ba13092c82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Criação do Servidor gRPC em GO]]></title>
            <link>https://medium.com/@araujo_89059/cria%C3%A7%C3%A3o-do-servidor-grpc-em-go-c7e7121fc5d4?source=rss-89d5a2cdae47------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7e7121fc5d4</guid>
            <category><![CDATA[grpc]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Oops Telecom]]></dc:creator>
            <pubDate>Wed, 26 Jun 2024 13:11:44 GMT</pubDate>
            <atom:updated>2024-06-26T13:19:03.532Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Escrito por <a href="https://github.com/micledson">Micledson Carlos</a></blockquote><figure><img alt="Imagem com o mascote do go, Golpher, olhando para a sigla ‘gRPC’" src="https://cdn-images-1.medium.com/max/744/1*UrRfgy_QViFhqXt2ESmfLw.png" /><figcaption>Imagem obtida em <a href="https://crypto-gopher.medium.com/golang-writing-an-effective-application-using-grpc-grpc-gateway-24791ff93ffe">Learn how to use gRPC + REST in your Go application in 3 minutes! | by Gopher | Medium</a></figcaption></figure><h3>Por que escolher gRPC em vez de REST?</h3><p>Para este projeto, precisávamos de informações em tempo real. O gRPC oferece funcionalidades que são perfeitas para essa necessidade, especialmente os <strong>streams</strong>. Com streams, o servidor pode enviar múltiplas atualizações ao cliente sem a necessidade de novas requisições por parte do frontend.</p><h3>Comparação: gRPC x REST</h3><p><strong>REST</strong>:</p><ul><li><strong>Protocolo</strong>: Utiliza HTTP/1.1.</li><li><strong>Modelo de Comunicação</strong>: Baseado no modelo cliente-servidor tradicional. O cliente faz uma requisição, o servidor responde e a conexão é fechada.</li><li><strong>Formato de Dados</strong>: Normalmente usa JSON para a troca de dados. JSON é fácil de ler, mas pode ser menos eficiente em termos de desempenho e tamanho de payload.</li><li><strong>Escalabilidade</strong>: Adequado para muitas aplicações web. No entanto, não é ideal para comunicações de baixa latência e alta frequência.</li><li><strong>Simplicidade</strong>: Muito simples e bem suportado, com uma curva de aprendizado mais baixa e fácil integração com muitos serviços e APIs.</li></ul><p><strong>gRPC</strong>:</p><ul><li><strong>Protocolo</strong>: Utiliza HTTP/2.</li><li><strong>Modelo de Comunicação</strong>: Suporta streams bidirecionais, permitindo que a conexão entre cliente e servidor permaneça aberta. Isso possibilita que o servidor envie dados adicionais a qualquer momento, sem a necessidade de o cliente fazer novas requisições.</li><li><strong>Formato de Dados</strong>: Usa Protocol Buffers (protobuf) para serialização de mensagens. Protobuf é altamente eficiente, resultando em menores tamanhos de payload e maior velocidade de processamento.</li><li><strong>Desempenho</strong>: Oferece melhor desempenho em comparação ao REST, especialmente para aplicações que exigem comunicação em tempo real. A multiplexação de HTTP/2 permite que múltiplas mensagens sejam enviadas simultaneamente sobre a mesma conexão.</li><li><strong>Flexibilidade</strong>: Ideal para aplicações que requerem comunicação eficiente e de baixa latência, como streaming de dados e serviços de backend com alta carga de dados.</li></ul><h3>Como os dados são atualizados?</h3><p>Para manter os dados atualizados, usamos gRPC com streams habilitados. Porém, precisamos de um mecanismo para monitorar mudanças nos dados. Para isso, escolhemos o <strong>Apache NiFi</strong>. O NiFi monitora o banco de dados e, ao detectar uma alteração, notifica nosso backend.</p><h3>Por que não fazer o frontend realizar requisições periódicas?</h3><p>Embora simples de implementar, fazer o frontend realizar requisições a cada x segundos não é a solução mais eficiente, especialmente em um cenário onde o banco de dados retorna mais de 100 mil linhas numa consulta.</p><p><strong>Desvantagens das Requisições Periódicas</strong>:</p><ul><li><strong>Sobrecarga do Servidor</strong>: Fazer requisições frequentes pode sobrecarregar o servidor. Com consultas que retornam 100 mil linhas, o servidor pode ser rapidamente sobrecarregado, resultando em custos elevados para manter a infraestrutura.</li><li><strong>Latência</strong>: Essa abordagem pode não ser eficiente para dados em tempo real, pois há um atraso inevitável entre as requisições.</li><li><strong>Consumo de Banda</strong>: Requisições frequentes aumentam o consumo de banda, especialmente ao transferir grandes volumes de dados.</li></ul><p><strong>Vantagens do gRPC com Apache NiFi</strong>:</p><ul><li><strong>Streams de Dados</strong>: Com o gRPC, você pode usar streams bidirecionais, permitindo que o servidor envie dados continuamente para o cliente sem fechar a conexão. Isso é ideal para dados em tempo real.</li><li><strong>Eficiência de Recursos</strong>: Apache NiFi monitora o banco de dados e notifica o backend somente quando há alterações, evitando consultas desnecessárias e sobrecarga do servidor.</li><li><strong>Desempenho</strong>: gRPC usa HTTP/2 e Protocol Buffers, resultando em menor latência e maior eficiência na transferência de dados, especialmente em grandes volumes.</li></ul><h3>Configurando programas</h3><p>Para começar, precisaremos baixar e instalar alguns programas essenciais para o funcionamento do nosso projeto:</p><ul><li><strong>Protoc</strong> (o gRPC precisa dele para gerar os arquivos) — <a href="https://github.com/protocolbuffers/protobuf/releases">Releases · protocolbuffers/protobuf (github.com)</a></li><li><strong>Golang</strong> — <a href="https://go.dev/doc/install">Download and install — The Go Programming Language</a></li><li><strong>Docker Desktop</strong> — <a href="https://www.docker.com/products/docker-desktop/">Docker Desktop: The #1 Containerization Tool for Developers | Docker</a></li></ul><p>Vamos utilizar a arquitetura hexagonal no nosso projeto.</p><h3>Arquitetura Hexagonal</h3><p>Na arquitetura hexagonal, o foco é desacoplar o código de domínio do código de infraestrutura. Isso permite que as regras de negócio sejam independentes da interface do usuário, banco de dados ou outras partes do sistema. Usamos interfaces para definir os contratos entre as diferentes camadas, facilitando a substituição ou alteração de componentes sem impactar o sistema como um todo.</p><h3>Pacotes adicionais</h3><pre># Instalação dos pacotes necessários para gRPC e Protocol Buffers<br>go get google.golang.org/grpc v1.64.0<br>go get google.golang.org/protobuf v1.34.1</pre><p>Esses arquivos são necessários para a compilação do protobuf. O protocolo buffers (protobuf) é uma linguagem neutra e independente de plataforma usada para serializar dados estruturados, similar ao XML ou JSON. No entanto, o protobuf é mais eficiente em termos de desempenho.</p><h3>Estrutura do Projeto</h3><p>A estrutura do projeto está organizada da seguinte forma:</p><figure><img alt="Imagem com a estrutura básica do projeto." src="https://cdn-images-1.medium.com/max/351/1*0kP_I1fQA_5gryGL_2ze2w.png" /><figcaption>Imagem com a estrutura básica do projeto.</figcaption></figure><p>Dentro da pasta <strong>config</strong>, temos algumas configurações essenciais para o projeto, incluindo os arquivos do Docker para subir o banco de dados, scripts SQL, e arquivos gRPC onde vamos armazenar os arquivos <strong>.proto</strong> e os arquivos gerados pelo <strong>protoc</strong>.</p><figure><img alt="Imagem contendo as pastas e arquivos que estão dentro da pasta ‘config’" src="https://cdn-images-1.medium.com/max/358/1*KnmGRcNBUxJW-cj3FaME0Q.png" /><figcaption>Imagem contendo as pastas e arquivos que estão dentro da pasta ‘config’</figcaption></figure><h3>Arquivo Dockerfile para PostgreSQL</h3><p>O Dockerfile abaixo é usado para criar uma imagem Docker personalizada do PostgreSQL, copiando os arquivos necessários e expondo a porta 5432.</p><pre>#postgres.Dockerfile</pre><pre>FROM postgres:13.2</pre><pre># Copia os arquivos para o diretório de trabalho no container<br>COPY . /mydata</pre><pre># Define o diretório de trabalho<br>WORKDIR /mydata</pre><pre># Expondo a porta 5432<br>EXPOSE 5432</pre><pre># Adiciona o script SQL de inicialização ao diretório do Docker<br>ADD ./sql/init_db.sql /docker-entrypoint-initdb.d</pre><h3>Arquivo docker-compose.yml</h3><p>O arquivo <strong>docker-compose.yml</strong> define os serviços necessários para subir o banco de dados PostgreSQL.</p><pre>#docker-compose.yml\</pre><pre>version: &#39;3&#39;</pre><pre>services:</pre><pre>  db:<br>    container_name: oops_telemetria_db<br>    build:<br>      dockerfile: ./docker/dockerfile/postgres.dockerfile<br>      context: &quot;../&quot;</pre><pre>    environment:<br>      - POSTGRES_USER=postgres<br>      - POSTGRES_PASSWORD=12345678<br>      - POSTGRES_DBNAME=oops_telemetria</pre><pre>    ports:<br>      - &quot;5432:5432&quot;</pre><pre>    networks:<br>      - oops_telemetria</pre><pre>networks:<br>  oops_telemetria:<br>    driver: bridge</pre><h3>Arquivos gRPC</h3><p>Na pasta <strong>grpc</strong>, temos as subpastas <strong>proto/</strong> e <strong>protobuf/</strong>. Os arquivos dentro de <strong>protobuf/</strong> são gerados automaticamente e não precisam ser modificados. Já os arquivos dentro de <strong>proto/</strong>, como o <strong>data.proto</strong>, são os arquivos onde definimos os métodos e parâmetros para as chamadas gRPC.</p><p>[Parágrafo Geral] Em gRPC, os arquivos <strong>.proto</strong> funcionam como contratos, onde tanto o servidor quanto o cliente devem ter acesso ao mesmo arquivo. Esses arquivos definem a estrutura das mensagens e os serviços, garantindo que ambos os lados da comunicação entendam e processem os dados de maneira consistente.</p><pre>#data.proto</pre><pre>syntax = &quot;proto3&quot;;</pre><pre><br>option go_package = &quot;/&quot;;</pre><pre>message Empty {}</pre><pre>message DataResponse {<br>  int32 quantity = 1;<br>  string name = 2;<br>}</pre><pre>message DataResponseArray {<br>  repeated DataResponse response = 1;<br>}</pre><pre>service DataService {<br>  rpc GetData(Empty) returns (stream DataResponseArray) {}<br>}</pre><p>Com os arquivos <strong>.proto</strong> criados, devemos executar o comando para o <strong>protoc</strong> gerar os arquivos que ficarão dentro da pasta <strong>protobuf/</strong>.</p><pre>protoc --proto_path=config/grpc/proto --go_out=config/grpc/protobuf --go-grpc_out=config/grpc/protobuf --go_opt=paths=import config/grpc/proto/*.proto --go-grpc_out=require_unimplemented_servers=false:.</pre><p><strong>⚠️ ATENÇÃO ⚠️:</strong> O comando deve ser executado na raiz do projeto.</p><h3>Arquivo main.go</h3><p>Vamos agora criar o arquivo <strong>main.go</strong>, onde estamos criando dois servidores: um gRPC, que é o principal, e um REST, visto que o Apache NiFi não consegue se comunicar via gRPC e precisamos de uma forma para receber essas atualizações.</p><pre>//main.go<br>package main<br>import (<br> &quot;fmt&quot;<br> &quot;github.com/joho/godotenv&quot;<br> &quot;google.golang.org/grpc&quot;<br> &quot;google.golang.org/grpc/reflection&quot;<br> &quot;log&quot;<br> &quot;net&quot;<br> &quot;net/http&quot;<br> &quot;oops.telemetria.com/app/endpoints/dicontainer&quot;<br> &quot;oops.telemetria.com/app/endpoints/routes&quot;<br> &quot;oops.telemetria.com/infrastructure/mysql&quot;<br> &quot;oops.telemetria.com/infrastructure/postgres&quot;<br>)<br>func main() {<br> Init()<br> PORT := os.Getenv(&quot;PORT&quot;)<br> HttpPort := os.Getenv(&quot;HTTP_PORT&quot;)<br> // Inicializa o servidor gRPC em uma goroutine<br> go func() {<br>  fmt.Println(&quot;PORT: &quot;, PORT)<br>  lis, err := net.Listen(&quot;tcp&quot;, fmt.Sprintf(&quot;0.0.0.0:%s&quot;, PORT))<br>  if err != nil {<br>   log.Fatalf(&quot;failed to listen: %v&quot;, err)<br>  }<br>  grpcServer := grpc.NewServer()<br>  routes.LoadRoutes(grpcServer)<br>  reflection.Register(grpcServer)<br>  log.Printf(&quot;Starting gRPC server on %s&quot;, fmt.Sprintf(&quot;0.0.0.0:%s&quot;, PORT))<br>  if err := grpcServer.Serve(lis); err != nil {<br>   log.Fatalf(&quot;failed to serve: %v&quot;, err)<br>  }<br> }()<br> // Inicializa o servidor HTTP em uma goroutine<br> go func() {<br>  httpServer := &amp;http.Server{<br>   Addr: fmt.Sprintf(&quot;0.0.0.0:%s&quot;, HttpPort),<br>  }<br>  dataHttp := dicontainer.GetDataHttp()<br>  http.HandleFunc(&quot;/data&quot;, dataHttp.GetHandler)<br>  // Adiciona middleware CORS<br>  http.HandleFunc(&quot;/&quot;, handleCORS(dataHttp.GetHandler))<br>  log.Printf(&quot;Starting HTTP server on %s&quot;, fmt.Sprintf(&quot;0.0.0.0:%s&quot;, HttpPort))<br>  if err := httpServer.ListenAndServe(); err != nil {<br>   log.Fatalf(&quot;failed to serve HTTP: %v&quot;, err)<br>  }<br> }()<br> // Impede a função main de terminar, mantendo os servidores em execução<br> select {}<br>}<br>// Middleware para habilitar CORS<br>func handleCORS(next http.HandlerFunc) http.HandlerFunc {<br> return func(w http.ResponseWriter, r *http.Request) {<br>  w.Header().Set(&quot;Access-Control-Allow-Origin&quot;, &quot;*&quot;)<br>  w.Header().Set(&quot;Access-Control-Allow-Headers&quot;, &quot;Content-Type&quot;)<br>  w.Header().Set(&quot;Access-Control-Allow-Methods&quot;, &quot;GET, POST, PUT, DELETE, OPTIONS&quot;)<br>  if r.Method != http.MethodOptions {<br>   next.ServeHTTP(w, r)<br>   return<br>  }<br>  w.WriteHeader(http.StatusOK)<br> }<br>}<br>// Função para inicializar variáveis de ambiente e configurações dos bancos de dados<br>func Init() {<br> err := godotenv.Load()<br> if err != nil {<br>  log.Fatalf(&quot;Error loading .env file&quot;)<br> }<br> mysql.SetUpCredentials()<br> postgres.SetUpCredentials()<br>}</pre><p>Vamos agora para a parte do handler da aplicacao, essa é a estrutura de pasta dela</p><p>O código acima cria dois servidores: um gRPC e um REST, ambos utilizando goroutines para que possam rodar simultaneamente. Sem as goroutines, um servidor bloquearia a execução do restante do código.</p><ul><li><strong>select {}</strong>: Impede que a função <strong>main</strong> termine, mantendo os servidores em execução. Como estamos usando goroutines, a função <strong>main</strong> precisa de algo que a mantenha viva, caso contrário, ela encerraria o programa após iniciar os servidores.</li><li><strong>Init()</strong>: Carrega as variáveis de ambiente do <strong>.env</strong> e realiza as configurações necessárias para os bancos de dados MySQL e PostgreSQL.</li><li><strong>routes.LoadRoutes(grpcServer)</strong>: Essa função é responsável por registrar os serviços gRPC que serão executados. No gRPC, não temos “endpoints” e “rotas” como no REST. Em vez disso, temos serviços e métodos definidos nos arquivos <strong>.proto</strong>.</li></ul><p>No gRPC, a comunicação é feita através de chamadas a métodos remotos definidos nos arquivos <strong>.proto</strong>. Esses arquivos definem os serviços e os métodos que podem ser chamados, garantindo uma interface clara e consistente para a comunicação entre cliente e servidor. Isso difere do REST, onde a comunicação é baseada em recursos e endpoints HTTP.</p><h3>Arquitetura do Handler</h3><p><strong>Estrutura de Pastas do Handler</strong></p><p>A seguir está a estrutura de pastas do nosso projeto de handlers:</p><figure><img alt="Imagem contendo as pastas e arquivos que estão dentro da pasta ‘app’" src="https://cdn-images-1.medium.com/max/335/1*AepeJmvGNvU8zGm7FK3Z-g.png" /><figcaption>Imagem contendo as pastas e arquivos que estão dentro da pasta ‘app’</figcaption></figure><pre>//routes.go<br>package routes<br>import (<br>   &quot;google.golang.org/grpc&quot;<br>   &quot;oops.telemetria.com/app/endpoints/dicontainer&quot;<br>   proto &quot;oops.telemetria.com/config/grpc/protobuf&quot;<br>)<br>// LoadRoutes carrega todas as rotas gRPC disponíveis no servidor<br>func LoadRoutes(server *grpc.Server) {<br>   loadData(server)<br>}<br>// loadData registra o serviço DataService no servidor gRPC<br>func loadData(s *grpc.Server) {<br>   dataHandlers := dicontainer.GetDataHandlers()<br>   proto.RegisterDataServiceServer(s, dataHandlers)<br>}</pre><p>No arquivo <strong>routes.go</strong>, estamos carregando todas as funções que pertencem ao DataHandler.</p><h3>Pasta dicontainer</h3><p>A pasta <strong>dicontainer</strong> é onde vamos deixar as funções para a injeção de dependência para as outras camadas, visto que na arquitetura hexagonal não fazemos uma chamada direta a uma função, mas sim usamos interfaces.</p><pre>//handler.go<br><br>package dicontainer<br><br>import (<br> &quot;oops.telemetria.com/app/endpoints/handlers&quot;<br> &quot;oops.telemetria.com/app/endpoints/handlers/data&quot;<br> &quot;oops.telemetria.com/infrastructure/postgres/interfaces&quot;<br>)<br><br>// broadcaster é uma instância compartilhada do Broadcaster<br>var broadcaster = handlers.NewBroadcaster()<br><br>// GetDataHandlers retorna um novo handler para Data gRPC<br>func GetDataHandlers() *data.Handlers {<br> postgresInterface := GetDataRepositoryPostgres().(interfaces.DataPostgres)<br> return data.NewDataHandler(GetDataServices(postgresInterface), broadcaster)<br>}<br><br>// GetDataHttp retorna um novo handler HTTP para Data<br>func GetDataHttp() *data.HTTPHandler {<br> return data.NewDataHTTPHandler(broadcaster)<br>}</pre><pre>//service.go<br><br>package dicontainer<br><br>import (<br> &quot;oops.telemetria.com/core/interfaces/primary&quot;<br> &quot;oops.telemetria.com/core/services&quot;<br> &quot;oops.telemetria.com/infrastructure/postgres/interfaces&quot;<br>)<br><br>// GetDataServices retorna um novo serviço de Data<br>func GetDataServices(postgresInterface interfaces.DataPostgres) primary.DataManager {<br> mysqlRepo := GetDataRepositoryMySQL(postgresInterface)<br> return services.NewDataService(mysqlRepo)<br>}</pre><pre>//repository.go<br><br>package dicontainer<br><br>import (<br> &quot;oops.telemetria.com/core/interfaces/repository&quot;<br> &quot;oops.telemetria.com/infrastructure/mysql&quot;<br> &quot;oops.telemetria.com/infrastructure.postgres&quot;<br> &quot;oops.telemetria.com/infrastructure.postgres/interfaces&quot;<br>)<br><br>// getPsqlConnectionManager retorna o gerenciador de conexão para PostgreSQL<br>func getPsqlConnectionManager() *postgres.DatabaseConnectionManager {<br> return &amp;postgres.DatabaseConnectionManager{}<br>}<br><br>// getMySQLConnectionManager retorna o gerenciador de conexão para MySQL<br>func getMySQLConnectionManager() *mysql.DatabaseConnectionManager {<br> return &amp;mysql.DatabaseConnectionManager{}<br>}<br><br>// GetDataRepositoryPostgres retorna um novo repositório de dados para PostgreSQL<br>func GetDataRepositoryPostgres() repository.DataRepository {<br> return postgres.NewDataRepository(getPsqlConnectionManager())<br>}<br><br>// GetDataRepositoryMySQL retorna um novo repositório de dados para MySQL<br>func GetDataRepositoryMySQL(postgresInterface interfaces.DataPostgres) repository.DataRepository {<br> return mysql.NewDataRepository(getMySQLConnectionManager(), postgresInterface)<br>}</pre><pre>//broadcast.go<br><br>package handlers<br><br>import (<br> &quot;sync&quot;<br>)<br><br>// Message representa uma mensagem de atualização<br>type Message struct {<br> HasUpdate bool<br>}<br><br>// Broadcaster gerencia assinaturas e transmissão de mensagens<br>type Broadcaster struct {<br> subscribers map[chan Message]struct{}<br> mu          sync.RWMutex<br>}<br><br>// NewBroadcaster cria uma nova instância de Broadcaster<br>func NewBroadcaster() *Broadcaster {<br> return &amp;Broadcaster{<br>  subscribers: make(map[chan Message]struct{}),<br> }<br>}<br><br>// Subscribe adiciona um novo assinante<br>func (b *Broadcaster) Subscribe() chan Message {<br> ch := make(chan Message, 1)<br> b.mu.Lock()<br> b.subscribers[ch] = struct{}{}<br> b.mu.Unlock()<br> return ch<br>}<br><br>// Unsubscribe remove um assinante<br>func (b *Broadcaster) Unsubscribe(ch chan Message) {<br> b.mu.Lock()<br> delete(b.subscribers, ch)<br> close(ch)<br> b.mu.Unlock()<br>}<br><br>// Broadcast envia uma mensagem para todos os assinantes<br>func (b *Broadcaster) Broadcast(msg Message) {<br> b.mu.RLock()<br> defer b.mu.RUnlock()<br> for ch := range b.subscribers {<br>  select {<br>  case ch &lt;- msg:<br>  default:<br>  }<br> }<br>}</pre><p>O <strong>Broadcaster</strong> é um componente que facilita a comunicação entre diferentes partes do sistema através de canais (channels) do Go. Ele permite que várias partes do sistema se inscrevam para receber atualizações e sejam notificadas quando uma nova mensagem é transmitida. Isso é especialmente útil para cenários onde precisamos reagir a mudanças em tempo real, como atualizações de dados enviadas pelo Apache NiFi.</p><pre>//data_handler.go<br><br>package data<br><br><br>import (<br> &quot;github.com/rs/zerolog/log&quot;<br> &quot;oops.telemetria.com/app/endpoints/handlers&quot;<br> broadcast &quot;oops.telemetria.com/app/endpoints/handlers&quot;<br> proto &quot;oops.telemetria.com/config/grpc/protobuf&quot;<br> &quot;oops.telemetria.com/core/interfaces/primary&quot;<br>)<br>// Handlers implementa os métodos do serviço DataService<br>type Handlers struct {<br> proto.UnimplementedDataServiceServer<br> service     primary.DataManager<br> broadcaster *broadcast.Broadcaster<br>}<br>// loadDatas carrega os dados do serviço<br>func (h *Handlers) loadDatas() []*proto.DataResponse {<br> data, err := h.service.GetData()<br> if err != nil {<br>  log.Err(err)<br>  return []*proto.DataResponse{}<br> }<br> var dataResponse []*proto.DataResponse<br> for _, dt := range data {<br>  dataResponse = append(dataResponse, dt.ToDataResponse())<br> }<br> return dataResponse<br>}<br>// GetData implementa o método GetData do serviço gRPC<br>func (h *Handlers) GetData(_ *proto.Empty, stream proto.DataService_GetDataServer) error {<br> dataResponse := h.loadDatas()<br> response := &amp;proto.DataResponseArray{<br>  Response: dataResponse,<br> }<br> ch := h.broadcaster.Subscribe()<br> if err := stream.Send(response); err != nil {<br>  log.Err(err)<br>  return err<br> }<br> for {<br>  select {<br>  case msg := &lt;-ch:<br>   if msg.HasUpdate {<br>    dataResponse := h.loadDatas()<br>    response := &amp;proto.DataResponseArray{Response: dataResponse}<br>    if err := stream.Send(response); err != nil {<br>     return err<br>    }<br>   }<br>  case &lt;-stream.Context().Done():<br>   return stream.Context().Err()<br>  }<br> }<br>}<br>// NewDataHandler cria um novo handler para DataService<br>func NewDataHandler(service primary.DataManager, broadcaster *handlers.Broadcaster) *Handlers {<br> return &amp;Handlers{<br>  service:     service,<br>  broadcaster: broadcaster,<br> }<br>}</pre><p>No arquivo <strong>data_handler.go</strong>, a função <strong>GetData</strong>, declarada no <strong>data.proto</strong>, faz uma solicitação à camada de serviço para obter os dados necessários para retornar ao cliente. O <strong>for</strong> basicamente serve para ficar ouvindo o broadcast e, caso haja alguma alteração, ele fará uma nova consulta.</p><pre>//data_http.go<br><br>package data<br><br>import (<br> &quot;net/http&quot;<br> broadcast &quot;oops.telemetria.com/app/endpoints/handlers&quot;<br>)<br>// HTTPHandler gerencia as requisições HTTP para Data<br>type HTTPHandler struct {<br> broadcaster *broadcast.Broadcaster<br>}<br>// GetHandler é chamado pelo NiFi em caso de alteração no banco de dados<br>func (h *HTTPHandler) GetHandler(w http.ResponseWriter, req *http.Request) {<br> msg := broadcast.Message{HasUpdate: true}<br> h.broadcaster.Broadcast(msg)<br> w.WriteHeader(http.StatusOK)<br> w.Write([]byte(&quot;Data updated successfully&quot;))<br>}<br>// NewDataHTTPHandler cria um novo handler HTTP para Data<br>func NewDataHTTPHandler(broadcaster *broadcast.Broadcaster) *HTTPHandler {<br> return &amp;HTTPHandler{broadcaster: broadcaster}<br>}</pre><p>O <strong>GetHandler</strong> é a função que é chamada pelo NiFi em caso de alteração no banco de dados. Quando ela é chamada, envia uma mensagem para o <strong>broadcast</strong>, que está dentro do <strong>data_handler.go</strong>, e com isso ele consegue atualizar os dados.</p><h3>Services</h3><p><strong>Estrutura de Pastas do Service</strong></p><p>A seguir está a estrutura de pastas do nosso projeto de services:</p><figure><img alt="Imagem contendo as pastas e arquivos que estão dentro da pasta ‘core’, que é o nosso service" src="https://cdn-images-1.medium.com/max/375/1*RSqqLu_bzWKVLZ4T2TYqIA.png" /><figcaption>Imagem contendo as pastas e arquivos que estão dentro da pasta ‘core’, que é o nosso service.</figcaption></figure><p>Dentro do diretório <strong>domain</strong>, temos as structs (classes) do nosso código, onde elas serão manipuladas por todo o sistema.</p><pre>//Data.go<br><br>package domain<br><br>import proto &quot;oops.telemetria.com/config/grpc/protobuf&quot;<br>// Data representa a estrutura de dados básica<br>type Data struct {<br>   Name     string<br>   Quantity int32<br>}<br>// ToDataResponse converte uma instância de Data para o tipo DataResponse<br>func (d Data) ToDataResponse() *proto.DataResponse {<br>   return &amp;proto.DataResponse{<br>      Name:     d.Name,<br>      Quantity: d.Quantity,<br>   }<br>}<br>// NewData cria uma nova instância de Data<br>func NewData(name string, quantity int32) *Data {<br>   return &amp;Data{<br>      Name:     name,<br>      Quantity: quantity,<br>   }<br>}</pre><p>No arquivo <strong>domain</strong>, definimos a estrutura <strong>Data</strong> com os campos <strong>Name</strong> e <strong>Quantity</strong>. Além disso, temos a função <strong>ToDataResponse</strong>, que converte uma instância de <strong>Data</strong> para o tipo <strong>DataResponse</strong>, definido no arquivo <strong>data.proto</strong>.</p><pre>//data_services.go<br><br>package services<br><br>import (<br>   &quot;github.com/rs/zerolog/log&quot;<br>   &quot;oops.telemetria.com/core/domain&quot;<br>   &quot;oops.telemetria.com/core/interfaces/repository&quot;<br>)<br>// DataServices implementa os serviços relacionados a Data<br>type DataServices struct {<br>   dataRepository repository.DataRepository<br>}<br>// GetData obtém dados do repositório e os converte para o tipo de domínio<br>func (s DataServices) GetData() ([]domain.Data, error) {<br>   data, err := s.dataRepository.GetData()<br>   if err != nil {<br>      log.Err(err).Msg(&quot;Error getting data&quot;)<br>      return nil, err<br>   }<br>   var result []domain.Data<br>   for _, d := range data {<br>      result = append(result, *d)<br>   }<br>   return result, nil<br>}<br>// NewDataService cria uma nova instância de DataServices<br>func NewDataService(dataRepository repository.DataRepository) *DataServices {<br>   return &amp;DataServices{<br>      dataRepository: dataRepository,<br>   }<br>}</pre><pre>//data_manager.go<br><br>package primary<br><br>import &quot;oops.telemetria.com/core/domain&quot;<br>// DataManager define a interface para o serviço de gerenciamento de dados<br>type DataManager interface {<br>   GetData() ([]domain.Data, error)<br>}</pre><p>O <strong>data_manager.go</strong> define a interface <strong>DataManager</strong>, que contém os métodos que o serviço deve implementar. Isso permite que o handler acesse esses métodos de forma desacoplada.</p><pre>//data_repository.go<br><br>package repository<br><br>import &quot;oops.telemetria.com/core/domain&quot;<br>// DataRepository define a interface para o repositório de dados<br>type DataRepository interface {<br>   GetData() ([]*domain.Data, error)<br>}</pre><p>O <strong>data_repository.go</strong> define a interface <strong>DataRepository</strong>, que contém os métodos que o repositório deve implementar. Isso permite que o serviço acesse esses métodos de forma desacoplada.</p><h3>Repository</h3><p><strong>Essa é a estrutura de pastas do repository.</strong></p><figure><img alt="Imagem contendo as pastas e arquivos que estão dentro da pasta ‘infraestructure’, que é a parte do repositorio" src="https://cdn-images-1.medium.com/max/362/1*ZDRMrGspRGHFeBINv4zFVg.png" /><figcaption>Imagem contendo as pastas e arquivos que estão dentro da pasta ‘infraestructure’, que é a parte do repositório.</figcaption></figure><p>Vamos ter duas pastas principais: <strong>mysql</strong> e <strong>postgres</strong>. Vamos utilizar os dois bancos de dados porque algumas informações estão presentes em um banco e outras em outro, como o estoque, que está presente no PostgreSQL.</p><pre>//credentials.go<br><br>package mysql<br><br>import (<br>   &quot;errors&quot;<br>   &quot;fmt&quot;<br>   &quot;github.com/rs/zerolog/log&quot;<br>   &quot;os&quot;<br>   &quot;strconv&quot;<br>)<br>var (<br>   user     string<br>   password string<br>   dbName   string<br>   host     string<br>   port     int<br>)<br>// SetUpCredentials configura as credenciais para o banco de dados MySQL<br>func SetUpCredentials() error {<br>   user = os.Getenv(&quot;mysql_user&quot;)<br>   password = os.Getenv(&quot;mysql_password&quot;)<br>   dbName = os.Getenv(&quot;mysql_db&quot;)<br>   host = os.Getenv(&quot;mysql_host&quot;)<br>   portString := os.Getenv(&quot;mysql_port&quot;)<br>   portInt, err := strconv.Atoi(portString)<br>   if err != nil {<br>      fmt.Println(err)<br>      log.Err(err).Msg(&quot;Error converting port string to int&quot;)<br>      return err<br>   }<br>   port = portInt<br>   if !HasValidCredentials() {<br>      return errors.New(&quot;invalid credentials for the MySQL database&quot;)<br>   }<br>   log.Info().Msg(&quot;MySQL credentials set up successfully&quot;)<br>   return nil<br>}<br>// HasValidCredentials verifica se as credenciais são válidas<br>func HasValidCredentials() bool {<br>   return host != &quot;&quot; &amp;&amp; dbName != &quot;&quot; &amp;&amp; port &gt; 0 &amp;&amp; user != &quot;&quot;<br>}<br>// getMySQLConnectionURI retorna a URI de conexão para o MySQL<br>func getMySQLConnectionURI() (string, error) {<br>   if !HasValidCredentials() {<br>      return &quot;&quot;, errors.New(&quot;invalid credentials for the MySQL database&quot;)<br>   }<br>   return fmt.Sprintf(&quot;%s:%s@tcp(%s:%d)/%s&quot;, user, password, host, port, dbName), nil<br>}</pre><p>No código <strong>credentials.go</strong>, configuramos as variáveis necessárias para que o banco de dados funcione.</p><pre>//connection.go<br><br>package mysql<br><br>import (<br>   _ &quot;github.com/go-sql-driver/mysql&quot;<br>   &quot;github.com/jmoiron/sqlx&quot;<br>   &quot;github.com/rs/zerolog/log&quot;<br>   &quot;time&quot;<br>)<br>type connectorManager interface {<br>   getConnection() (*sqlx.DB, error)<br>   closeConnection(conn *sqlx.DB)<br>}<br>var _ connectorManager = (*DatabaseConnectionManager)(nil)<br>// DatabaseConnectionManager gerencia a conexão com o banco de dados<br>type DatabaseConnectionManager struct{}<br>// getConnection estabelece uma conexão com o banco de dados MySQL<br>func (r DatabaseConnectionManager) getConnection() (*sqlx.DB, error) {<br>   uri, err := getMySQLConnectionURI()<br>   if err != nil {<br>      return nil, err<br>   }<br>   db, err := sqlx.Open(&quot;mysql&quot;, uri)<br>   if err != nil {<br>      log.Print(&quot;Error while accessing database: &quot; + err.Error())<br>      return nil, err<br>   }<br>   db.SetConnMaxLifetime(time.Minute * 3)<br>   db.SetMaxOpenConns(10)<br>   db.SetMaxIdleConns(10)<br>   return db, nil<br>}<br>// closeConnection fecha a conexão com o banco de dados<br>func (r DatabaseConnectionManager) closeConnection(conn *sqlx.DB) {<br>   err := conn.Close()<br>   if err != nil {<br>      log.Error().Err(err).Msg(&quot;Error closing the database connection&quot;)<br>   }<br>}</pre><p>O <strong>connection.go</strong> fornece os métodos necessários para estabelecermos uma conexão com o banco de dados.</p><pre>//query.go<br><br>package querys<br><br>// GetData retorna a query SQL para obter os dados necessários<br>func GetData() string {<br> query := `<br>  SELECT &#39;Contratos Bloqueados&#39; AS name, COUNT(*) AS quantity FROM oops_c_contratos WHERE oops_c_contratos_status IN (3, 4, 5, 7) UNION ALL<br>  SELECT &#39;Contratos Ativos&#39; AS name, COUNT(*) AS quantity FROM oops_c_contratos WHERE oops_c_contratos_situacao = 2 UNION ALL<br>  SELECT &#39;Contratos Inadimplentes&#39; AS name, COUNT(*) AS quantity FROM oops_c_contratos WHERE oops_c_contratos_status = 3 UNION ALL<br>  SELECT &#39;Contratos Liberado com Restrição&#39; AS name, COUNT(*) AS quantity FROM oops_c_contratos WHERE oops_c_contratos_status = 2 UNION ALL<br>  SELECT &#39;Contratos em ativação&#39; AS name, COUNT(*) AS quantity FROM oops_c_contratos WHERE oops_c_contratos_situacao = 1 UNION ALL<br>  SELECT &#39;Contratos Cancelados&#39; AS name, COUNT(*) AS quantity FROM oops_c_contratos WHERE oops_c_contratos_situacao = 6<br> `<br> return query<br>}</pre><p><strong>query.go</strong> fornece a query SQL necessária para obter os dados que precisamos.</p><pre>//data_repository.go<br><br>package mysql<br><br>import (<br>   &quot;github.com/rs/zerolog/log&quot;<br>   &quot;oops.telemetria.com/core/domain&quot;<br>   &quot;oops.telemetria.com/infrastructure/mysql/querys&quot;<br>   &quot;oops.telemetria.com/infrastructure/postgres/interfaces&quot;<br>)<br>// DataRepository implementa o acesso aos dados no MySQL e PostgreSQL<br>type DataRepository struct {<br>   manager           connectorManager<br>   postgresInterface interfaces.DataPostgres<br>}<br>// GetData obtém dados do MySQL e PostgreSQL e os combina<br>func (r DataRepository) GetData() ([]*domain.Data, error) {<br>   conn, err := r.manager.getConnection()<br>   if err != nil {<br>      log.Err(err).Msg(&quot;Error getting MySQL connection&quot;)<br>      return nil, err<br>   }<br>   defer r.manager.closeConnection(conn)<br>   rows, err := conn.Query(querys.GetData())<br>   if err != nil {<br>      log.Err(err).Msg(&quot;Error executing MySQL query&quot;)<br>      return nil, err<br>   }<br>   defer rows.Close()<br>   var data []*domain.Data<br>   for rows.Next() {<br>      var name string<br>      var quantity int32<br>      if err := rows.Scan(&amp;name, &amp;quantity); err != nil {<br>         log.Err(err).Msg(&quot;Error scanning MySQL row&quot;)<br>         return nil, err<br>      }<br>      data = append(data, domain.NewData(name, quantity))<br>   }<br>   if err := rows.Err(); err != nil {<br>      log.Err(err).Msg(&quot;Error with MySQL rows&quot;)<br>      return nil, err<br>   }<br>   postgresData, err := r.postgresInterface.GetData()<br>   if err != nil {<br>      log.Err(err).Msg(&quot;Error getting PostgreSQL data&quot;)<br>      return nil, err<br>   }<br>   for _, d := range postgresData {<br>      data = append(data, d)<br>   }<br>   return data, nil<br>}<br>// NewDataRepository cria uma nova instância de DataRepository<br>func NewDataRepository(manager connectorManager, postgresInterface interfaces.DataPostgres) *DataRepository {<br>   return &amp;DataRepository{<br>      manager:           manager,<br>      postgresInterface: postgresInterface,<br>   }<br>}</pre><p>O <strong>data_repository.go</strong> é responsável por fazer a conexão e executar as queries no banco de dados. Neste caso específico, temos o banco MySQL fazendo sua consulta e, logo após, fazendo uma chamada para o PostgreSQL.</p><h3>Rodando o Projeto</h3><p>Agora com tudo configurado, basta ir até onde está localizado o arquivo main.go e rodar o comando</p><pre>go run main.go</pre><p>Se tudo ocorrer bem você vera uma mensagem como essa no terminal</p><pre>2024/05/22 22:52:03 Starting HTTP server on 0.0.0.0:9999<br>{&quot;level&quot;:&quot;info&quot;,&quot;time&quot;:&quot;2024-05-22T22:52:03-03:00&quot;,&quot;message&quot;:&quot;MySQL credentials set up successfully&quot;}<br>2024/05/22 22:52:03 Starting gRPC server on 0.0.0.0:50051<br>{&quot;level&quot;:&quot;info&quot;,&quot;time&quot;:&quot;2024-05-22T22:52:03-03:00&quot;,&quot;message&quot;:&quot;Postgres credentials set up successfully&quot;}</pre><p>Esses são os arquivos que temos até o momento e como está o funcionamento do nosso código. Qualquer dúvida, entre em contato pelo e-mail <a href="/service/mailto:micledson14@gmail.com"><strong><em>micledson.dev@gmail.com</em></strong></a><strong><em>.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c7e7121fc5d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>