DEV Community: Renato Suero

Conectando Dois Bancos PostgreSQL com FDW (DataLink do Heroku)

Renato Suero — Mon, 11 Aug 2025 11:00:00 +0000

Postado originalmente

É muito comum quando temos 2 sistemas que se relacionam em algum momento um precisar conectar no outro banco de dados. Seja pela aplicação(falarei sobre em outro post) ou mesmo direto numa consulta no banco de dados.

Imagina conseguir fazer uma consulta onde fazemos um inner join usando uma tabela de cada banco de dados, como a seguir estando conectado no banco de dados loja e consultando produto que vem de catalogo:

select * from vendas v inner join produtos p on p.id=v.produto_id

Quanto usamos serviços como Heroku temos isso via interface(chamado data link) e outros lugares com possíveis outros nomes, mas por baixo dos panos estão usando uma extensão do Postgres chamada [fdw](https://www.postgresql.org/docs/current/postgres-fdw.html)

Meu objetivo é mostrar como conseguimos alcançar isso para o ambiente de desenvolvimento que é onde vamos escrever esse código então precisamos validá-lo

Configuração

Para começar eu vou deixar o script para criação de 2 bancos de dados para seguirmos o tutorial

create database catalogo
-- Cria a tabela 'produtos'
CREATE TABLE produtos (
    id SERIAL PRIMARY KEY,
    nome VARCHAR(255) NOT NULL,
    quantidade INT NOT NULL,
    valor DECIMAL(10, 2) NOT NULL
);

-- Insere uma lista de 10 produtos na tabela
INSERT INTO produtos (nome, quantidade, valor) VALUES
('Notebook Gamer', 15, 7500.50),
('Monitor 4K 27"', 25, 1899.90),
('Teclado Mecânico RGB', 50, 350.00),
('Mouse Sem Fio Ergonômico', 80, 120.75),
('Headset 7.1 Surround', 40, 499.99),
('Cadeira Gamer Confort', 20, 1200.00),
('SSD NVMe 1TB', 60, 850.00),
('Placa de Vídeo RTX 4070', 10, 4500.00),
('Memória RAM 16GB DDR5', 100, 650.25),
('Webcam Full HD', 75, 250.00);

create database loja
-- Cria a tabela 'usuarios'
CREATE TABLE usuarios (
    id SERIAL PRIMARY KEY,
    nome VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE
);

-- Cria a tabela 'vendas'
-- Esta tabela se relaciona com 'usuarios' e 'produtos'
CREATE TABLE vendas (
    id SERIAL PRIMARY KEY,
    usuario_id INT NOT NULL,
    produto_id INT NOT NULL,
    quantidade INT NOT NULL CHECK (quantidade > 0),
    data_venda TIMESTAMP WITH TIME ZONE DEFAULT NOW(),

    -- Define as chaves estrangeiras para garantir a integridade dos dados
    CONSTRAINT fk_usuario FOREIGN KEY(usuario_id) REFERENCES usuarios(id)
);
-- II. INSERIR DADOS DE EXEMPLO

-- Insere 10 usuários na tabela 'usuarios'
INSERT INTO usuarios (nome, email) VALUES
('Ana Silva', 'ana.silva@email.com'),
('Bruno Costa', 'bruno.costa@email.com'),
('Carlos Pereira', 'carlos.pereira@email.com'),
('Daniela Martins', 'daniela.martins@email.com'),
('Eduardo Almeida', 'eduardo.almeida@email.com'),
('Fernanda Lima', 'fernanda.lima@email.com'),
('Gustavo Oliveira', 'gustavo.oliveira@email.com'),
('Helena Souza', 'helena.souza@email.com'),
('Igor Santos', 'igor.santos@email.com'),
('Juliana Ribeiro', 'juliana.ribeiro@email.com');

-- Insere 50 registros de vendas na tabela 'vendas'
-- As datas são variadas para simular um histórico de vendas.
INSERT INTO vendas (usuario_id, produto_id, quantidade, data_venda) VALUES
(1, 3, 1, '2025-07-01 10:30:00'),
(5, 1, 1, '2025-07-01 11:15:00'),
(2, 5, 2, '2025-07-02 14:00:00'),
(10, 8, 1, '2025-07-03 09:05:00'),
(3, 7, 1, '2025-07-04 18:20:00'),
(7, 2, 1, '2025-07-05 12:00:00'),
(4, 10, 3, '2025-07-06 16:45:00'),
(8, 4, 1, '2025-07-07 11:50:00'),
(6, 6, 1, '2025-07-08 13:10:00'),
(9, 9, 2, '2025-07-09 10:00:00'),
(1, 4, 1, '2025-07-10 15:00:00'),
(2, 8, 1, '2025-07-11 17:25:00'),
(5, 2, 1, '2025-07-11 19:00:00'),
(7, 1, 1, '2025-07-12 08:30:00'),
(3, 9, 4, '2025-07-13 11:40:00'),
(10, 5, 1, '2025-07-14 20:00:00'),
(4, 7, 1, '2025-07-15 21:05:00'),
(6, 3, 2, '2025-07-16 09:15:00'),
(8, 6, 1, '2025-07-17 10:00:00'),
(1, 10, 1, '2025-07-18 14:55:00'),
(9, 1, 1, '2025-07-19 16:20:00'),
(5, 5, 1, '2025-07-20 18:30:00'),
(2, 7, 2, '2025-07-21 12:10:00'),
(7, 4, 3, '2025-07-22 13:00:00'),
(3, 2, 1, '2025-07-22 14:40:00'),
(8, 8, 1, '2025-07-23 09:00:00'),
(4, 9, 1, '2025-07-23 11:20:00'),
(10, 3, 1, '2025-07-24 16:00:00'),
(6, 1, 1, '2025-07-24 17:00:00'),
(1, 6, 1, '2025-07-25 19:10:00'),
(2, 10, 2, '2025-07-26 10:45:00'),
(5, 4, 1, '2025-07-26 11:00:00'),
(9, 5, 1, '2025-07-26 15:30:00'),
(7, 7, 1, '2025-07-27 13:25:00'),
(3, 1, 1, '2025-07-27 14:00:00'),
(4, 8, 1, '2025-07-28 10:10:00'),
(8, 2, 2, '2025-07-28 11:30:00'),
(10, 9, 1, '2025-07-28 12:00:00'),
(6, 5, 1, '2025-07-29 18:00:00'),
(1, 7, 1, '2025-07-29 18:45:00'),
(9, 3, 3, '2025-07-29 20:15:00'),
(5, 6, 1, '2025-07-30 09:30:00'),
(2, 4, 1, '2025-07-30 10:00:00'),
(7, 10, 1, '2025-07-30 14:20:00'),
(3, 8, 1, '2025-07-30 15:00:00'),
(4, 1, 1, '2025-07-30 16:10:00'),
(8, 9, 2, '2025-07-30 17:40:00'),
(10, 2, 1, '2025-07-31 08:50:00'),
(6, 7, 1, '2025-07-31 09:00:00'),
(1, 5, 1, '2025-07-31 09:15:00');

Agora que temos 2 bancos de dados, podemos começar.Temos alguns passos para configurar a conexão, sendo eles:

Criar a extensão

loja=# CREATE EXTENSION IF NOT EXISTS postgres_fdw;
CREATE EXTENSION

Checando se tudo está ok

loja=# select * from pg_extension;
   oid   |   extname    | extowner | extnamespace | extrelocatable | extversion | extconfig | extcondition
---------+--------------+----------+--------------+----------------+------------+-----------+--------------
   13895 | plpgsql      |       10 |           11 | f              | 1.0        |           |
 7549345 | postgres_fdw |       10 |         2200 | t              | 1.1        |           |
(2 rows)

Criar o servidor no banco de dados:

Criei um server chamado foreigndb_fdw, vamos usar esse nome na hora de importar as tabelas, tbm fiz a configuração para o outro banco de dados, basicamente mudou o dbname já que ambos rodam localmente

loja=# CREATE SERVER foreigndb_fdw FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host '127.0.0.1', port '5432', dbname 'catalogo');
CREATE SERVER

Checando se tudo está ok

loja=# \des
               List of foreign servers
     Name      |    Owner     | Foreign-data wrapper
---------------+--------------+----------------------
 foreigndb_fdw | fdwuser      | postgres_fdw
(1 row)

Criar user mapping:

Podemos fazer manual trocando fdwuser para o usuário que vamos conectar ou usar o próximo comando que vai selecionar o usuário conectado

Eu já tenho um usuário chamado fdwuser, então uso o mesmo assim não preciso configurar permissões e outras configurações, como é um ambiente local podemos deixar isso simples. No primeiro comando eu passo a mesma senha que uso para conectar, na segunda opção não há senha então só criar o mapping do usuário

loja=# CREATE USER MAPPING FOR fdwuser SERVER foreigndb_fdw OPTIONS (user 'fdwuser', password 'secret');
CREATE USER MAPPING

Comando lendo o usuário logado, o usuário que estamos executando os comandos

SELECT format('CREATE USER MAPPING FOR %I SERVER foreigndb_fdw OPTIONS (user %L)', current_user, current_user) \gexec

Checando se tudo está ok

loja=# select * from pg_user_mapping;
   oid   | umuser | umserver |      umoptions
---------+--------+----------+---------------------
 7549353 |     10 |  7549352 | {user=fdwuser}
(1 row)
loja=# select * from pg_user_mappings;
  umid   |  srvid  |    srvname    | umuser |   usename    |      umoptions
---------+---------+---------------+--------+--------------+---------------------
 7549353 | 7549352 | foreigndb_fdw |     10 | fdwuser      | {user=fdwuser}
(1 row)

Depois que fizemos as configurações agora falta um último passo, importar as tabelas utilizadas no banco de dados. Aqui eu tenho algumas notas que farei na sequência, mas vou deixar um exemplo de como funcionaria.

loja=# IMPORT FOREIGN SCHEMA public                                                                                                             FROM SERVER foreigndb_fdw                                                                                                                     INTO public;
IMPORT FOREIGN SCHEMA

Notas sobre o import

Sempre que criar novas tabelas precisará fazer o import para que traga a nova tabela;
Caso tenha conflito com nome de tabela, ambos banco de dados tendo uma tabela com o mesmo nome, podemos criar um schema. Note que que comando acima é feito no final INTO public troque public para o nome do novo schema, e na hora da consulta tem que fazer nome-schema.tabela se criamos um schema catalogo seria assim catalogo.produtos
O import não traz enum ou coisas do tipo, neste caso eu copio o script de criação e executo no outro banco de dados, assim ele funcionará porque agora terá esses items customizados
Eu fiz um import de todas tabelas, mas podemos restringir com algumas opções:
- EXCEPT para excluir tabelas, IMPORT FOREIGN SCHEMA public EXCEPT (produtos)
- LIMIT TO para selecionar apenas algumas IMPORT FOREIGN SCHEMA public LIMIT TO (produtos)

Deletando tudo

Hora de limpar a casa, detelando a extensão já irá remover as configurações de server, users mappings e o import das tabelas.

loja=# DROP EXTENSION IF EXISTS postgres_fdw CASCADE;
NOTICE:  drop cascades to 3 other objects
DETAIL:  drop cascades to server foreigndb_fdw
drop cascades to user mapping for renato.suero on server foreigndb_fdw
drop cascades to foreign table produtos
DROP EXTENSION

Lidando com concorrências no banco de dados 🇧🇷

Renato Suero — Sun, 25 Oct 2020 12:07:27 +0000

Você já ouviu essa pergunta ? "O que acontece se 2 pessoas executarem a ação ao mesmo tempo?"(no contexto de um serviço web com o banco de dados). Algumas respostas possíveis(se conhece outras me diz ai).

Transações estão ai para resolver isso.
Não sei (simples,direto e principalmente honesto).

Beleza, vamos criar um cenário para que possamos ter o contexto em comum. Podemos olhar para esse problema pensando em reserva de assentos/quartos, estoque de produtos,qualquer problema onde 2 pessoas podem alterar o mesmo registro, etc...
Vamos trabalhar com um cinema. Temos uma tabela com os assentos 1-5(sim é um cinema muito pequeno, mas garanto que a qualidade é muito boa).

Vamos ter uma tabela assentos com os registros para cada assento e o nome de quem reservou. A tabela será simplesmente isso e eu farei as inserções dos assentos com cliente vazio oq significa disponível.

create database cinema;
create table assentos ( 
   id serial PRIMARY KEY, 
   cliente varchar NOT NULL DEFAULT '' 
);
insert into assentos (cliente) values(''),(''),(''),(''),('');

postgres@localhost:cinema> select * from assentos;                                              
+------+-----------+
| id   | cliente   |
|------+-----------|
| 1    |           |
| 2    |           |
| 3    |           |
| 4    |           |
| 5    |           |
+------+-----------+
SELECT 5
Time: 0.018s

o fluxo da reserva vai ser:

Checar se o assento está disponível

Caso negativo: "Retornar um erro avisando que o assento não está disponível";
Caso positivo: Reservar o assento e retornar uma mensagem avisando que foi reservado;

No sql seria algo assim

begin;
select id from assentos where id = 5 and cliente='';
/// caso retorne 0
update assentos set cliente = 'Renato' where id = 5;
Commit;

Criei um código para mostrar isso, não vou mostrar aqui porque o objetivo é executar as instruções acima, mas você pode ver o código nesse link.(você pode ver isso funcionando, mas não recomendo esse código, eu fiz ele rápido só para mostrar meu ponto porque só com o sql não seria tão divertido).

Legal temos nossa API para reservar assentos no cinema :), massss o que acontece se durante o processo de reserva tivermos alguma lentidão no servidor ou mesmo se tivermos algum processo ali no meio entre a consulta e reserva(por ex. enviar a informação sobre a reserva para outro serviço)?

Vou Adicionar um sleep antes do update para simular o cenário, caso o cliente seja Henrique(por que Henrique?, porque ele é um vacilão 🙂) assim podemos responder à pergunta anterior.

Vou mandar duas requisições usando o curl para que fique tudo na mesma imagem. E ai quer dar um palpite? quem leva o quarto Henrique ou Renato ?

Olhe em fullscreen para ver todas panes do meu tmux

Brincadeiras de lado, o que rolou foi que quando o Henrique enviou o pedido a API fez o fluxo que combinamos, porém ela deu uma pausa para que desse tempo de fazermos outro pedido.
O outro pedido fez o mesmo processo e na primeira parte confirmou que o assento estava livre então poderia avançar e assim fez executando o update para o Renato, quando o sleep terminou o update do Henrique foi feito, nesse caso como foi o último ele levou o assento(apesar de ambos terem o retorno de sucesso). Agora se Renato também tivesse uma lentidão e fosse maior que Henrique(executasse o update por último) ele/eu levaria o assento.

Legal agora podemos começar o post sobre esse assunto. Existe algumas opções de lock que podemos bloquear o dados seja uma tabela ou registro(nosso caso).

A solução é bem simples, mas infelizmente não muito conhecida (motivo pelo qual eu escrevo este post).

Na nossa query , vamos adicionar mais 2 palavras, FOR UPDATE Ficando assim:

SELECT id FROM assentos WHERE id = 5 AND cliente='' FOR UPDATE;

Essa instrução nova vai dar um lock nesse registro não permitindo outras consultas no registro. Assim quando a próxima query tentar consultar o assento 5 nesse caso, vai ficar esperando até que quem deu o bloqueio(a transação que fez o pedido de reserva) execute o Commit ou Rollback.
Vamos ver novamente o resutlado agora com o essa alteração.

Olhe em fullscreen para ver todas panes do meu tmux

Legal né? com duas palavras resolvemos um problema de reservar o mesmo assento para para mais pessoas.

Uma boa notícia para quem usa o GORM é que ele tem suporte para essa feature
Beleza se vc não quis clicar tá aqui o exemplo :)

DB.Clauses(clause.Locking{Strength: "UPDATE"}).Find(&assentos,"id = $1 and cliente =''",id)

Uma forma que você poderia resolver sem precisar do "lock" seria fazer algo assim(obrigado Henrique)

select id from assentos where id = 5 and cliente='';
update assentos set cliente ='Henrique' where id=5 and cliente='';

Para o cenário simples que criei sim é uma solução que funcionaria bem, a única coisa diferente é que a API precisaria ver o retorno RowsAffected para saber se houve a reserva(update aconteceu e retornaria 1 RowsAffected,caso 0 significa que não encontrou). Para esse cenário de um campo fica fácil validar se o campo ainda está no estado anterior(cliente is null) mas para a vida real ou algo menos simples que um campo para atualizar isso te obrigaria a checar todos campos que vai fazer o update. Acho que usando o FOR UPDATE você resolve isso de uma maneira mais "limpa/simples".

Bom era isso que tinha para fazer hoje, espero que tenham gostado e que te ajude de alguma forma =)

Avoid duplicated requests with singleflight

Renato Suero — Sun, 24 May 2020 14:17:46 +0000

Do you have any endpoints which need to process a lot of things, it consumes third-party data, it's slow, etc... And to help these endpoints receive a lot of simultaneous requests (something you load on your home page for all users and the content is the same, for example some statistics).

Each time that endpoint is called your eyes are filled with tears. That is about to change :) I'll tell you how.
We will use the package singleflight.In words of the package:

"Package singleflight provides a duplicate function call suppression mechanism."

The idea of the package is, you create a key to identify the request and when there're other requests with the same key, it will wait for the answer which is processing for another request. When the request returns the result, it will share with the other requests were waiting for the result, therefore avoiding multiples requests/slow process.

Let's see the code, I've created an API to see the package running, you can see the code [here]. (https://github.com/renatosuero/devto-posts/tree/master/singleflight)

I've created an HTTP service that will consume data that comes from an external API.

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "time"
)

func main() {
    var requestGroup singleflight.Group
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("calling the endpoint")
        response, err := http.Get("https://jsonplaceholder.typicode.com/photos")

        if err != nil {
            fmt.Print(err.Error())
            os.Exit(1)
        }

        responseData, err := ioutil.ReadAll(response.Body)
        if err != nil {
            log.Fatal(err)
        }
        time.Sleep(2 * time.Second)
        w.Write(responseData)
    })

Accessing http://127.0.0.1:3000/ it willl call the API jsonplaceholder, in order to become interesting I've added 2 seconds for sleeping to simulate the process is slowlest.

Let's use vegeta, the goal is to execute a lot of requests to see singleflight shine. I defined to execute 10 requests per second and the duration will be 1 second.

echo "GET http://localhost:3000/" | vegeta attack -duration=1s -rate=10 | tee results.bin | vegeta report

Here you can see the result of Vegeta and the output of our service:

As we can see, all requests called the external API.

Let's see singleflight shine now, we'll use the same configurations to run Vegeta again.

In this code I added a new endpoint /singleflight, in the function requestGroup.Do, I defined the key as s*singleflight*, now the request will verify if there's a processing running (using that key) , if there's a key, it won't call and it'll wait for the result of the call it is processing.
I added a print in the terminal to indicate when the request waits for result and uses the shared result.

// Because the pacage isn't a starndard library until now, you have to add him in your go path,go mod, vendor,etc..
import "golang.org/x/sync/singleflight"
var requestGroup singleflight.Group
//para este endpoint funcionar você precisa importar o pacote singleflight e criar essa variável(eu sei global e tal, mas para este post é suficiente).
    http.HandleFunc("/singleflight", func(w http.ResponseWriter, r *http.Request) {
        res, err, shared := requestGroup.Do("singleflight", func() (interface{}, error) {
            fmt.Println("calling the endpoint")
            response, err := http.Get("https://jsonplaceholder.typicode.com/photos")

            if err != nil {
                http.Error(w, err.Error(), http.StatusInternalServerError)
                return nil, err
            }
            responseData, err := ioutil.ReadAll(response.Body)
            if err != nil {
                log.Fatal(err)
            }
            time.Sleep(2 * time.Second)
            return string(responseData), err
        })

        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        result := res.(string)
        fmt.Println("shared = ", shared)
        fmt.Fprintf(w, "%q", result)
    })

Vegeta again

echo "GET http://localhost:3000/" | vegeta attack -duration=1s -rate=10 | tee results.bin | vegeta report

I recommend you execute the code+vegeta and see it executing in your machine.
In the first endpoint, you'll see all the requests are executed and the log shows the calls.
In the second one, you'll see one request, and suddenly 10 true indicating all requests used the shared result.

That's an amazing resource, let's think of endpoints we have a heavy/slow process, or you pay by external requests. In the latter, not only it helps reducing processing power, but also saves you money by avoiding duplicated calls .
Another thing, I'm using an HTTP service, but it could be anything, for example it could be a database query, a worker, etc...

Well, that's it folks. I hope it helps you as it helped me knowing this cool package, I'd like to thank Henrique to show me that, and André Mota for your valuable review.
The package has an option to "forget" the key and another one that the result returns by channels. You can for example, define a timeout, after X time you defined, cancel the key or by channel.

Evitando requisições duplicadas com singleflight 🇧🇷

Renato Suero — Sun, 12 Apr 2020 14:55:41 +0000

Você tem algum endpoint que precisa processar muita coisa, consome dados de terceiros, lento, etc.... E para ajudar esse endpoint recebe muitas requisições simultâneas( algo que carrega na tua página inicial para todos users e tem o mesmo conteúdo)

Cada vez que aquele endpoint é chamado seus olhos se enchem de lágrimas, pois então isso vai mudar :) e vou te contar como.
Vamos usar o pacote singleflight. Nas palavras do pacote:

"Package singleflight provides a duplicate function call suppression mechanism."
"O pacote singleflight fornece um mecanismo de supressão de chamada de função duplicado."

A idéia do pacote é, você cria uma chave para identificar a requisição e quando houver outras requisições com a mesma chave ela vai aguardar a resposta que está em andamento de outra request. Quando a request retornar com o resultado ela compartilhará com as outras requests que estavam esperando pelo resultado, assim evitando múltiplas chamadas/processos pesados.

Chega de papo e vamos ver código, afinal é disso que gostamos :). Criei uma api para que possamos ver o pacote em ação, você pode ver o código no repositório

Criei um serviço http que consome dados vindos de uma api externa.

package main
import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "time"
)
func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("calling the endpoint")
        response, err := http.Get("https://jsonplaceholder.typicode.com/photos")
        if err != nil {
            fmt.Print(err.Error())
            os.Exit(1)
        }
        responseData, err := ioutil.ReadAll(response.Body)
        if err != nil {
            log.Fatal(err)
        }
        time.Sleep(2 * time.Second)
        w.Write(responseData)
    })
    http.ListenAndServe(":3000", nil)
}

Quando você acessar http://127.0.0.1:3000/ ele vai chamar pela api jsonplaceholder, para tornar mais interessante eu adicionei um sleep de 2 segundos para simular que o processo é mais lento.

Agora vamos usar o vegeta a idéia aqui é executar várias requests para ver o singleflight brilhar. Eu defino para executar 10 requests por segundo e a duração de 1 segundo.

echo "GET http://localhost:3000/" | vegeta attack -duration=1s -rate=10 | tee results.bin | vegeta report

Aqui você pode ver o resultado do Vegeta e o output do nosso serviço:

Como podemos ver todas requests chamaram a api externa.

Agora vamos ver o singleflight brilhar, usaremos as mesmas configurações do vegeta.

Neste código eu adicionei um novo endpoint /singleflight, na chamada da função requestGroup.Do() eu defini a chave como singleflight, agora a request vai verificar se há um processo em andamento, caso sim ele aguarda o resultado.
Adicionei um print no terminal para indicar quando a request aguarda pelo resultado e usa a resposta compartilhada.

// Como ele não faz parte da standard library você precisa adicionar ele no seu gopath,go mod,vendor,etc...
import "golang.org/x/sync/singleflight"
var requestGroup singleflight.Group
//para este endpoint funcionar você precisa importar o pacote singleflight e criar essa variável(eu sei global e tal, mas para este post é suficiente).
http.HandleFunc("/singleflight", func(w http.ResponseWriter, r *http.Request) {
        res, err, shared := requestGroup.Do("singleflight", func() (interface{}, error) {
            fmt.Println("calling the endpoint")
            response, err := http.Get("https://jsonplaceholder.typicode.com/photos")

            if err != nil {
                http.Error(w, err.Error(), http.StatusInternalServerError)
                return nil, err
            }
            responseData, err := ioutil.ReadAll(response.Body)
            if err != nil {
                log.Fatal(err)
            }
            time.Sleep(2 * time.Second)
            return string(responseData), err
        })
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        result := res.(string)
        fmt.Println("shared = ", shared)
        fmt.Fprintf(w, "%q", result)
    })

Vegeta novamente

echo "GET http://localhost:3000/" | vegeta attack -duration=1s -rate=10 | tee results.bin | vegeta report

Recomendo você executar o código+vegeta e ver isso executando na sua máquina.
No primeiro endpoint, você verá que os requests são executados e o log mostra as chamadas.
No segundo endpoint, você verá uma request, e de repente 10 true indicando que todas requests usaram a resposta compartilhada.

Isso é um recurso incrível, pense em endpoints que tem um processo pesado/lento ou por serviços externos que você paga por requisições, neste último caso além de ajudar o serviço evitando processamento também poderá poupar dinheiro com requests duplicadas.
Outro ponto é que estou usando em um serviço de http, mas poderia ser qualquer coisa, por ex. poderia ser uma consulta na base de dados , enfim cenários não faltam :).

Bom é isso o que gostaria de mostrar, espero que te ajude como me ajudou saber deste package lindão e deixo meu agradecimento ao Henrique por te me mostrado o pacote. Vale dizer que o pacote conta com uma opção para "esquecer" a chave e tbm uma opção que o resultado é retornado via channel. Você pode por ex. definir um timeout, depois de n tempo você pode por ex. cancelar a chave ou pelo channel.

Go, Google Functions and Gitlab-ci a perfect combination

Renato Suero — Sat, 19 Jan 2019 17:27:03 +0000

Last week I tested google functions at gcp using Go, after that, I decided to add another service I like gitlab. I liked it so much that I decided to write this post.

If you know how to add an account to do a deploy at GCP or you have an account, you can ignore this section.

Creating an account to use at Gitlab.

I'll add a lot of screenshots to make it clear.
You need to access IAM & admin then Service accounts.

Click on the button "+ CREATE SERVICE ACCOUNT"

Type a name to identify the account

You need to add 3 roles

Create a key

Check that JSON is checked and click on the create button

We finish the config at GCP, now we will add the env vars in the repository. PROJECT_ID is the project's id and SERVICE_ACCOUNT is the content you do a download when you created your key

Ok now we will create the code to test our deploy.I'm using the examples from Google
We will create 3 files, hello_world.go that is the function

// Package helloworld provides a set of Cloud Function samples.
package helloworld

import (
    "fmt"
    "net/http"
)

// HelloGet is an HTTP Cloud Function.
func HelloGet(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello, World!")
}

hello_world_test.go that is the test of the function


package helloworld

import (
    "io/ioutil"
    "net/http/httptest"
    "strings"
    "testing"
)

func TestHelloGet(t *testing.T) {
    payload := strings.NewReader("")
    req := httptest.NewRequest("GET", "/", payload)

    rr := httptest.NewRecorder()
    HelloGet(rr, req)

    out, err := ioutil.ReadAll(rr.Result().Body)
    if err != nil {
        t.Fatalf("ReadAll: %v", err)
    }
    want := "Hello, World!"
    if got := string(out); got != want {
        t.Errorf("HelloWorld = %q, want %q", got, want)
    }
}

and .gitlab-ci.yml that is the config to run the continuous integration

image: google/cloud-sdk:alpine

test_production:
  image: golang:alpine
  stage: test
  only:
  - production
  script:
  - CGO_ENABLED=0 go test ./...

deploy_production:
  stage: deploy
  environment: Production
  only:
  - production
  script:
  - echo $SERVICE_ACCOUNT > /tmp/$CI_PIPELINE_ID.json
  - gcloud auth activate-service-account --key-file /tmp/$CI_PIPELINE_ID.json
  - gcloud --quiet --project $PROJECT_ID functions deploy HelloGet --runtime go111 --trigger-http
  after_script:
  - rm /tmp/$CI_PIPELINE_ID.json

The workflow is, the actions will run when we merged changes in production branch.

That's all, as you can see in the next screenshot, the deploy was done and the return from Google shows the URL created

That's all folks, I hope it can be useful to you =). You can see the code in the repository

Go is supported in Google functions

Renato Suero — Thu, 17 Jan 2019 15:53:44 +0000

Now we can use Go to run google functions =). Take a look an example:

// Package helloworld provides a set of Cloud Function samples.
package helloworld

import (
        "fmt"
        "net/http"
)

// HelloGet is an HTTP Cloud Function.
func HelloGet(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, World!")
}

Deploy:

gcloud functions deploy HelloGet --runtime go111 --trigger-http

Improve the Go code with GolangCI-Lint

Renato Suero — Sun, 13 Jan 2019 08:33:20 +0000

It is a great tool to run before you send your commit to the repository(maybe you can use git hook).

there is another option gometalinter but golangci-lint is faster than gometalinter.

golangci / golangci-lint

Fast linters runner for Go

golangci-lint

Fast linters runner for Go

golangci-lint is a fast Go linters runner.

It runs linters in parallel, uses caching, supports YAML configuration, integrates with all major IDEs, and includes over a hundred linters.

Install `golangci-lint`

Documentation

Documentation is hosted at https://golangci-lint.run.

Social Networks

Supporting Us

golangci-lint is a free and open-source project built by volunteers.

If you value it, consider supporting us, we appreciate it! ❤️

Badges

Contributors

This project exists thanks to all the people who contribute. How to contribute.

Stargazers over time

View on GitHub

To run the tools is pretty simple, you need to run:

golangci-lint run ./...

If you want to use docker, the only thing you need to do is configure the volume to use your project path.

docker run --rm -it -v $GOPATH/src/github.com/golangci/golangci-lint:/go/src/github.com/golangci/golangci-lint golangci-lint run ./...

that's all folks, I hope it can be useful to you =)

Golang Security Checker

Renato Suero — Fri, 11 Jan 2019 07:31:13 +0000

Gosec is a great tool to run our Go code and ensure that we have no security issues. To keep the post short, I won't explain the security issues, my focus will be to show you how to run the tool. Maybe in the future, I can write about the issues, right now if you want to understand more, please read this post

securego / gosec

Go security checker

gosec - Go Security Checker

Inspects source code for security problems by scanning the Go AST and SSA code representation.

License

Licensed under the Apache License, Version 2.0 (the "License") You may not use this file except in compliance with the License. You may obtain a copy of the License here.

Project status

Install

CI Installation

# binary will be $(go env GOPATH)/bin/gosec
curl -sfL https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s -- -b $(go env GOPATH)/bin vX.Y.Z
# or install it into ./bin/
curl -sfL https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s vX.Y.Z

# In alpine linux (as it does not come with curl by default)
wget -O - -q https://raw.githubusercontent.com/securego/gosec/master/install.sh | sh -s vX.Y.Z

# If you want to use the checksums provided on the "Releases" page
# then you will have to download a tar.gz file for your operating system instead of a binary file
wget https://github.com/securego/gosec/releases/download/vX.Y.Z/gosec_vX.Y.Z_OS.tar.gz

# The

…

View on GitHub

You can run the tool using a binary or using Docker. I'll show both cases to you.
Using binary you need to run into your root directory:

gosec *.go

Using docker, it needs more config, but it works well. In the readme the command is securego/gosec ./..., it didn't work to me, so I replaced ./... to projet-path

docker run -it -v $GOPATH/src/<YOUR PROJECT PATH>:/go/src/<YOUR PROJECT PATH> securego/gosec $GOPATH/src/<YOUR PROJECT PATH>

Even if you use go module, you need to use this format to run the tool.

that's all folks, I hope it can be useful to you =)

Run migrations in schemas in PostgreSQL

Renato Suero — Sat, 05 Jan 2019 09:37:28 +0000

Hy everyone,

This post is a continuation from that link.
Now we have schemas, but how can we create a new table in the schemas?

I've been using a function to handle migrations in the schemas, it can be used for anything. create table,changes in the table, triggers,functions,index,etc...

Ok, that is the function you need to run in your database.

After that, you only need to run

select migrate_schema('your code')

In my case,

select migrate_schema('CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);');

A tip, you can ignore schemas, take a look in the function. In line 13 I ignore the public schema and in line 11 I ignore schemas that begin with pg_

Another thing, I've been using the goose to handle my migrations. I planned to write about that, but fortunately, the Sho Minagawa wrote a great post.
We need to run more complex statements (PL/pgSQL). So, If you decide to use the tool, remember to add these lines in the migration code:

-- +goose StatementBegin
/// your statement here
-- +goose StatementEnd

When we use schemas, the goose looks for its migrations table within the schema. In my case, I want to keep my migrations table in the public schema, so I forked the project and change the instruction to check the table only in the public schema. Right now I have no plan to send a merge request, to the project, maybe it can be useful only to me. In this case, use my fork.

that's all folks.

Clone schema in PostgreSQL

Renato Suero — Sat, 05 Jan 2019 08:45:44 +0000

Hi everyone,

My goal is to keep the post short, so If you don't know what is schema access this link.

Schemas can be useful to clients, maybe a schema by the client or schema by "category". In my job(our business is based in soccer) we use schemas by championship and year.
A sample :
ucl_2018
ucl_2017
championship *that's the model

Ok, now we need to create a new schema ucl_2019, right?

I researched and after some time, I found a function to help me, but I needed to do changes. I didn't remember exactly what I needed to do, so I decided to share the function I've been using. Another thing this function will create everything indexes, keys, foreign keys, etc...

Ok, that is the function you need to run in your database.

After that, you only need to run

select clone_schema('source','destination')

In my case,

select clone_schema('championship','ucl_2019');

I hope it can be useful to you. I love PostgreSQL, so I want to write more about other features I like or I think that can be useful.
~~My new post will be a sequence for that, I'll show how to update the schemas, running migrations in the schemas.~~ I wrote the post

Generate UML diagram from a textual description

Renato Suero — Tue, 01 Jan 2019 11:26:09 +0000

Hi everyone,

I always hated UML because every tool I saw, I needed to "draw", I feel that I'm less productive.
So I found PlantUML and my world changed, now I could write and generate the diagram. One of the reasons I liked that option is to keep the diagrams updated, now it is simple and fast (to me).

Let's see how we can use the tool.
Firstly, another thing nice to me, I can use docker =).
I use 2 docker images, first to generate the diagram to me. I use https://hub.docker.com/r/think/plantuml/
In this case, I created a file called test.uml:

@startuml
autonumber
Bob -> Alice : Authentication Request
Bob <- Alice : Authentication Response

autonumber 15
Bob -> Alice : Another authentication Request
Bob <- Alice : Another authentication Response

autonumber 40 10
Bob -> Alice : Yet another authentication Request
Bob <- Alice : Yet another authentication Response

@enduml

I run this command

cat test.uml | docker run --rm -i think/plantuml > test.svg 
cat test.uml | docker run --rm -i think/plantuml > test.png

As you can see, that's the result.

Another way, I run the server to write and see the diagram. I use https://hub.docker.com/r/plantuml/plantuml-server/

In this case, I run the command

docker run -d -p 8080:8080 plantuml/plantuml-server:jetty

then, I open my browser and I access http://localhost:8080. As you can see, that's the result.

If you want to play now you can use the official server, the good thing to use that server, is you can share the diagram

I recommend you access the official documentation, my goal was to show you options to generate your diagrams and help you to be more productive.

I'd like to show you a suggestion how to use dev.to using UML =)

I'd like to invite you to write/draw a diagram and share here in the comments, let's inspire others readers =)

DEV Community: Renato Suero

Conectando Dois Bancos PostgreSQL com FDW (DataLink do Heroku)

Configuração

Notas sobre o import

Deletando tudo

Lidando com concorrências no banco de dados 🇧🇷

Avoid duplicated requests with singleflight

Evitando requisições duplicadas com singleflight 🇧🇷

Go, Google Functions and Gitlab-ci a perfect combination

Creating an account to use at Gitlab.

Go is supported in Google functions

Improve the Go code with GolangCI-Lint

golangci / golangci-lint

Fast linters runner for Go

golangci-lint

Install golangci-lint

Documentation

Social Networks

Supporting Us

Badges

Contributors

Stargazers over time

Golang Security Checker

securego / gosec

Go security checker

gosec - Go Security Checker

License

Project status

Install

CI Installation

Run migrations in schemas in PostgreSQL

Clone schema in PostgreSQL

Generate UML diagram from a textual description

Install `golangci-lint`