Um momento
Aula 12
Cursos / Módulos de Golang: Gerenciamento de Pacotes e Dependências na Linguagem Go
Como Fazer Upgrade de Versão Maior v1 para v2 de Dependências de Módulos de Golang

Summary

Resumo da Aula sobre Upgrade de Dependências em Go

Nesta aula, o instrutor ensina como realizar um upgrade de uma dependência do Go de uma versão maior (de V1 para V2), utilizando um projeto com o arquivo GoMod.

Principais Tópicos Abordados

  1. Instalação da Versão 1:

    • O instrutor utiliza um módulo do GitHub, github.com.vindtwegs.vilmos, e instala a versão 1.2.1.
    • O Go, por padrão, instala a versão mais recente abaixo da versão maior 2, caso a versão não seja especificada.
  2. Estrutura de Dados:

    • Demonstra o uso de uma função que cria uma pilha (stack) e explora como essa função se comporta na versão 1.
  3. Upgrade para a Versão 2:

    • Para instalar a versão 2, é necessário especificar o caminho como github.com/vindtwegs/vilmos/v2.
    • O instrutor discute as mudanças que ocorrem com a versão 2, onde uma função já existente muda seu comportamento, retornando dois valores ao invés de um.
  4. Mudanças no Código:

    • O código deve ser modificado para lidar com o novo retorno da função new stack.
    • No código, o erro deve ser tratado corretamente.
  5. Novos Métodos na Versão 2:

    • Um novo método chamado clear é introduzido na versão 2, que não existia na versão 1.
  6. Transição entre Versões:

    • O instrutor sugere que durante um período de transição, é possível usar duas versões do mesmo módulo. Para isso, seria necessário criar um alias para uma das versões.
    • Por exemplo, poderia-se utilizar interpreter1 e interpreter2 para referenciar a versão 1 e 2, respectivamente.
  7. Limpeza de Dependências:

    • Após a transição, a limpeza das dependências pode ser feita com o comando go mod tidy, que remove versões não utilizadas.

Conclusão

A aula conclui abordando a importância de entender como as mudanças nas versões podem quebrar o código existente, o que é comum ao fazer upgrades de versões maiores, de acordo com o conceito de Versionamento Semântico (Semver).

Espero que este resumo tenha sido útil! Até a próxima aula!

Video Transcript

Bem-vindo a mais uma aula de Columbo. Nessa aula eu vou falar de como você faz um upgrade de uma dependência da versão maior. No exemplo eu vou usar de versão maior 1 para versão 2. V1 para V2. Para essa demonstração eu vou usar aqui o meu projeto que já criei. Tem o meu arquivo GoMod. Eu vou baixar um certo módulo de Golang que eu achei online no GitHub e vou demonstrar a atualização da versão 1. O upgrade da versão 1 para a versão 2. A gente vai ver que certas uma certa função foi adicionada na versão 2 e também vamos ver que a versão 2 quebrou uma das funções que já existia. Por isso se tornou de 1 para 2. De acordo com Semantic Version, que é Samver, versões semânticas. Vou aqui no meu nome e vou usar o quebrador. Então o módulo de Gol que eu vou usar para esse exemplo é esse aqui no GitHub.com.vindtwegs.vilmos. GitHub.com.vine.twg. TWGS.vilmos. Se eu ver aqui nas tags tem os releases, as versões. Tem a versão 2 maior que é o número mais esquerda depois do V e tem a versão 1. O primeiro vou instalar a versão 1. Então vamos lá. Go, get, caminho do módulo GitHub.com.vindtwegs.vilmos. A note que eu não disse nenhuma versão específica, mas ele instalou a versão 1.2.1 e ver a versão mais atual que a versão 2. Isso é devido à maneira que o Gol lida com as versões maiores que 1. Então na verdade se eu quiser essa versão 2 que é mais atual eu teria que dizer explicitamente. Vilmos barra v2. A gente vai ver depois. Mas sem a especificação de barra v2 aqui, que é diferente do do arroba, tá? E ele vai baixar 1. Então vamos lá. No editor de texto. Eu tenho um exemplo no meu arquivo main.go. Se eu salvar. Então o módulo é esse aqui. Mas eu quero usar um certo pacote desse módulo. Então digo barra interpreter que é o nome do pacote. Deixa eu te mostrar no editor. Voltar para o repositório arquivos interpreter. Eu quero ver stack.go. Mas eu quero olhar a versão 1.2, né? Quero a versão 1.2.1. Porque essa aqui é mais atual. Então vamos ver. Você clica aqui no seu editor de branch e tag. Clique em tag. Aí eu vou mudar para a versão que eu estou usando agora no arquivo. Que é 1v1.2.1. E agora ele vai mudar para essa tag e vai mudar para essa conta. Para aquele commit da versão 1.2.1. Então nesse ponto no tempo, né? O snapshot desse repositório dos arquivos era dessa maneira. Então vou olhar aqui a função que eu vou usar. Essa aqui. Você vai na linha 18 a 22. Se aumentar aqui para você ver melhor. Então essa é uma função que vai criar uma stack, né? A estrutura de dados stack é como por exemplo você tem pratos, né? Você empira os pratos um em cima do outro. Isso é uma stack, né? E você sempre só pode acessar o prato lá do fundo se você tirar todos os pratos de cima. Então essa função eu posso chamar com o número de elementos, né? Para stack e retorno o ponteiro para stack. Essa struct aqui na linha 13. Às 16 tem os itens, né? E tem o tamanho máximo. Então eu usei isso como exemplo. Na linha 9 do meu arquivo, main.go na função, no bloco da função main, eu falo interpreter, né? Que é o nome do pacote. Ponto new stack, que é o nome da função da tamanho de 4. Então eu quero que você aloca 4, uma stack de 4, tamanho 4. Você pode botar por exemplo de pratos, 4 pratos, né? E que é o tipo, né? Retorno o ponteiro para stack que está dentro do modo. E tem também a função de push, que é adicionar o valor a essa stack. Eu usei um, dois, três, números um, dois, três. E no final eu faço print na linha 24. Por favor, ignore os comentários, para ver. Vou falar aqui goal build. Aprenda a executar. Então eu mostro aqui que a estrutura interna daquela variável, né? Que é uma stack de 1, ponteiro para stack. A stack tem um, dois, três, que é um slice de int, inteiros, números inteiros, e o tamanho máximo que é 4, então dá pra empurrar mais um. Então eu quero demonstrar o lance da upgrade, né? Da versão 1 para 2. E como fazer? Bem, se eu falar goal gets, não sei o que, viu uns barra v2. Ele adiciona essa versão aqui e você nota que a tag é mais atual da v2. Então a tag, essa barra v2 é no caminho, certo? É diferente do arroba, nesse caso seria arroba v2.1.1, se quisesse explicitamente, digitar. Se eu olhar o meu goal mod agora, agora vai ter também a versão 2 ao mesmo tempo, que é a versão 1. Então essa é uma das das coisas que acontece. Você pode ter duas versões do mesmo módulo instalados ao mesmo tempo. Isso porque o caminho é diferente. Então o caminho da versão 2 sempre vai ter o suffixo barra v2, depois do nome do caminho do módulo. Então é parte do caminho, o suffixo da versão. Agora, se eu tiver aqui no meu main.go, ainda estou usando a versão 1, na verdade. Porque no goal você tem que explicitamente dizer se quiser usar a versão 2 ou se tem que dizer. Então, se eu quiser fazer o upgrade da versão 2, eu teria que mudar os meus caminhos. Cada caminho que dizia getarra.com.bindtwegs.vilmos, agora tem que dizer também o suffixo barra v2. Nesses casos ele quer dar o ponto com barra bindtwegs.vilmos barra v2. Então v2 teria que ser adicionado aqui ao meu import. Então todos os import que você tem que adicionar a nova versão, v2, nesse caso, versão maior. Com isso ele vai usar o módulo da versão 2 em vez da 1. Agora, quando a gente quiser fazer o upgrade, o problema é que a versão maior que muda, normalmente tem a mudança que quebra o programa, porque algo que já existia foi modificado para se comportar de outra maneira. Nesses casos a gente vai ver que vai quebrar o negócio. Quando eu botar v2 e todos esses referências de interpreter, oh, desculpa, está errado aqui, tem que ser v2 depois do nome do caminho do módulo. Tem que ser depois do barra v1. Então, github.com, barra bindtwegs, barra v1, barra v2. Porque esse é o caminho do módulo, a interpretação é o nome do pacote que está dentro do módulo. Como esse módulo é, na verdade, um programa executável, em possível própria, eu tenho que dizer barra interpreter para poder só acessar aquele pacote interpreter. Interpreter é o pacote que é o arquivo aqui, se você ver no GitHub, de volta ao navegador, na primeira linha package interpreter. Está esse aqui que é usado para o sufixo. Então, de volta ao editor de texto, quando eu mudar v2, barra interpreter, vamos ver o que acontece. Quando eu falar gobuild para compilar, você note que já teve um erro de atribuição. Falou que teve o mismatch de atribuição. One variable but interpreter, but new stack returns dois values, né? Está dizendo aqui que a função new stack retorna dois valores. Então, o que aconteceu aqui que essa função foi modificada, seu comportamento original. Na versão 2 retorna dois valores, em vez de só um. Para poder confirmar isso, você pode ir na página do GitHub e comparar as versões. Deixa eu te mostrar como comparar. Vai aqui no code, clica nas, cadê releases, tags. Você vê, eu clico na versão mais atual, versão 2. Aqui embaixo do número, clica compare. Você coloca a versão anterior para comparar o que foi adicionado nessa versão 2. Então, a versão anterior que eu usei foi v1.2.1. Você note na URL tem o bar compare, barra v1.2.1, que é a base do 3.v211, que é por cima. Então, o que mudou da versão 1.2.1 para a versão 2.1.1? Vamos ver. Aqui rola para baixo. Eu estou interessado na função new stack. Então, vou fazer uma busca new stack. Funk. Já noto aqui que a função new stack foi modificada e o retorno, o tipo de retorno que era só um único, que era ponteiro para stack, agora se tornou um tuple, que é 2 valores retornados ao mesmo tempo. Nesses casos, além de retornar com um ponteiro para stack, retorna o error do tipo error, que é erro. Foi modificar o comportamento com se usa essa função. Então, essa mudança que quebrou. Então, o que você faria nos seus upgrades? Você iria lá e qualquer chamada para a função ponto new stack, você teria que mudar o comportamento. Nesses casos, ele só está atribuindo a uma variável. Então, eu modifiquei isso, já tenho escrito aqui para te mostrar. Eu teria que criar duas variáveis e atribuir o valor de retorno a essas duas variáveis. Você pode usar dois pontos igual aqui e você tem que usar var também. Eu só botei isso para poder destacar. Então, na versão 2, tem que usar assim. Então, tem que lidar com o erro. Então, interpreto retorno stack e além de stack, vim para o error. E o erro, se não for new, é botar o mensagem. Acho que é só um exemplo pessoal. Isso aqui não é sério. Então, só botei algo para ele não reclamar que não estou usando a variável error. Com isso, vou salvar, falar Google Build. Vou executar o notic que funcionou direito. Então, outra coisa aqui, nessa nova versão, adicionar a função, vamos ver aqui, clear. Vamos usar essa função. Depois vou reverter para você ver que quebra o negócio. Então, vou linha 22 e botar stack.clear, que não existia antes da v21. Vamos comparar a versão 1 que eu tinha. Falar Google Build, executável executável. E note que ele deu clear. Clear significa limpar, remover todos os elementos da pira. Nesse caso, virou vazio. Cocheiro vazio. Agora, se eu tirar o v2 aqui, usar a versão 1. E se você quiser tirar esse require, eu vou usar o go mod tidy depois de remover todas as referências da versão anterior dos imports. Nesse caso, como os imports do meu aqui não tem mais versão 1, é só dar o go mod tidy, go mod tidy e ele removeria a versão anterior. Mas eu quero deixar aqui só para você ver o que acontece. Então, quando eu tirar esse v2 e fazer ele usar o v1, vai quebrar, né? A gente já viu que tinha quebrar mesmo. Na hora de criar stack, também no stack clear é indefinido, porque não existe essa função, esse método no stack. Agora, como que te mostra que é interessante? Você pode usar duas versões ao mesmo tempo. Vamos fazer isso, ó. Te mostrar aqui. Se você quiser fazer um certo período de transição, você copiaria e botava mesmo com o v2, mas você tem que dizer uma alias, porque eles não podem ter o mesmo nome, né? Ou você dá para o v1 ou para o v2. Eu não sei qual que você quer. Por exemplo, normalmente se chama interpreter, né? Então, aqui você fala interpreter, aí você coloca, sei lá, v2, algo assim. Dá um nome diferente, ou 2, sei lá, interpreter 2. Aí, onde tiver a função que só existe no 2, né? Que quer usar do 2, você vai lá. Por exemplo, clear, só tem no 2. Então, teria que usar... O problema que que stack é do interpreter 1. Ah, deixa eu ver. É o como usar do... Usar o do 2 aqui, isso é um problema. Ah, vamos ver. No record module... Ah, desculpa. Sempre esqueço. É o v2 depois do modo caminho, não do pacote. Então, o problema é que tem que usar stack do 2, né? É o meu problema. Vamos usar outro exemplo. Vamos ver o new stack, por exemplo. Se eu quisesse já... Eu poderia usar o new stack do interpreter 2, nesse caso, para não quebrar aqui. Vamos ver qual é o problema. Não dá para assinar o 2 ao stack do 2. Então, eu tenho problema aqui, na verdade. Na maneira que esse exemplo não é muito bom. Porque não é função isolada, né? É pertença ao... Tem um método que é associado à estrutura. Então, porque as estruturas são diferentes, de modos diferentes, não funciona direito com esse exemplo. Mas o ponto que eu queria demonstrar é que você tivesse funções e transição de certo modo, se você poderia só dar um alias aqui, enquanto estivesse em transição, você colocaria 2, algum outro nome diferente do primeiro. Aí, fazia transição e depois de tirar todas as referências do 1, você só mudaria de volta para o nome aqui. Acho que poderia ficar melhor no 1. Não sei, você escolhei. Tem que pensar nisso. Em vez de falar 2, você fala interpreter 1, então você fazia uma substituição global de todos os interpreters. Nesse caso, o primeiro aqui seria 1. E o 2 seria o mais atual, seria como já existia. Aí você faria a limpeza procurando em transição. O período de transição seria o pessoal das equipes. Então, teria que como tarefa, substituir interpreter 1 pelo normal que é o 2. Então, esse seria o período de limpeza nesse caso. Então, recapitulando tudo para poder dar upgrade, versão 1 para a versão 2. Ou, em geral, a versão 2 é acima. O caminho do módulo tem que clicar como sufixo vx, onde x é o número da versão. Nesse caso, v2. Então, caminho do módulo barra v2. Caminho do módulo barra v2. Cada import que você tem em todos os arquivos, você tem que modificar isso para caminho do módulo barra v2. Se tiver período de transição, pode usar duas versões ao mesmo tempo, mas ter que criar um alias para uma das versões. Ou você quer ir para a versão 1 e põe sufixo 1 ou v2, sufixo 2, por exemplo, e usa 2 ao mesmo tempo até que você termine a limpeza de tudo. Fazia transição e só usar a nova versão. Porque certamente, certos elementos vão não quebrar. Depois que terminar isso tudo, só dá o GoModTide e vai remover a versão anterior. Vou mostrar. Tirei tudo das versões anteriores. Vou aqui. Go, espaço mod, espaço tide, T, I, D, Y. Ele removeu a versão anterior e agora está a versão mais atual. Tá bom pessoal? Então, por essa aula é só. Espero que tenham gostado dessa. E até a próxima.
Nenhum comentário ainda (loading...)
Nenhum comentário ainda (loading...)
Gostou da aula? 😆👍
Apoie nosso trabalho com uma doação: