Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Laboratório de Git

Resumo dos conceitos de Controle de Versão Centralizado, principais conceitos e comandos do Git.
by

Marcio Rosner

on 29 October 2014

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Laboratório de Git

Explorando
a ferramenta
Pegue o GIT:
Laboratório de Git
Características do Git
Identifica versões por Hash SHA-1, garantindo também a integridade: não é possível modificações ou corromper arquivos sem o git saber
Experimentação descartável:testar novas idéias de forma independente.
Reversão do commit remoto
Edição e correção do commit local
Mudança de tarefa instantânea: Área de stash (trabalho incompleto)
Rastreamento de revisões: MERGE fácil e automático (3-way merge)
Integra com o SVN se necessário
Permite desenvolvimento orientado a tarefa: uma branch por tarefa (cada mudança reflete uma tarefa)
Exercícios:
http://git-scm.com
Conceitos e Comandos básicos
Manual do GIT:
http://git-scm.com/book/pt-br
Configurando
git config --global user.name "Marcio Rosner"
git config --global user.email "marcio.rosner@tse.jus.br"
Help
git help "comando"
Alguns comandos básicos
git clone :
cria uma cópia local de um repositório remoto (na pasta atual).
git add . :
adiciona todos os arquivos (fora do controle de versão e os modificados) ao stage
git commit -m "primeiro commit" :
faz o commit
git status :
mostra o status dos arquivos na pasta local
git commit -am "mensagem" :
comita diretamente sem passar pelo staging area
git log :
exibe o histórico com informações dos commits
git checkout <branch> :
move o ponteiro de HEAD para o destino, neste caso, muda para a branch informada (se já existe).
git checkout -b <branch> =
git branch <nome> :
cria uma nova branch (a partir do commit atual, ie, apontado pela HEAD)
git branch + git checkout
HEAD =
referência (ponteiro) para onde estamos (branch, commit ou tag)
git checkout <hash> -- <arquivo> :
traz o "arquivo" no commit "hash"
git tag <nome>:
git tag <nome> <hash>:
git tag <nome> -a -m "msg"
cria uma tag (à partir do commit apontado por HEAD). se for passado também o <commit>, cria a tag para este. "-a" = tag anotada.
git reset <commit> :
seta a HEAD da branch atual para o commit informado. Com --hard, atualiza os arquivos locais. Ou seja, está voltando no histórico !
git merge <outraBranch> :
faz o merge na branch atual do conteúdo da outraBranch
Comandos Especiais
Obs.: Se for o caso, use
git status
para ver os conflitos
.
$ git checkout experiment
$ git rebase master
First, rewinding head to replay your work on top of it...
Applying: added staged command
Com rebase:
Trabalhando com repositórios remotos
master =
branch de desenvolvimento default
origin =
repositório remoto default (Origin é uma convenção para o primeiro remote). Ex.:
git.tse.jus.br
Criado por
Márcio Rosner


Aumentando o Buffer
git config --global http.postBuffer 524288000
Controle de Versão
Apóia o desenvolvimento com:
Histórico
Quem fez o quê, quando e onde.
Colaboração
Vários trabalham em paralelo (sem sobrescrever o trabalho do outro)
Variações no projeto
Linhas diferentes de evolução do mesmo projeto.
Controle de Versão
Topologia em estrela (cliente-servidor).
Único repositório central e várias cópias de trabalho.
Centralizado x Distribuído
múltiplos repositórios locais em vez de apenas um único central.
o acesso a rede só é necessário para sincronização.
o trabalho continua mesmo sem conexão: maior parte das operações (e processamento) são locais.
a conexão ao repo central é pré-requisito para o trabalho: a comunicação de 2 áreas de trabalho passa pelo servidor.
grandes projetos + muitos acessos = deteriora acesso ao servidor (+banda, + processamento).
Vantagens do modelo distribuído
Maior rapidez
Autonomia
Ramos privados sem interferir nos demais
Facilidade na mesclagem
Maior confiabilidade
Redução de custos no servidor
ramos são criados no repo central
ramos privados são locais: permite desenvolvimento orientado à tarefa com experimentação descartável.
mesclagem automática por DAG (Grafo Acíclico Direcionado) - 3-way-merge
repo central = processador central das requisições
os repositórios dos desenvolvedores são backup
Centralizado
Distribuído
Obs.:
- alterações no Master podem ser sobrescritas por um pull
- e um conflito no Master paralisa seu trabalho
git remote add origin repo
(Adiciona um repositório como remoto)
git push origin <branch>
(Envia os commits locais para o repositório remoto em um
determinado branch)
git pull
(Atualiza a partir do repositório remoto default, o origin)
Similar a usar "fecth" + "merge")
git fetch origin
(Traz as mudanças do repositório remoto, mas não integra ao HEAD)
git push origin master
git push origin v1.0
(Envia a tag v1.0)
git push --tags
(Envia todas as tags)
Help:
git help <comando>
"Fast forward"

=
merge de um commit com outro que pode ser alcançado seguindo o histórico do primeiro, o Git move o ponteiro adiante
Estratégias de ramificações
Manutenção caótica (organização imatura)
Estratégias de ramificações
Objetivos de uma estratégia de ramificação:
Desenvolvimento em paralelo

Isolamento entre desenvolvedores e equipes
customização para diferentes clientes ou plataformas
outros...
ramo principal com evoluções e correções
impossível separar correção de evolução
usuários de uma versão recebem nova funcionalidade junto com correção
Estratégias de ramificações
Manutenção em série
ramo principal com evoluções
ramos auxiliares com correções
foco em cliente único
Estratégias de ramificações
Uma branch por feature
ramo principal para integração
ramos auxiliares com features
permite a identificação de cada feature
possibilita a remoção de uma feature
trabalho em paralelo e independente
Obs.: integração deve ser frequente
funcionalidade, correção de bug, tarefa, história ou qualquer segmento de trabalho.
agrupa o trabalho a ser feito de forma funcional
permite o desacoplamento das features
builds e testes independentes: um commit de um desenvolvedor não quebra o trabalho do outro
tem vários commits
toda a feature é integrada, e não commits individuais.
cada feature pode gerar uma release para produção
RAMIFICAÇÕES
Alterando Merge, conflitos e histórico
git cherry-pick
Melhor opção quando as branchs divergem (e o merge não interessa)
git cherry-pick <hash do commit>
: cria um novo commit
git cherry-pick -n <hash do commit>
: não cria um novo commit
git cherry-pick -x <hash do commit>
: cria o commit com uma msg indicando de onde a mudança original veio
Aplicando um commit em outra branch
git cherry-pick C D E
Resolvendo Conflitos
identificando o conflito
resolvendo o conflito manualmente:
$git commit -am "conflito resolvido"
vendo o conteúdo do arquivo com conflito
resolvendo o conflito graficamente:
$git mergetool"
Sugestão: instale o KDiff3 e altere o .gitconfig para:
escolha uma versão para sobrescrever o conflito:
$git checkout --theirs (--ours) -- teste.txt
Trabalhando no Projeto
1-
Clonar o projeto (é criada a branch MASTER)
2-
Crie uma nova branch com o nome "BUGZILLA-X" para fazer o trabalho (vários commits)
3-
Volte a branch MASTER e atualize-a (PULL)
4-
Se houve mudanças na Master, volte a branch do SISSOL para atualizá-la com o REBASE
5-
Envie a branch "BUGZILLA-X" para o servidor: PUSH
6-
Entre no site http://git.tse.jus.br e crie um MERGE REQUEST
Merge: apenas fastfoward
git config --system receive.denyNonFastForwards true
Pull sempre com rebase
git config --global pull.rebase true
SSH Key
ssh-keygen -t rsa -C "marcio.rosner@tse.jus.br"
1 - clonar o projeto:
git clone git@git.tse.jus.br:marcio.rosner/projetoexemplogit.git
a) Acesse pelo browser e copie o link do projeto:
b) Pela linha de comando (git bash):
mkdir projetosGit
cd projetosGit
http://git_clone.tse.jus.br/forks/projetoexemplogit
2 - alterar arquivo 02_fontes\script.txt em nova branch:
git commit -am "marcio rosner alterou linha 1"
a) Criar nova branch com nome da demanda:seu nome.
b) alterar arquivo script.txt e realizar commit:
cd 02_fontes
vi script.txt
git checkout -b marcio_rosner
3 - criar merge request
a) Acesse pelo browser:
b) selecione o botão "create merge request"
http://git.tse.jus.br
4 - atualizar a master, e fazer rebase:
a) volte a branch master
b) atualize realizando prune:
git checkout master
git pull origin master
5 - criar branch teste, fazer commit e corrigir commit:
a) volte a branch master e atualize-a
b) criar branch teste e ir para ela:
git checkout master
git checkout -b teste
c) faça alteração no arquivo 02_fontes\script.txt, faça commit e corriga o commit (com nova alteração):
cd 02_fontes
vi script.txt
git commit -am "alteracao 2"
git commit --amend
6 - voltar versão do projeto e criar tag:
a) na branch teste, renomeie para
teste_seunome
:
c) criar tag
git reset --hard HEAD~1
git tag -a -m "nova versao" v1.0
git push origin marcio_rosner
c) enviar a nova branch para o servidor (origin):
c) selecione Daniel Pereira (ou Marcio Rosner) para fazer o MR.
c) Fazer rebase do master na sua branch:
git checkout marcio_rosner
git rebase master
e) Após o rebase, apagar e reenviar a branch para o servidor:
git push origin :marcio_rosner
vi script.txt
Relembrando o merge:
git push origin marcio_rosner
Apagar a branch remota:
Reenviar a sua branch:
d) se der conflito no REBASE:
edite o arquivo
marque resolvido:
finalize o rebase:
git rebase --continue
git add 02_fontes/script.txt
git pull origin master
(ou use um editor de texto do windows)
(alterando novamente o arquivo)
(corrigindo o commit anterior)
b) volte todo o projeto 1 commit atrás
git branch -m teste teste_seunome
d) envie sua branch teste para o servidor com as tags:
git push origin teste_seunome --tags
UNGIT - Ferramenta visual para Git
Full transcript