DevOps Tools/SCM/Git

Overview | Continuous Integration (CI) | Source Control Management (SCM) | Containerization | Configuration | Integration

Git

Install and Configure

Done on CentOS 7. Serves as an agentless server and client. You can use this package to create a local repository as well as other git functions.

~$ yum install git

Setup global parameters

~$ sudo git config --global user.name "global username"
~$ sudo git config --global user.email "email address"
~$ sudo git config --system core.editor "/bin/vim"

Configuration Files

At the time of this writing, Git has (4) potential places for configuration files:

System

Having the most weight, this is located in the main directory. It applies to the entire system.

$(prefix)/etc/gitconfig

Global

With the second heaviest weight, this file does not exist by default. It is user specific.

~/.gitconfig

Custom

Another file that does not exist by default it lives in one of (2) places. It is also user specific.

$XDG_CONFIG_HOME/.config/git/config
$HOME/.config/git/config

Repository (Local)

And last the repository specific config file, sometimes referred to as local.

$GIT_DIR/config

Initializing Local Repo

Create a local directory with nothing in it. This is called initializing the repository

~$ mkdir ~/repo
~$ git init ~/repo
Initialized empty Git repository in /home/user/repo/.git/

Set repo user & email, if you want something different from the global.

~$ git config user.name "user"
~$ git config user.email "user@example.com"

git clone

You can also initialize a directory by simply doing a git clone of the repo. Without a specified directory, a new folder will be created based on the name of the repository.

~$ git clone git@gitlab.local:infrastructure/ansible.git

multiple repos/ssh keys

Personally, I found the simplest way to deal with multiple repos that need different ssh keys is to utilize a parent .gitconfig that lives in the user home directory along with individual .gitconfig files that live in the parent folder of each project (not the repository folder).
for example:

home/.gitconfig
home/git/project-1/.gitconfig
home/git/project-2/.gitconfig

home .gitconfig

~$cat $HOME/.gitconfig
# project-1 user
[includeIf "gitdir:~/git/project-1/"]
  path = ~/git/project-1/.gitconfig
# project-2 user
[includeIf "gitdir:~/git/project-2/"]
  path = ~/git/project-2/.gitconfig

parent .gitconfig

~$ cat $HOME/git/project-1/.gitconfig
[user]
  name = My Project-1 Account Name
  email = my-project-1-email@project-1.com

[core]
  sshCommand = "ssh -i ~/.ssh/project-1_id_rsa"

Basics

add

adds a new file to the repo.

~$ git add filename
~$ git add *    ---- adds everything in the current directory
~$ git add .     ---- adds everything in the current directory

status

shows the current status of the git repository

~$ git status

commit

Commits the changes to the repo

~$ git commit -m "comment on commit"

commit anything that is staged, but not anything that is untracked.

~$ git commit -a

delete

deletes a file from the git repo. you must delete the file first.

~$ rm filename
~$ git rm filename

log

Shows you a log of all the commits and changes.

~$ git log
~$ git log --oneline       -----  shows the logs in a single line
~$ git log -p                  ----- shows details of the changes per line per log.
~$ git log --author="username"          ------- shows logs of a certain user
~$ git log --grep="search term"                 ------- shows logs of changes that match the search term
~$ git log --graph --decorate   ------ shows a directory tree view of the changes.

clone

Clones a git repository

~$ git clone "local path"
~$ git clone user@hostname:repo_directory   ---   assumes the repo directory is in the remote user's home directory.
~$ git clone https://github.com/repository/project.git
~$ git clone https://username@github.com/username/repository.git

push

push changes to repo

~$ git push origin master

pull

pull changes from repo to local

~$ git pull origin master

pull changes from a feature branch

~$ git pull origin feature/branch_name

ignore

Ignore file types in local/specific repository

~$ vim .gitignore
#local git ignore in specific repo
*.filetype
/ignored_directory/*

merge

merges two branches together. start by selecting the branch you want to merge another branch into.

~$ git merge branch_name

rm

remove a file from the repo and local

~$ git rm {file name}

reset

reset any adds

git reset

reset the local branch and remove any local commits

git reset --hard origin/master

Global Settings

exclude

Show excluded files

~$ git config --global core.excludesfile

Exclude file/path

~$ git config --global core.excludesfile '/etc/gitignore'

Manually ignore files via exclude file

~$ sudo vim /etc/gitignore
# globally ignore files based on type
*.filetype

Branch

Determine current branch

~$ git branch

Create new branch

~$ git branch new_branch

Select new branch

~$ git checkout branch_name

Create new branch and select at the same time

~$ git checkout -b new_branch

List all branches

~$ git branch -a

Examples

Clone new project and push initial commit

Assuming you've created the project in GitLab already. This is also using a non-standard port.

~$ git clone ssh://git@gitlab01.r00tedvw.com:8922/user/project01.git
~$ cd ./project01
~$ touch README.md
~$ git add ./README.md
~$ git commit -m "initial commit"
~$ git push ssh://git@gitlab01.r00tedvw.com:8922/user/project01.git master

Create a new branch for changes, then merge into master

~$ git pull origin master
~$ git status                                                                                  
On branch master
~$ git checkout -b new_feature_01                                     #create a new branch and switch to it
Switched to a new branch 'new_feature_01'
~$ git status
On branch new_feature_01
~$ vim ./index.html                                                   #new changes
~$ git add .                                                          #add new files
~$ git commit -m "html index"                                         #commit changes
~$ git push ssh://git@gitlab01.r00tedvw.com:8922/user/project01.git new_feature_01              #push changes to branch
~$ git checkout master                                                #switch back to master branch
~$ git pull origin master                                             #pull master branch down (overwrites local changes committed to new branch)
~$ git merge new_feature_01                                           #merge new branch into master
~$ git push origin master                                             #commit changes to master
~$ git branch -d new_feature_01                                       #delete new branch (local)
~$ git push origin --delete new_feature_01                            #delete new branch (remote)

Update existing branch

~$ git checkout branch01
~$ git add .
~$ git commit -m "new commit message"
~$ git push origin branch01