Aula 13
Como Fazer o Lançamento de uma Versão Maior v1 para v2 de um Módulo de Golang
Summary
Resumo da Aula de Golang: Lançando uma Nova Versão de Módulo
Introdução
Na aula de hoje, o instrutor ensina sobre módulos em Golang, especificamente como lançar uma nova versão de uma biblioteca que quebra a compatibilidade com versões anteriores.
Estrutura da Aula
-
Descrição do Módulo
- O módulo é uma biblioteca que oferece uma função chamada
novoLivro
. Esta função retorna um ponteiro para uma estruturaLivro
, que contém informações comopublicado em
etítulo
.
- O módulo é uma biblioteca que oferece uma função chamada
-
Versão Atual
- A biblioteca está na versão 1.0.3 e é usada por outro módulo chamado
consumidor
.
- A biblioteca está na versão 1.0.3 e é usada por outro módulo chamado
-
Quebra de Mudanças
- Para a nova versão, uma mudança simples será feita: a ordem dos parâmetros da função
novoLivro
será alterada, o que quebra compatibilidade com os consumidores da biblioteca.
- Para a nova versão, uma mudança simples será feita: a ordem dos parâmetros da função
-
Métodos para Lançar uma Nova Versão
- Método 1: Criar um Novo Diretório
- Copiar todos os arquivos para um novo diretório chamado
v2
e aplicar as mudanças.
- Copiar todos os arquivos para um novo diretório chamado
- Método 2: Criar um Novo Branch
- Criar um branch (galho) no repositório que representa a nova versão, por exemplo,
v2
.
- Criar um branch (galho) no repositório que representa a nova versão, por exemplo,
- Método 1: Criar um Novo Diretório
-
Demonstração Prática
- O instrutor demonstra como criar o branch
v1
para armazenar a versão atual antes de fazer as mudanças nomaster
. - A mudança é feita e a tag
v2.0.0
é adicionada ao repositório.
- O instrutor demonstra como criar o branch
-
Atualização do Consumidor
- O módulo consumidor precisa remover a versão antiga e fazer as alterações necessárias nos imports e chamadas da função para utilizar a nova versão
v2
.
- O módulo consumidor precisa remover a versão antiga e fazer as alterações necessárias nos imports e chamadas da função para utilizar a nova versão
-
Verificação de Compatibilidade
- O instrutor verifica que tanto a versão nova quanto a versão antiga funcionam independentemente e descreve o uso do comando
go mod tidy
para limpar dependências não utilizadas.
- O instrutor verifica que tanto a versão nova quanto a versão antiga funcionam independentemente e descreve o uso do comando
Conclusão
A aula finaliza com um convite para os espectadores se inscreverem e comentarem, e agradecimentos pela participação.
Essa aula fornece uma compreensão prática sobre como trabalhar com versões de módulos em Golang, destacando a importância de manter compatibilidade e as estratégias para gerenciar versões de forma eficiente.
Video Transcript
Olá pessoal, estamos de volta com mais uma aula de Golang. Vamos falar de módulos
nesta aula e eu vou te ensinar como lançar uma versão nova de versão 1 para a versão 2
de uma biblioteca de Gol. Vamos fazer o seguinte, eu tenho aqui um módulo de Gol que é uma biblioteca,
essa biblioteca é usada por outros módulos de Gol, então a dependência de outros programas que
são os consumidores dessa biblioteca. Então está na versão 1 maior, mas eu queria lançar a nova
versão, versão 2 que iria quebrar umas mudanças, essa versão 2 terá mudanças que irá quebrar o código
dos consumidores da dependência se eles utilizarem a nova versão. Então vamos lá, para demonstrar isso
teremos dois módulos separados, o que está aberto aqui é meu arquivo gol.mode do meu primeiro
arquivo que é 0021 golmódulo biblioteca. Então esse primeiro repositorio tem o golmode que define o
módulo e tem um arquivo livre.go que é a função aqui que eu quero disponibilizar para os outros
programas usarem, neste caso a função novo livro, função bem simples, eu tenho uma estrutura aqui
o livro que representa um livro, um livro no ano de publicação chamado publicado em e a propriedade
título. A função novo livro leva dois argumentos, o primeiro publicado em que é o inteiro e segundo
título que é um string, essa função retorna um ponteiro para o livro que é um struct. Então
eu vou usar um livro literal aqui e retorno com 1%. Publicado em e o título, então ele que apenas cria
uma nova instância de um livro. Esse módulo está na versão 1 maior. Deixe-me mostrar aqui
ele já hospedado no GitHub, se eu clicar tags eu já adicionei a tag para cada comete dele. Então a versão
mais atual a versão 1.0.3, remedo 3, maior 1. Voltando no editor de texto tem uma outra pasta
chamada 0021 traço-go, traço-módulo, traço-consumidor. Essa pasta requer tem como dependência a biblioteca
que a gente acabou de ver no outro diretório. Eu estou usando a versão aqui 1.0.3. E é um programa bem
simples no arquivo main.go, tem a funk main que é a função principal, chama o método novo livro do
nosso pacote biblioteca. Noja que o diretório da biblioteca tem um arquivo lebe.go, mas eu defino
o package com biblioteca, por isso que aparece lá no consumidor biblioteca. Não tem a ver com o nome do
arquivo nem com o nome do diretório na hora de referenciar o nome do pacote. É claro que para ficar
com as coisas seria melhor você nomear o pacote na mesma nome que o arquivo e que o nome do
projeto. Depende, se tiver múltiplos pacotes, mas tiver só um seria ideal. De qualquer maneira, o
nome do pacote definido no arquivo é que vai ser referenciado lá do consumidor. De volta ao diretório
do consumidor main.go, quando a gente faz um import com o caminho do módulo que é o gethaw.com,
nvkmundo.tech, 0 0 21 traço go, traço módulo, traço biblioteca, ele vai disponibilizar aquele
package chamado biblioteca. Então eu posso dizer biblioteca. novo livro e passo com os argumentos
do primeiro, que é o ano de publicação do livro e o segundo o título. Eu passei 1857,
isso retorna o ponteiro para o livro, mas o livro está dentro de biblioteca, então eu tenho que
dizer estrelabiblioteca.livro. Amazônia isso não variava e aprendam que chamam println do pacote
FMT. Bem simples, não tem nada demais, é só para demonstrar o lançamento de uma alversão no
módulo da biblioteca. Vamos supor que lado da biblioteca, de volta ao diretório da biblioteca,
leib.goarchivo, na linha 10, vamos supor que eu vou quebrar essa função, isto é, eu vou modificar
a assinatura da função, o comportamento dela para ser diferente do original. Eu vou fazer uma coisa bem
bem simples, vamos mudar a ordem dos parâmetros. Em vez de ser publicado em primeiro e título segundo,
o título vai ser título como primeiro parâmetro, vírgula publicado em como segundo. Se eu fizer isso,
é claro que vai quebrar lá o pacote consumidor, porque ele teria que trocar o argumento 1 com
argumento 2. Então, isso que eu vou fazer. Para poder lançar a alversão, qual é a maneira?
Tem duas maneiras principais, uma maneira é você criar um diretório, copiar os arquivos
para aquele diretório e implementar a nova versão só com aqueles arquivos naquele diretório.
Claro, eu acho que eu não sou fã desse porque tenho que fazer uma cópia, eu prefiro usar controle
no caso de um diretório, que é o segundo, a segunda maneira. A segunda maneira é você criar um
branch, um galho no get branch e esse branch você chama do nome da versão. Por exemplo,
pode ser a versão nova ou pode ser a versão antiga, você escolhe, eu prefiro a nova lá. Não, eu prefiro a
antiga, eu acho. Então, você pode criar esse branch e chama v, por exemplo, se você escolher que o
branch vai armazenar na alversão, eu chamo o branch nesse caso de v2, o nome do branch é v2. Se eu
quiser armazenar a versão velha no branch, que é que eu prefiro, eu vou dizer que esse novo branch
vai armazenar a versão v1 e ele vai capturar o código da versão 1 nesse branch v1. Aí o da v2 vai ser
o branch principal, que é o master, no meu caso. Então, você escolhe, se quiser fazer do novo, o branch
vai ser o novo ou o branch vai ser a versão velha. Se você fizer a versão velha, como acabo de dizer,
o branch principal sempre vai ser a versão mais nova. Se você fizer o contrário, então o branch
principal, nesse caso, seria a versão antiga e você criaria v2 para o branch da versão nova.
Então, vamos ver isso na prática. Vamos lá. Vou demonstrar, vamos ver o que eu faço. Eu quero focar
o branch, mas eu vou demonstrar só rapidinho o da pasta. Então, essa parte inicial é diferente,
mas o resto que a gente vai fazer é similar. Então, a parte de criar pasta, se você escolher
para criar pasta, eu criaria aqui a pasta aqui, chamaria de v2, mas tem que copiar todos os arquivos
que você tem aqui para a pasta v2. Então, copia aqui o código.
Basicamente, tem que copiar tudo, né? Seria mais rápido não terminar, mas deixa.
E aí
E aí, agora vamos lá no gmod desse de dentro. Você vai colocar a barra v2,
no caminho é adiciona sufix v2. Aí você faz as mudanças aqui no novo código, por exemplo,
para trocar a ordem dos parâmetros. Está aí pronto, já estaria preparado e ia para a próxima
etapa que eu vou explicar depois. Agora eu vou reverter e vou explicar do branch.
Vou ver se está aí. Vou ver ver. Vou fazer o do branch. Vou ver aqui. Estou no
módulo consumidor, quero para o módulo biblioteca. Ok, então, que branch eu estou?
O branch no principal que é master. Qual é a minha tag agora? Se eu olhar o log, o master
agora está 1, 0, 3. Ok, então vou falar get, checkout, traço b. Eu vou falar v1.
Ok, agora o v1 está apontando até aqui, esse commit, que é a versão anterior. Agora eu vou fazer o
odynamic, vou voltar para o master. Agora eu vou modificar o code como se fosse a nova
versão. Então, se eu voltar o meditor de texto, libe.go, troca a ordem dos parâmetros do
método de função novo-lib. Troquei. Vou fazer o commit. A ordem dos parâmetros foi trocada.
Ok, mas eu também tenho que mudar a versão aqui do go-mode para o suffix barra v2 no caminho
do módulo. Vou deixar isso um nice também. Da ordem de parâmetros de novo-lib.
Ok, vamos supor que você tenha vários commits, até que chegou ao ponto de lançar.
Ok, então vamos lá. Eu vou fazer get tag, espaço v2.0.0. Eu vou dar push, traço, traço tags e push normal.
A ordem do espaço master, a mesma coisa, que é o meu principal. Se eu olhar no get hub, atualizar tags, agora tem 2.0.
Se eu olhar aqui e comparar com a versão anterior, eu vejo que agora é barra v2 no go.mode e os parâmetros foram trocados.
Agora vou lá no pacote consumidor e verificar.
Então, esse processo que eu acabei de fazer vai na mesma na maneira de criar o diretório.
Se você tem o diretório lá v2, você iria fazer a tag naquele ponto.
Vamos ver o módulo consumidor para o módulo consumidor.
Para poder usar a nova versão do consumidor, você teria que estar lá como se fosse o novo módulo, porque o caminho seria diferente, com barra v2.
Então seria no terminal, módulo consumidor, goget, getup.com, barra nvk, módulo tag, barra 0021, traço, módulo, traço, biblioteca, barra v2.
Você baixou.
No go.mode do consumidor, agora tem v2.
Se eu ir lá no main.go no arquivo e eu botar a barra v2 aqui, ele vai quebrar.
Eu fiz o upgrade do consumidor.
Se eu falar go build, quebrou porque os argumentos foram trocados.
Então, da parte do consumidor, ele teria que trocar a ordem de todas as chamadas dessa função para poder funcionar novamente.
Então, recapitulando.
Temos um repositório de um módulo de biblioteca.
Para poder lançar a versão 2,
há uma maneira de você criar um diretório, chama v2, copia todos os arquivos lá, faz as mudanças lá e aplica a tag de v2.0.0.
Outra maneira, através do branch, galhos de get.
Nesses casos, tem duas maneiras.
Você faz o branch da versão nova.
Nesse caso, seria get checkout, traço b v2, faz as mudanças lá e depois terminar a mudança, fazer o commit, aplica a tag v2.0.0.
Ou você pode fazer a maneira que eu fiz, que eu foquei aqui, que é do branch principal.
Você criou um branch com a versão vela v1, que chama de v1.
Depois, volta para o branch principal, nesse meu caso master.
Começa a fazer mudanças no master.
Depois de fazer o commit, não esqueça de mudar o go-mode, o caminho do modo tem que ter o suffix o barra v2.0.
Lá.
Aí, quando estiver feito o commit dessas mudanças, aplica a tag get tag v2.0.0.
Puxa a tag para o repositório, servidor e puxa o branch.
O branch não, o branch principal, as mudanças.
E isso lança.
E já do pacote consumidor, se ele quiser fazer o upgrade, ele teria que mudar todos os imports e adicionar o suffix o barra v2.
E modificar a chamada da, no meu caso, chamada da função.
E outros pacotes seriam outras coisas que quebraram, né?
Teria que consertar ou ajeitar, reordenar as coisas.
Tá certo? Então, deixa eu voltar o consumidor.
Como não estou usando mais o antigo.
Eu vou dar o tidy aqui para ver se ele remove o anterior.
Go-mode tidy.
Então, seria o fim do upgrade.
Mas eu quero reverter só para ver se está funcionando direito.
Então, vou reverter isso na implementação. Vou reverter v1.
E isso eu falava o build quebrou.
Ah, não tem, né?
Então, vou lá go get a isso aqui.
Vamos ver se ainda funciona a versão anterior.
Ele adicionou no go-mode v1.0.3.
Vou falar o go-mode tidy para tirar outra versão nova, que eu não uso mais.
E eu vou confirmar que realmente a versão velha ainda está lá.
Não foi quebrado.
Então, funcionou direitinho.
Então, a versão velha também é disponível para baixar, para download.
E funciona sem problemas.
A versão nova também funciona sem nenhuma interação, conflito com a versão anterior.
E de volta aqui na página do Getts, pode verificar as mudanças e tal.
Se você clicar em tags ou releases.
Tags.
Está certo, pessoal?
Então, por essa aula é só. Muito obrigado por assistir.
A peça que se inscreva, este comentário, né?
Não se esqueça das notificações.
E agradeço muito 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: