0:00Idempotência é o conceito que eu utilizei em todas as empresas que eu já trabalhei e é um dos conceitos que mais cai em entrevistas de back-end, de longe. Hoje eu prometo que eu vou te ensinar idempotência da forma mais didática possível, te dando exemplos práticos que eu utilizei na minha carreira. E no final do vídeo ainda vou te passar a resposta curta de 30 segundos que eu daria se alguém me perguntasse numa entrevista de emprego sobre o que é idempotência. Eu sou Yudi Ganeko, eu sou engenheiro de software há 7 anos, já trabalhei para iFood, C6 Bank, Revolut, Grupo Boticário e eu tô procurando agora a minha próxima vaga na gringa e levando vocês juntos nessa jornada. Então bora entender isso junto que esse é um dos conceitos mais importantes de todos, sério. Então primeiro, o que é idempotência? Bom, eu quero que vocês imaginem o seguinte cenário. A gente tem um cliente e um servidor. Vamos fazer de conta que isso aqui é um sistema de pagamentos, certo?
0:46E aí a gente quer fazer uma chamada aqui do cliente para o servidor fazendo uma transação de 20 reais. Então a gente vai mandar uma chamada HTTP aqui adicionando 20 reais e aqui no lado do servidor, ele vai salvar no banco de dados que ele adicionou 20 reais na conta dele. Mas o sistema cliente, ele, como de costume, ele é resiliente, né? Como quando a gente vai criar um sistema, a gente sempre quer que ele seja resiliente, ou seja, ele consiga lidar com possíveis falhas. E o que ele faz se algum problema acontecer aqui? Ele vai fazer uma coisa chamada retry, que é fazer essa mesma chamada outras vezes. Então ele vai lá, tenta adicionar mais 20 reais de novo e de novo e de novo. Então ele tenta executar quatro vezes, por exemplo, ele deu erro três vezes e só conseguiu executar com sucesso na
1:34quarta. O que vai acontecer aqui no nosso no nosso servidor de pagamentos? Bom, vai adicionar 20 reais, depois vai adicionar mais 20 reais, depois vai adicionar mais 20 reais e depois vai adicionar mais 20 reais. Mas tem um grande problema. O nosso cliente aqui, a operação que ele realizou era só de um uma transação de 20 reais e não do que resultou aqui no final, que acabou resultando numa transação errada, um saldo final errado de 80 reais, né gente? Quando um sistema se comporta dessa forma, isso significa que esse sistema é não idempotente, porque uma mesma chamada vindo de uma mesma intenção de fazer uma transação de 20 reais, acabou acontecendo várias vezes, sendo processada várias vezes e o resultado foi inconsistente. Agora, se a
2:22gente pegar esse mesmo cenário, como que a gente faz para ter uma estrutura idempotente? Bom, o cenário aqui ainda seria o mesmo. O usuário quer fazer uma transferência de 20 reais, o sistema é resiliente, ele pode falhar, acontece, não tem como a gente controlar. Ele pode falhar três vezes aqui e tentar executar a operação quatro vezes, só que a relação entre cliente e o servidor tem que ter uma estrutura implementada de idempotência para garantir que o resultado final aqui seja apenas de 20 reais transferidos, resultando num saldo de 20 reais. Então, idempotência é isso.
2:57Conceitualmente, ela é só isso. Ela é uma operação que mesmo executada várias vezes, vai ter só um resultado, o resultado original. Bom, mas eu falei para vocês que aqui então tem que ter uma uma estrutura de idempotência implementada no código mesmo, na infraestrutura, para que isso tudo funcione. Agora então, vamos entender como que essa estrutura de idempotência é implementada, como que faz ela na prática. Então, para a gente começar a desenhar a implementação aqui, eu vou te fazer uma pergunta. O que acontece se o cliente fazer uma chamada aqui para o servidor de adicionar 20 reais, por exemplo, e aí esse retorno aqui, ele nunca retornar, ele der um timeout, né?
3:39Então, a gente não sabe o que aconteceu. Ele mandou a requisição de adicionar 20 reais, mas nunca retornou se foi sucesso ou não. O que pode ter acontecido aqui? São três opções. A requisição pode ter saído aqui do cliente, chegar e nunca ter chegado no servidor. Essa é a primeira opção. Ou ela pode ter chegado no servidor e dado um erro aqui dentro. Ou ela pode ter chegado no servidor, processado com sucesso, mas nunca conseguiu ter voltado e dar um erro aqui no na volta para o cliente. E esse terceiro caso é o pior dos casos e é o que mais interessa aqui para a gente.
4:14Por quê? Porque a operação de adicionar 20 reais foi executada aqui no nosso servidor de pagamentos, então adicionou 20 reais, mas nós, o cliente aqui, o nosso sistema, ele nunca ficou sabendo que esses 20 reais foram adicionados com sucesso. Então o que vai acontecer? Ele vai mandar de novo a requisição, essa requisição vai ser processada novamente e aí ele vai retornar aqui sucesso, por exemplo, só que vai ter adicionado 40 reais e não 20 reais. E aí para resolver isso, é aí que entra a infraestrutura de inde idempotência. Primeiro a gente tem que identificar se as nossas transações que a gente tá realizando aqui realmente precisam de uma estrutura de idempotência. E a gente tem duas formas principais de ver isso. A primeira é através dos requisitos de negócio mesmo.
4:59Então através de requisitos de negócio e também através de métodos HTTP dá para a gente nos questionar se essa requisição realmente precisa de idempotência. Eu tenho alguns exemplos aqui, ó, de requisitos de negócio, de operações que já são naturalmente idempotentes. São, né? Na verdade não são todas as que aqui que são naturalmente idempotentes. Mas quais quais dessas que são? Será que a partir do que eu expliquei você já consegue adivinhar? Então definir o saldo da conta como 100 reais. Você acha que ela já é naturalmente idempotente? E a resposta é sim, porque não importa quantas vezes o cliente vir aqui e mandar definir saldo para 20, não importa quantas vezes ele fizer isso, o resultado sempre vai ser o mesmo, vai ser o saldo de 20 reais. Muito diferente desse segundo caso aqui, ó, somar 10
5:47reais ao saldo. Esse aqui não é naturalmente idempotente, porque aí é aquele caso que a gente já feito antes. Adicionar um valor vai ser mais 20, mais 20, mais 20 aqui, não vai ser naturalmente idempotente. Apagar uma chave Pix, por exemplo, apagar um registro de um banco. Sim, é idempotente. Nesse caso ele ainda o comportamento, né? O processamento, mas o retorno às vezes vai ser diferente. Mas isso aí a gente entende melhor mais para frente. Registrar uma chave Pix, sim, também é idempotente. Isso com uma condição, se o servidor destino e o banco de dados destino tiver uma chave única no banco de dados, aí se se ele tentar registrar a mesma chave de novo, vai dar erro de unicidade no banco e aí ele vai continuar sendo idempotente. E enviar um Pix de 50 reais para o fulano aqui, isso aqui não é idempotente.
6:32potente, porque você envia um Pix 50, depois envia mais um Pix 50. Então sempre tem esse caráter incremental ou de tão estado inicial ou de tão estado inicial e depois uma operação relativa a esse estado inicial, sempre que acontece isso, ele não é idempotente por natureza. Agora, outra forma de ver se é idempotente por natureza, chamadas HTTP. Aqui é muito importante a gente falar disso, porque a própria definição do protocolo HTTP fala sobre idempotência. Então a gente tem os nossos cinco métodos HTTP e pela definição deles, a gente já consegue entender se ele é ou não idempotente por natureza. Um método Get, ele está só puxando dados. Sim, ele sempre vai ser idempotente. O método Post, Post é enviar dados, criar ou executar alguma coisa. Ele não é idempotente por natureza. Ele pode ser,
7:19né, gente? Aqui é muito importante a gente é salientar isso, né? Que quando a gente vai falar de métodos HTTP, são padrões que foram definidos para serem seguidos. Eles vão ser seguidos? Na maioria das vezes não. Não corretos, né, de forma 100% correta igual a definição. Então é por isso que se você aí tem dificuldade de definir Get, Post, Patch, Delete, é totalmente normal, tá? Através da sua experiência, porque, cara, em cada empresa vai ser uma forma diferente. Mas o Post, em sua essência, é aí editar uma informação, adicionar um dado e através disso não dá para a gente garantir que ainda é potente, né? Porque ele pode executar, tipo, uma soma de 10 reais no no saldo, por exemplo, e isso não é idempotente. Então não dá para garantir. Dá para ser, mas não dá para garantir. O ele é inserir ou substituir um dado inteiro. Então sim,
8:08ele é idempotente, porque independente se o dado existe já ou não, o registro existe ou não lá no banco de dados, ele vai inserir ele de novo ou vai só manter o que já tá lá. Então, o resultado é sempre o mesmo. O patch, ele é atualização de uma parte do nosso registro e aí, novamente, depende de que tipo de alteração tá sendo executada no registro, né? Então, também a gente não consegue garantir que ele é idempotente, porque ele pode, por exemplo, incrementar 10 reais. E já o delete é, assim, não importa, né? Se o registro já existiu ou não, ele vai ser deletado ou não vai acontecer nada, então, ele é idempotente. Bom, esses conceitos aqui são bem importantes de transações que são naturalmente independentes e eu fiz questão de falar sobre isso aqui antes de explicar para vocês como implementar a idempotência, porque às vezes a gente simplesmente não precisa implementar. Eu
8:56vou dar um exemplo, uma das empresas que eu trabalhei, a gente tinha um fluxo que era, quando uma conta era deletada, ela tinha que deletar as chaves Pix registradas lá no Banco Central e também registradas no nosso banco de dados interno. E a gente tinha uma estrutura toda criada para isso, uma estrutura assíncrona que criava um job chamado termination, que era para deletar todos os registros desse usuário. E a gente tinha que garantir essa sincronia, né? Do das chaves Pix que foram deletadas lá no Banco Central e aqui no nosso banco. Só que tem um detalhe importante, como vocês perceberam, a gente tá falando de deletar. E olha só o que a gente falou aqui, a gente falou que o delete, ele é naturalmente idempotente. E aí lá o sistema tem várias outras complexidades, tinha vários estados que a gente passava na nossa máquina de estados, tinha também um job de reconciliação, que é um processo que verifica o estado da fonte
9:44da verdade com o nosso banco interno e depois executa essa reconciliação, né? Garantir que os dados se conversam. Todos esses fatores e, principalmente, esse fator aqui de ser uma chamada de delete, faziam criar toda uma estrutura de implementação, que a gente não criou aqui ainda, ser desnecessária. Então, o que a gente fez, a gente removeu essa estrutura. Um sistema que tava muito mais complexo do que precisava ser, a gente removeu tudo isso. De quebra, alguns casos de inconsistência foram resolvidos, ficaram bem menos comum por causa de toda essa complexidade que a gente tirou e o sistema ficou muito mais fácil de ser entendido. Então não, não é sempre que você precisa usar a idempotência, mesmo às vezes parecendo que precisa. É esse tipo de coisa que separa um pleno de um sênior. Bom, e falando sobre dinheiro que some do banco, que não pode duplicar, e o seu dinheiro, no final do mês, ele bate?
10:31Você trabalha, ganha bem, mas sente que o dinheiro não sobra no final do mês? Eu invisto há muitos anos e sou cliente da UP há muito tempo também. E sinceramente eu gosto muito deles, eu conheço há muito tempo aí, bem antes de eu ter esse canal do YouTube. A UP é a maior escola de investimentos do Brasil. O curso é 100% online para organizar a sua vida financeira e aprender a investir do básico ao avançado. E eles têm garantia plena, então se você, mesmo se você concluir todo o curso, mas não sentir que aprendeu, não se sentir seguro para investir, não tá satisfeito, eles devolvem todo o seu dinheiro. Lá você vai aprender tudo que você precisa saber para ser um bom investidor, desde renda fixa, renda variável, reserva de emergência, investimento no exterior.
11:10Tem também todos os outros benefícios como cartão de crédito, mediante análise de crédito que te dá acesso à sala VIP, cashback. [música] Então o que você vai fazer é clicar no primeiro link da descrição, clicar em faça sua análise de perfil e preencher o formulário, que aí a UP vai ver se faz sentido tanto para você fazer parte da UP quanto para eles terem você como cliente, porque precisa fazer sentido. Investir não é sobre ter muito dinheiro, é sobre ter o controle, então é melhor começar agora. Agora que você já sabe quando você não precisa usar a idempotência, agora sim eu vou te ensinar a usar, porque eu não quero que vocês saiam colocando aí complexidade à toa nos seus serviços aí. Então vou jogar lá esse texto aqui todo para a esquerda aqui e vamos aplicar idempotência aqui na nossa arquitetura bonitinha de cliente e servidor. Então a primeira coisa que a gente vai fazer é adicionar um banco de dados aqui do lado
11:57do nosso client. Por quê? Porque a gente tem que criar uma coisa agora que a gente tem um conceito novo aqui chamado aqui idempotency key, ele é uma chave única para identificar a nossa transação, a nossa intenção. Então esse idempotency key aqui vai ser criado no nosso client, vai ser salvo no nosso banco de dados antes de ser enviado para o servidor, aí ele vai enviar o nosso payload junto com o idempotency key aqui para o servidor, então envia aqui ó, tudo junto ó, idempotency key mais adicionar 20 reais. O servidor vai ter outro banco de dados aqui, ele vai salvar esse idempotency key nesse banco também, o mesmo idempotency key está salvo aqui e dessa forma a gente consegue começar a brincar. Por quê?
12:36Porque agora o servidor, ele sabe aqui uma forma de identificar essa mesma transação. Por quê? Porque o que poderia acontecer é o cliente aqui, ele der algum problema e novamente aqui mandar adicionar 20 reais de novo. Tem duas possibilidades, essa chamada de adicionar 20 reais adicional, ela pode ser legítima ou não. Ela pode ser sim, o usuário aqui querendo fazer uma transação de 20 reais e depois querendo fazer outra transação de 20 reais, poderia ser esse caso. Mas no caso que a gente tá trabalhando aqui não é, ele só quer fazer 20 reais mesmo, mas acabou acontecendo de enviar duas mensagens na nossa infraestrutura. Mas o nosso banco de dados aqui, a nossa infraestrutura, ela tá idempotente agora. Então aqui tinha o ID, por exemplo, o ID 10 e aí ele transitou esse ID ID 10 aqui para cá, salvou o ID 10 aqui no nosso banco de dados e ele identificou, hum, chegou
13:25o ID 10 duas vezes. Quando chegou a segunda vez, ele vai perceber, cara, já tenho esse ID 10 salvo aqui no banco, já recebi essa mensagem, não preciso adicionar 20 reais de novo que já tinha sido adicionado, eu vou só falar para esse cara aqui, eu vou falar, beleza, já fiz, mano. Ele vai responder aqui, beleza, já fiz e tá resolvido, né? Muito fácil, né? Muito simples. Só que não. Quanto mais complexidade a gente coloca no sistema, mais pontos de falha vão aparecendo. Você se perguntou por que eu coloquei esse banco de dados aqui no começo? Não precisava, né? Eu eu podia simplesmente ter gerado esse ID aqui e enviado para o servidor, não precisava salvar lá. Mas isso aqui eu coloquei como um fallback, como uma garantia caso aconteça alguma falha. Porque se a gente gerar esse ID 10 aqui na memória e esse
14:14servidor aqui, esse client aqui, morrer, como que ele vai saber o ID que foi criado para essa intenção de transação e enviar esse essa chamada aqui de adicionar 20 reais duas vezes com o mesmo ID? Ele não sabe qual foi o ID que foi gerado. Então, de novo, né? Se esse pod aqui morrer entre esse adicionar 20 e esse segundo adicionar 20, seria um problemão. É por isso que a gente cria aqui esse banco de dados e a gente salva a chave de idempotência nesse banco de dados. Porque se der algum problema entre uma execução e outra, entre um retry e outro, é só ele checar aqui esse banco e pegar a chave de idempotência de novo e mandar de novo para o servidor. E aí chega a minha segunda pergunta: onde, quem tem que criar essa chave de idempotência? É esse servidor aqui de cliente? É outro servidor que está sendo controlado aqui? É um front-end aqui?
15:01Onde que tem que ser criada essa essa chave? E isso é muito importante, porque essa chave de idempotência, ela vai ser transitada pelo nosso sistema em vários sistema em vários servidores diferentes. E a resposta para onde ela tem que ser criada é no momento exato que a intenção dessa operação foi criada. Então, aqui, o cliente pediu para fazer uma transferência de 20 reais, o primeiro sistema que fizer a o registro dessa transação, que no caso aqui é esse nosso client, é ele que tem que criar essa idempotência aqui. Para depois todos os serviços, microsserviços que forem operando essa transação, todos eles vão saber que é tudo uma chamada só. É por isso que a chave de idempotência é uma ótima chave para você fazer tracing de logs, por exemplo. Você consegue
15:48identificar uma intenção, uma transação de negócio acontecendo em vários sistemas diferentes. Beleza, resolvemos? Não, gente. Quando você insere mais complexidade, você insere mais pontos de falha. Ah, a gente pode ter problemas aqui no servidor também. Então, por isso que a gente tem esse banco de dados aqui. Então, a idempotência que foi enviada aqui para o servidor, ele salvou no banco de dados. Se der algum problema aqui, o servidor morrer e voltar, novamente é o mesmo caso aqui do cliente, a gente já tem o a chave aqui salva, então a gente consegue recuperar ela com tranquilidade. E para cobrir vários desses pontos de falha, entre outros, aqui no nosso banco de dados a gente vai guardar algumas informações muito importantes, como o response body que vai ser retornado para o cliente, a gente guarda o hash do request, a gente guarda obviamente o idempotency key, a gente guarda também um status e guarda
16:36também o time to live, que é o tempo que essa chave de idempotência vai ficar salva aqui no banco. Então a gente guarda várias informações e cada uma dessas informações tem um motivo para estar aqui. Bom, a gente grava o response body porquê? Porque quando a gente fala aqui ó, beleza, já fiz mano, a gente não fala simplesmente isso, tá? A gente tem que fazer muito mais do que isso. Normalmente, qual é o comportamento esperado? Se o cliente mandar uma mensagem para o servidor, começar a processar aqui e ele der um retry, tem algumas possibilidades. Esse segundo retry pode ter chego no momento em que a operação ainda está em processamento, então tá processando, ou ela pode ter já sido finalizada, pode estar em done. Se tiver em processamento, normalmente o que a gente faz é retornar um status 409 que indica conflito. Agora se tiver em done, aí o
17:25que a gente retorna normalmente é o payload de resposta, o response body. Na verdade a gente responde como se fosse a primeira chamada, tudo com sucesso na response body, retorna um 201 aqui por exemplo de status. E aí? Porquê? Porque se o sistema cliente aqui por exemplo for o seu front-end, um aplicativo e ele tá fazendo uma transação, se eu mandar a mesma requisição de novo, teve um retry síncrono aqui, né, o meu sistema, eu vou querer receber o response body de que eu esperava receber para mostrar os dados de transação com sucesso, por exemplo. Então ele tem que retornar aqui o response body que era esperado retornar desde a primeira requisição. Por isso que a gente salva o response body aqui no banco de dados também. A gente salva o hash do request, porquê? Porque se o cliente mandar uma idempotency key que já existe, mas com um body diferente, aí ele pode identificar que tem algum bug,
18:14alguma inconsistência, alguma tentativa de fraude e aí ele vai dar erro. O status aqui a A salva para controlar coisas como esse aqui de processamento e dane, e a gente também tem esse time to live, por quê? Porque a a chave de idempotência aqui não precisa ficar salva aqui para sempre. Então normalmente ela pode durar aí, sei lá, um dia. Só que é muito importante porque esse time to live aqui, esse tempo que a chave vai ficar viva no banco de dados, ela tem que estar em sintonia aqui. Porque a gente não pode enviar um retry depois que essa chave não existe mais. Então se você está integrando com o sistema aí, você tem que identificar quanto tempo de time to live tem do da chave de idempotência para você não fazer um retry que pode ser daqui dois dias sendo que a chave só dura um dia.
18:52Se não vai ter um grande risco aí de duplicidade. Ufa, acabou? Não, meu amigo. Você tem que entender todos os edge cases se você quiser ter mais senioridade. Então vamos dar outro exemplo aqui. E se o cliente mandar duas requisições com a mesma idempotência key, só que ele conseguir mandar no mesmo exato milissegundo? Faz de conta por exemplo que tinha um processamento paralelo aqui, ou uma chamada aqui na rede demorou um pouquinho mais para chegar e as duas acabaram chegando no mesmo exato milissegundo aqui no servidor. O servidor começou a processar as duas chamadas, as duas chamadas perguntaram para o banco de dados se já existe esse ID 10 no banco e as duas verificaram que não, que não existe.
19:32Isso pode acontecer? Claro que pode, por que não? E para entender o que salva a gente nesse nesse tipo de caso aqui é só a gente olhar a nossa infraestrutura aqui, ó. O servidor vai receber essas duas mensagens, ele vai tentar salvar no banco de dados com a mesma idempotência key. Já está entendendo essa idempotência key aqui, o que ela é? Ela é o mais importante a gente entender que ela é uma chave única. Sendo uma chave única, quando o o servidor aqui tentar inserir a mesma chave pela segunda vez, ele vai dar um erro e tranquilamente vai ter só uma chave aqui salva no banco. E aí ele vai identificar isso e não vai processar a mesma coisa duas vezes.
20:07Próximo ponto, vamos tentar deixar mais complexo aqui. Se ao invés de um client fosse uma fila aqui, por exemplo. Nem preciso explicar por que seria a mesma coisa, tá? Uma fila tem uma coisa chamado ack, que é o acknowledge, dizer se você já leu ou não a mensagem. Então a gente iria usar o mesmo sistema aqui de idempotência, a mesma tabela de idempotência, só que a gente só diria que aquilo foi lido, a mensagem foi lida, dá, a gente só daria o acknowledge depois que todo, todo o sistema tivesse processado a mensagem. Então, só substitui aqui os conceitos, né? Ao invés de retorno de sucesso, seria o acknowledge para fila. Então, funcionaria da mesma forma aqui, a mesma solução de idempotência para uma chamada HTTP funciona também para uma fila e é muito importante a gente implementar nos casos de fila idempotência. Por quê?
20:51Porque você, não sei se você já ouviu falar, mas se você for ler lá a definição do RabbitMQ, do Kafka, do SQS, você pode encontrar uma frase muito comum que é a frase famosa aqui at least once, que é que eles garantem que a mensagem só vai ser entregue, ela vai ser entregue pelo menos uma vez. Ou seja, eles falam: "Ah, entreguei uma vez. Pode ser que eu entregue de novo". E aí você fica: "Caramba, se você entregar de novo eu vou me ferrar". Exatamente, você se ferra aí mesmo. Por quê? É responsabilidade sua aplicar idempotência no seu sistema para garantir que essa chamada aí que pode ser enviada mais de uma vez não cause nenhum problema. E por que faz sentido eles fazerem isso, tá? Não é porque eles são malvados ou porque eles são burros, eles fazem isso porque justamente esse sistema de acknowledge, a gente só
21:38consegue dizer que uma mensagem foi processada com sucesso, só quem consegue dizer isso é o nosso sistema, o nosso servidor. Então, a fila, para ter um sistema de retry embutido nela, ela só vai parar de enviar a mensagem para você depois que você disser que a mensagem foi processada com sucesso. Se você não falar que foi processada com sucesso, ela vai mandar de novo sem medo. Bom, vamos tirar a nossa fila aqui para simplificar que já tá ficando muito complexo, mas vamos deixar mais complexo. E se eu colocar aqui, depois do nosso servidor, uma API externa? Então, vamos fazer de, de conta que esse nosso servidor aqui, ele é um client do, de um sistema de pagamento e essa API externa aqui é o sistema de pagamento, é a fonte da verdade, é onde os pagamentos são processados, pode ser o Banco Central aqui, por exemplo. Então, o que
22:25a gente tem que fazer aqui é mandar uma mensagem HTTP para esse sistema externo. Então, aqui a gente colocou mais um ponto de falha, porque a gente aumentou a complexidade. Vamos ver aqui, então, o que pode acontecer. A nossa idempotency key, a nossa request aqui, vai chegar aqui no cliente, vai ser salva no banco, vai ser enviado para o servidor. Esse servidor vai salvar a idempotency key e ele pode fazer a chamada para o sistema de pagamento, ele pode enviar a idempotency key, mas antes de retornar que tudo deu certo, ele pode morrer. Antes de retornar esse ID aqui para o nosso cliente, falar que deu tudo certo, antes mesmo de salvar aqui no nosso banco de dados o status como sucesso, ele ainda pode estar em processamento.
23:07Se esse status estiver em processamento e deu erro aqui depois da gente já ter feito essa chamada HTTP para o sistema de pagamentos, o que vai acontecer, o nosso cliente sistema pagamento vai ler o banco de dados, vai ver que o status ainda está em processamento, vai tentar processar de novo e vai mandar a mesma mensagem para para o sistema externo aqui, podendo duplicar a nossa transação. O cliente sistema pagamento vai ver que tem uma chamada aqui em status processamento e ele vai tentar mandar de novo. Inclusive, para isso funcionar, tem que ter um worker aqui nesse servidor que fica checando, pode ser um job que fica checando os registros que estão salvos aqui no banco de idempotency. Quando a gente tem esse padrão de um worker checando o banco, isso aqui sendo salvo através de uma transação, que é a mesma transação que executa as alterações no banco interno,
23:55isso cria um padrão chamado transactional outbox, mas isso é assunto para outro vídeo. Mas, enfim, o que vai acontecer aqui é que a mesma chamada pode ser enviada várias vezes para a nossa API externa aqui. E aí aqui a gente tem algumas possibilidades, né? A nossa API externa, ela pode ser idempotente ou não. Se ela for idempotente, muito bem, a gente mandou as duas chamadas com a mesma chave, deu tudo certo. Por isso que é importante aqui um conceito de da gente usar a mesma chave aqui em todo o fluxo. Lembra que eu falei que ele que essa chave tem que ser criada? No início da intenção da transação e tem que ser utilizada até o final do fluxo. Por isso, se aqui pro sistema externo fosse enviado outro ID, daria errado, né? Mas e se o sistema externo não garantir idempotência? Pode acontecer? Claro que pode. Aí a gente
24:44tem algumas opções. A gente pode, por exemplo, consultar antes, né? Mandar um get aqui e ver se o registro já existe lá. Se ele já existir, a gente não cria. Mas isso aí é meio complexo, né? Mas é uma saída aí pra gente evitar erros, evitar inconsistências. Já se nada disso der certo, cara, se o sistema aqui não for naturalmente idempotente e não aceitar uma chave de idempotência, eu já tive casos desse jeito, o sistema que a gente vai ter que recorrer é um sistema de reconcilia, que é basicamente criar um job que fica checando lá no nosso destino, aqui no sistema de pagamento, que é a fonte da verdade, ele fica checando, hum, todo dia, por exemplo, 3:00 da manhã, ele vai lá e vê. Ah, lá no nosso sistema de pagamentos, a fonte da verdade, tem que transações? Aí ele vai ver, tem essas
25:32transações e o saldo da conta do usuário é 30 reais. Aí ele vai falar, hum, é 30 reais e tem essas transações. Ele vai ver no nosso banco de dados interno. Tá 30 reais e tá essas transações? Não tá? Vê o que tá diferente e reconcilia, deixa igual. Porque o sistema externo é a fonte da verdade. Os nossos dados aqui no sistema interno tão só lá pra gente apresentar os dados de forma mais rápida pro nosso cliente. Então esse job de reconciliação aqui é a Finalmente, a última linha de frente aí pra garantir que não vai ter nenhuma inconsistência no nosso banco. Muito bonito, então, né? Funciona muito bem, cobrimos todos os casos, finalmente. Mas agora, numa entrevista de emprego de sênior, de uma pessoa mais experiente, aí é muito importante você entender uma coisa que é chamada trade-offs. Então agora eu quero perguntar pra você quais são os custos da gente implementar uma arquitetura
26:20idempotente? Bom, os custos normalmente sempre vão ser complexidade e uso de recursos. No geral é isso, mas é legal a gente responder de formas mais específicas. Então um custo que a gente vai ter, por exemplo, é de armazenamento. A gente vai ter que armazenar mais dados, armazenar, aí como eu falei, né, vai ter que ter um banco ou uma tabela para armazenar a chave de idempotência, o payload, o request hash. A gente vai ter que ter um banco de dados no nosso client para armazenar também essas chaves de idempotência. Outro custo vai ser a necessidade de um job para deletar as nossas chaves, né, que estão lá, o time to live, vai durar um dia, alguma coisa tem que apagar depois de um dia. Esse é outro custo, outra complexidade a mais. A gente também vai ter mais latência na hora de executar as nossas requisições. Então, é um é um passo a mais, né, a gente vai ter que estar salvando um registro no banco, recuperando o registro do banco,
27:06é um passo a mais. E ainda chamadas por banco de dados sempre são coisas que demoram um tempo a mais, aí aumenta o nosso tempo de execução. E aí você pode pensar: "Hum, então vou salvar a minha tabela de idempotência no Redis, no banco em cache, para ser mais rápido". Mas cuidado, normalmente isso aí não é uma boa opção. Por quê? Porque a sua chave de idempotência tem que estar no mesmo banco do efeito que vai ser executado no banco de dados. É a questão aqui da transação ou o inbox que eu falei. Porque você tem que na mesma transação conseguir salvar a sua chave de idempotência e executar a operação de mais R$ 20 no seu banco de dados. Se não, você não garante atomicidade, a o acoplamento dessas operações. Então, por isso que não é muito uma boa ideia você colocar as suas tabelas de idempotência no Redis. Vale a pena você usar se não tiver algum dado para salvar no seu banco de dados interno. Se, por exemplo, aqui, né, não tiver um banco de dados
27:53interno para salvar nada e só tiver que mandar uma mensagem para o sistema de pagamentos, aí você pode usar um Redis, mas rápido. E agora, como prometido para vocês, se uma pessoa na entrevista de emprego, a entrevistadora perguntar para você: "Ah, como você garantiria que um sistema de pagamentos não vai processar o mesmo pagamento duas vezes?" Eu responderia o seguinte: "Eu utilizaria um sistema de idempotência. Tendo como premissa que o sistema tem um sistema de retry, o meu client geraria no início da intenção dessa transação, geraria uma idempotência que eu iria salvar isso no banco de dados antes de enviar para o servidor. Chegando no servidor, eu também salvo essa chave junto do hash do request e o response body, dentre outras informações necessárias. Então, se o cliente acontecer algum problema e der retry nessa chamada, o servidor vai responder com o mesmo response body. Se
28:42ele ainda estiver processando, ele vai responder com um conflito. Se tiver um sistema externo, ele vai passar essa mesma chave de idempotência para o sistema externo. Se mesmo assim acontecer alguma duplicidade lá no sistema externo, um job de reconciliação é o que vai resolver no final das contas. Ufa! É isso, gente. Bom, idempotência é um conceito aí muito importante mesmo que cai muito em entrevista de emprego, por isso teve vários casos aqui, vários edge cases, vários momentos que a gente teve que explicar um trade-off do outro. E é por isso que eu resolvi trazer esse assunto aqui para vocês num vídeo que deve ter ficado gigante aí, porque eu queria ele bem completo para que vocês chegassem aí destruindo nas suas entrevistas de emprego. Hoje a gente falou aqui vários casos diferentes, vários trade-offs diferentes, porque é muito importante a gente entender todos os casos. Porque a verdadeira resposta se a gente vai ou
29:29não usar idempotência, se a gente vai ou não usar alguma decisão arquitetural, sempre vai ser depende. E o que separa um júnior de um sênior é o que vem depois do depende. É bastante coisa, é importante a gente ter todo esse raciocínio na nossa cabeça, mas é óbvio que não precisa saber tudo isso aqui de cor. No seu dia a dia aí, no seu trabalho, você vai consultar, vai querer lembrar: "Ah, como que funciona mesmo a transaction outbox? Que tipo de banco eu posso salvar essa informação aqui? Será que eu uso um Redis? Será que eu uso um MySQL?" Então, não, tá? Você não precisa saber tudo de cor. Mas é importante você compreender esse raciocínio. Compreendendo na hora, até na entrevista de emprego, você pode conversando com o entrevistador e lembrando e entendendo assim, pelo raciocínio, como que tem que funcionar o seu sistema de idempotência. Esse aqui é um assunto que pode cair em qualquer tipo de entrevista, pode cair numa
30:16entrevista de system design, pode cair numa entrevista behavioral, que é aquela entrevista que você fala sobre as suas experiências e fica explicando o que você fez, decisões de arquitetura, de trade-off. Até num exercício de código pode cair idempotência. Espero que você tenha gostado desse vídeo. Eu tô na minha jornada aqui de fazer vários vídeos técnicos totalmente de graça, porque eu quero ajudar vocês, ao mesmo tempo que eu tô relembrando todos esses conceitos. Se você gostou, se esse vídeo te ajudou de alguma forma, te trouxe um conhecimento novo ou te fez se lembrar de algum conhecimento antigo, por favor, eu peço que você deixe o like, deixe um comentário aí, deixe um feedback aí para melhorar para as próximas aulas e e se inscreve aí no canal, por favor, para continuar acompanhando aí essa nossa jornada aí de estudos, de aperfeiçoamento em ciência da computação, na minha busca aí pelo meu próximo emprego e é isso. Muito obrigado para quem viu o vídeo até aqui e um