Version control Git -Lecture-2

Version
Control
GIT
DevOps course by Abdul Rahim

Basic Git Commands
git --version git init git merge
git config --list git add <options> git rebase
git config --help git rm/mv <options> git push
git config --global git commit <options> git pull
git log git diff git checkout
git status git reset git fetch
git stash git branch git add origin
git stash apply

Git Branching Strategy /
Workflow
Build your strategy from these three concepts:
– Use feature branches for all new features and bug fixes.
– Merge feature branches into the main branch using pull
requests.
– Keep a high quality, up-to-date main branch.

Git Branching Strategy /
Workflow

Git Branching
– Independent/isolated line of development
– Inexpensive/lightweight as compared to other VCS
– Way to work on different version of a repository
– Work in parallel
– Master is the default branch
– Branches are just pointers to commits
– Protected branches

Branching Model

Git Branching Commands
– List Branches: git branch
– List all Branches: git branch -a
– Create Branch: git branch [branch_name]
– Delete Branch: git branch -d [branch_name]
– Delete remote Branch: git push origin --delete [branch_name]
– Create Branch and Switch: git checkout -b [branch_name]
– Switch Branch: git checkout [branch_name]

LAB - Branching
1. Create Branch
2. List Branches
3. Switch Branch
4. Commit to new Branch
5. Rename Branch
6. Delete Branch

LAB 1- Create Branch
– Create a new branch called “test-branch” by using
the command:
git branch test-branch

LAB 2- List Branch
– List local branches by using the command:
– git branch OR git branch --list
– List remote branches by using the command:
– git branch -r
– List all branches by using the command:
– git branch -a

LAB 3- Switch Branch
– In order to commit to new branch, first you will have to
switch to newly created branch, using the command:
git branch test-branch
– To know about current branch run the command:
git status

LAB 4- Commit to New
Branch
– You have already switched to testing branch. Next
create a file “test-branch.txt” in new branch and
commit by using the command:
git add test-branch.txt
git commit -m "create test-branch.txt file for test-branch"

LAB 5- Rename Branch
– Rename the “test-branch” branch to “new-test-
branch” using the command:
git branch -m test-branch new-test-branch

LAB 6- Delete Branch
– In order to delete the branch first you will have to switch
to another branch i.e. master in this case.
git checkout master
– Delete the “new-test-branch” branch using the
command:
git branch -d new-test-branch

Git Merging

Git Merging
– Combine multiple branches into one
– Combines multiple sequence into unified history
– Commands
– Merge branch into active branch: git merge [branch-name]
– Merge branch into target branch: git merge [source-branch] [target-
branch]

MERGING - FAST
FORWARD

MERGING – 3 Way

MERGING – Resolving
Conflict

LAB - Merging
1. Fast Forward merge
2. Three way (3 Way) Merge
3. Resolving Conflict

Lab 1- Fast Forward
Merge
You will first create a new branch and then add commit to
it and then merge new branch to master branch.
– Create a new branch and checkout:
– git checkout -b ffm-branch
– Create a new file, add, and commit to branch:
– git add merge-ff.txt
– git commit -m “add merge-ff.txt”

Lab 1- Fast Forward
Merge
– Merge “ffm-branch” to master branch:
– git checkout master
– git merge ffm-branch
– Check master logs for fast forward merge:
– git log --oneline --graph –decorate
– Delete “ffm-branch” branch:
– git branch -d ffm-branch

Lab 2- Three Way Merge
– You will first create a branch, then make a commit to it, then
switch to master branch and make a commit to it so that it
moves ahead from where the new branch was created, then
merge new branch to master.
– git checkout -b twm-branch master
– git add merge-tw.txt
– git commit -m “add merge-tw.txt”

Lab 2- Three Way Merge
– Move to master branch
– git add master-merge-tw.txt
– git commit -m “add master-merge-tw.txt”
– Merge “twm-branch” to master branch:
– git merge twm-branch
– Check master logs for fast forward merge:
– git log --oneline --graph –decorate
– Delete “ffm-branch” branch:
– git branch -d twm-branch

Lab 3- Resolving Conflict
You will first create a branch and then edit an already existing
file, next you will switch to master branch and edit the same file
in a way that both changes conflict with each other.
– git checkout -b conflict-branch master
– Edit an existing file master-merge-tw.txt on conflict branch and
append Hello World:
– git commit -m “modified master-merge-tw.txt”

– Move to master branch
– Edit an existing file master-merge-tw.txt on master
branch and append Hello:
– git commit -m “modified master-merge-tw.txt on master branch”
– Merge “conflict-branch” to master branch:
– git merge conflict

– You will encounter a merge conflict, run the command:
– git status
– Open the file with the conflict “master-merge-tw.txt” and resolve
the conflict. Once conflicts are resolved add and commit file again
– git commit -m “conflict resolved master-merge-tw.txt”
– Delete “conflict-branch” branch:
– git branch -d conflict-branch

Rebasing
– Alternative to integrate changes from one branch
to another
– Changes the base of your branch from one commit
to another
– Integrates upstream changes into your branch
– Linear history
– Command: git rebase

Rebasing

Rebasing vs Merging
– Rebase
– Streamlines a potentially complex history.
– Avoids merge commit “noise” in busy repos with busy branches.
– Cleans intermediate commits by making them a single commit, which can be
helpful for DevOps teams.
– Merge
– Simple and familiar.
– Preserves complete history and chronological order.
– Maintains the context of the branch.

LAB - REBASING
– You will first create a new branch “rebase-branch”.
– Next add a file “rebase-file.txt” commit to “rebase-branch”.
– Switch to master branch.
– Now edit an existing file “master-merge-tw.txt” on master branch,
– Switch back to new branch and then rebase: git rebase
– This will move the base of your branch from earlier commit to
current master branch commit.

Stashing
– Why do we need Stashing?
– Saves you uncommitted code for later use
– Reverts changes from your working copy
– You can make changes, create new commits, switch branches, and
– perform any other Git operations and then re-apply your stash when
– you're ready
– Local to your Git Repo

Stashing Commands
– List Stashes: git stash list
– Stash Changes: git stash
– Apply Stash: git stash apply or git stash pop
– Clear all Stashes: git stash clear
– Stash with description: git stash save "message"

LAB - Stashing
1. Stash Changes
2. Apply Stashed changes

LAB 1 – Stash Changes
– You will create a branch and move into it
– git branch stash-example
– git checkout stash-example
– Now make some changes and check state of working
directory
– git status
– Now stash your changes
– git stash

LAB 1 – Stash Changes
– To see stash changes run the command
– git stash list
– Check state of working directory
– git status
– After stashing the changes your working directory will be clean

LAB 2 – Apply Stashed
changes
– You will reapply your stashed changes
– git status
– Reapply your stashed changes:
– git stash pop
– git status
– You will see the changes you stashed earlier

Tagging
– Allows you to give commit a name
– Mark important checkpoint in the project
– Tags
– Annotated: extra metadata e.g. tagger name, email, and date.
– Lightweight: only tag name
– Branch that doesn’t change
– You can checkout to them

Tagging Commands
– List tags: git tag -l
– Lightweight tag: git tag
– Annotated tag: git tag -a -m
– Tag Details: git show
– Delete tag: git tag --delete

LAB - Tagging
1. Create Lightweight & Annotated Tag
2. List Tags
3. Tag Old Commit
4. Get Information On a Tag
5. Delete Tags

LAB 1- Create Lightweight
& Annotated Tag
– Create lightweight tag on latest commit:
git tag "first-tag“
– Create annotated tag with message on latest commit:
git tag -a "second-tag" -m "tag-test"

LAB 2- List Tag
– List tags using commands:
git tag -l
– You will see the list of tags i.g. ?rst-tag and second-tag

LAB 3- Tag Old Commit
– List old commit:
git log –n3
– This will show list of last three commits
– Copy the hash of second last commit and tag it using the
command:
git tag "third-tag"

LAB 4- Get Information On
a Tag
– Get information on a lightweight tag:
git show first-tag
– Get information on an annotated tag:
git show second-tag

LAB 5- Delete Tags
– Delete all the created tags:
git tag --delete first-tag
git tag --delete second-tag
git tag --delete third-tag

Pull Request
– Method of submitting contribution
– Makes collaboration easier
– Workflow
– Create Branch
– Make Changes
– Create Pull Request
– Merge Once Approved

Lab - Pull Request
– You will first create a new branch “pull-request-branch”.
– Next add a file “pull-request-file.txt” commit to “pull-request-
branch”.
– Now push changes to repository “pull-request-branch” branch.
– You will create a Pull Request from pull-request-branch to master
branch. Create a pull request for Github repository page and click
on "Pull Request" button in the repo header

Forking
– Copy of a repository
– Server-side copy as compared to clone
– Allows to freely experiment without affecting the original
project
– Use Cases
– Propose changes to someone else's project
– Contribute to open source projects

Lab - Forking
– You will fork a repository from GitHub this will create your server-side copy of
repository, then you will clone repository, then make changes and push them to
your copy of remote repository
– On GitHub, navigate to the hello repository. In the top-right corner of the page,
click Fork
– On GitHub, navigate to your fork copy. Under repository name click code
button, and copying the link. Go to the git bash and run clone command.
– Create, add, and commit and push a new file.
– Now create a pull request by using your branch of forked repo.

Contribute to Open Source
Projects
– Fork the Project
– Clone your copy of Project
– Create an upstream remote and sync local copy
– Do the work
– Push to your remote repository
– Create a new Pull Request in GitHub
– Review by Maintainers
– Respond to any code review feedback

Best Practices
– Don't commit directly to master
– Create .gitignore file for your projects
– Don't store credentials as code/config in GitHub
– Write meaningful commit message
– Test Your Code Before You Commit
– Use Branches
– Always pull the latest updates
– Protect your project
– The more approvals, the better
– Rebase your branches periodically
– Agree on workflow

Git PlayGround
– http://git-school.github.io/visualizing-git/
– https://learngitbranching.js.org/?NODEMO
– https://learngitbranching.js.org/

Reference
– https://docs.microsoft.com/en-us/azure/devops/repos/git/git-branching-
guidance?view=azure-devops
– https://www.w3docs.com/learn-git/git-rebase.html
– https://www.git-
tower.com/learn/git/glossary/rebase/#:~:text=In%20Git%2C%20the%20rebase
%20command,straight%2C%20linear%20succession%20of%20commits.

Version control Git -Lecture-2

More Related Content

What's hot (20)

Similar to Version control Git -Lecture-2 (20)

Recently uploaded (20)

Version control Git -Lecture-2