Be it a Designer, be it a Creator or be it a Developer, we all deal with projects and files every day. Our primary work-cycle revolves around creating a file, saving it, editing or making required changes and saving it again. In this Git Tutorial, we will be focusing on the life of a Developer, and therefore understand What is Git.
Git is a small, yet very efficient version control tool. Git helps both programmers and non-programmers keeping track the history of their project files by storing different versions of their project files.
Prepare yourself for the Top DevOps Interview Questions And Answers!
Git has become significantly popular among the developers in last few years. If you are a part of developer’s world it is expected that you know Git. You must have come across the term Git many times before as well. Don’t worry if you have never used Git, because in this tutorial you will be guided through:
But before diving deep into the understanding of Git, let us discuss little bit about the basics of version control systems and why we need them in the very first place.
Git helps developers by keeping track of the history of their codes files by storing them in versions on its own server repository i.e. GitHub. Git has the functionality, performance, security and flexibility that most teams and individual developers need.
Below given graph depicts the rate of popularity that Git has gained over the years (from 2004-2018):
Now let us go ahead in this Git tutorial and learn why Git is used and what are the factors that make Git so unique.
Become Master of DevOps by going through this online DevOps training in London.
There are some facts which makes Git so popular:
Now that we have learnt what is git in this git tutorial, we will move ahead and discuss how Git works. Let us start learning the git basics, starting with the lifecycle of Git.
We have successfully committed files to our local repository. But how does it help in our projects? The answer is, when we will be doing collaborative projects, files may need to be shared with our team members. That is when the next stage of Git lifecycle occurs, which is GitHub, where we publish files from local repository to remote repository. And how do we do that? We do that by using Git push command.
Here, we have discussed the life cycle of Git project, where we came across some commands like Git init, Git add, Git commit, Git push etc. Further in this Git Tutorial, we will be explaining these common commands in more details.
But before that lets go through the Git Installation and Configuration of Git.
Go through the Best DevOps Course in New York to get clear understanding of DevOps.
For installing git on windows, click on the link given below:
For Git installation in mac, click on the link given below:
For Git installation in Linux, click on the link given below:
We have successfully installed Git in our system. Before discussing common Git commands in this Git Tutorial let us set up the environment in our systems.
After following these steps your GitHub page should look like this
Create a GitHub account
To tell Git who you are, run the following two commands:
To begin, open a terminal and move to where you want to place the project on your local machine using the cd (change directory) command. For example, if you have a ‘projects’ folder on your desktop, you’d do something like:
Creating a Local Repository
We can go to the Git folder and see the new directory that we have just created.
Now we are all set to start working on the Git commands.
Learn more about DevOps in this DevOps training in Sydney to get ahead in your career!
We will divide the Git commands into two primary categories.
let us discuss the local commands first.
Git init: Use the Git init command to initialize a Git repository in the root of the folder:
Git touch: To add files to a Project Git touch can be used. Let us see how we add a file to the Git repository we have just created
Step-1: First, we will create a new file with command touch.
Step-2: Then, we will see the files present in our master branch.
Git status: After creating the new file, you can use the Git status command and see the status of the files in the master branch.
git statusGit add: Now we will add the humble.txt file to the staging environment by using Git add before going ahead to the staging and see the change using Git status.
There you go you have successfully created your first commit.
If you have any doubts or Queries related to DevOps, get it clarifies from DevOps Experts on DevOps Community.
Before we move on to Branching and Merging operation, let us discuss the remote commands like remote, push, pull in Git, but for that, we will have to create a new repository in our GitHub account:
Step-1: Go to your GitHub account.
Step-2: Create a new repository.
Create new repository
Once you are done with filing up the new repository form you should land on a page like the following.
Now we are ready to operate remote commands in our repository that we have just created.
Interested in getting an industry-recognized certification in DevOps? Enroll in Intellipaat’s DevOps Course in Bangalore now!
To push an existing repository to remote repository from a command line follow the commands given below.
After that give the following command:
Git push origin EnterBranchName
Don’t get confused by the word origin. Let me tell you what exactly that command is referring to:
Instead of writing the whole Git URL, like: Git push Git@Github.com:Git/Git.Git yourbranchname we can give the following command: Git push origin yourbranchname.
Now let us look at our repository:
look at our repository
When it comes to syncing remote repository pull command comes in handy.
Let us take a look at the steps that leads to pulling operation in Git.
Refer the steps given below:
Now that we have learnt the workflow of Git with the help of common commands, let us take a look at Branching, Merging and Rebasing and, also how and when to use them.
Now that we are a bit familiar with let’s take a step further and discuss one of the most important operations of Git branching.
Every node in the figure above represents commits.
Note: Remember that for “y”, “x” is the base.
Let us say that you want to modify something but don’t want to make any change in the main project that is where we take a branch out of the master branch.
For instance, if you are on the master branch and want to create a new branch to add a feature in the main project.
Step-1: Run Git checkout -b <new branch name>
Step-2: Use Git branch now to confirm that your branch is created
You can see from the above image that we have created a branch called branch1 and we automatically got landed in the new branch. Again, just to see which branch we are currently in we sent another command, Git branch (* mark before the branch name defines the current branch).
Note: Now, you must be wondering how to change branch in git to master branch right? Use the following command:
git checkout master
Now, you know the most important skill set of a DevOps Engineer. But, do you know, DevOps Engineers are among the highest paid professionals in the technology domain? so join DevOps training in Hyderabad!
Now that we have learned how to create a branch and work on a branch, let us take a look at merge feature of Git by merging a branch into the master branch.
Further in this git tutorial, let’s understand merging with an example. Say, we have a master and a feature branch.
The merge commit represents every change that has occurred on feature since it branched from master.
Note: Even after merging we can go on with our work on both the master and feature branch independently.
Let us see how to perform merging using Git bash:
Step1: Create a new branch called branch2
Step2: create a new file in that branch.
Step3: Add changes from all tracked and untracked files
Note: refer the following command Git add attributes
In our case, we have given the command as Git add -A and after that, we will commit one sentence as shown below in this git tutorial.
Step4: Check the last 3 logs by giving the command as Git log -3
We have created another branch on our master branch. Now we will see how to perform merging.
Git checkout master.
Git merge branch2
Now we have successfully merged the branch into master. Let us take a look at how it looks inside the master branch using the following command.
See the graph one the left. But why the graph is linear?
In our ProjectGit master branch we did branching and committed as well. But after branching master branch had not encountered any commits. So, after merging we have seen the linear.
Let us perform Git log –graph with more than one commits in both master and developers branches that we have created.
Here you can see the graph with commits on both master and developers branch. Red parts of the graph indicate merging operation.
Now that we have successfully learned to branch and merge with Git and GitHub. Now in this git tutorial, let us look at another very important Git operation i.e. rebasing.
When the project becomes relatively large, the commit log and history of the repository becomes messy. So, we use rebasing. Rebasing will take a set of commits, copy them and store them outside your repository. That helps us maintain a linear sequence of commits in our repository.
Now in this Git Tutorial, , let us take the same example of master and feature branch. Here, we will rebase master branch. And see what happens.
Note: In rebasing the base of feature branch gets changed and the last commit of the master branch becomes the new base of the feature branch.
Now let us perform rebasing in Git bash.
Advantage of rebasing:
Disadvantage of rebasing:
Now that we understood what merging and rebasing is in this git tutorial, let us see where to use merge and where to use rebasing.
Golden rule of Git merging and rebasing:
When to use git merge:
When to use git rebase:
As we have mentioned earlier in this git tutorial, one major disadvantage of merging is merge conflicts, which can be a backbreaking work during a team project. Let us understand how merge conflict occur and how to resolve this issue.
This drawback of merging operation in Git can be explained with a simple example shown below.
Say, we have two branches of the master branch, branch1, and branch2. And two developers working on these two branches independently on the same code file.
As we have shown in the figure above, they have made below mentioned modifications:
How to merge these two modifications now? That is where our merging conflict occur.
Similarly rebasing has rebasing conflicts as well, which can also be solved with the help of Git merging tool.
Let us look at a few Git workflows briefly, before we end this tutorial, so that you get an idea which Git workflow to choose for your team project.
Why is it important to choose the right Git workflow for team project?
Depending upon the team size, choosing the right Git workflow is important for a team project to increase the productivity.
Now in this git tutorial, let us look at different Git workflows:
In Git centralized workflow, only one development branch is there, which is called master and all changes are committed into that branch itself. Below given figure in this git tutorial depicts Centralized Workflow:
Feature Branching Workflow:
In feature workflow, feature development takes place only in a dedicated feature branch. Below given figure in this git tutorial depicts Feature Branching Workflow:
In case of Git workflow, instead of a single master branch, this workflow uses two branches. Here, master branch stores the official release history whereas our develop branch acts as an integration branch for features.
Below given figure depicts Git Workflow:
In case of forking workflow, contributor has two Git repositories: one private local and one on public server-side.
This brings us to the end of the Git tutorial. In this git tutorial, we have gone through Version Control Systems and its different types, basics of Git, terminologies related to Git, Git installation in windows, Linux, mac environment, setting up and working on GitHub repository. We have also discussed workings of some important operations in Git by the end of this git tutorial.
Git and its popularity
Git is one of the most important version control systems that has experienced a significant growth rate and popularity over the years. Git plays a very important role in both developers and the non-developers world. If you are a part of soft developer’s world, it is expected that you know Git. So, having a good grasp of Git is very important.
Even Microsoft has acquired Git very recently. This opens up more possibilities for developers’ community. So, this is the right time to learn Git.
We hope you have understood Git and got the answer to what is Git and what can it do.
To have a more deeper level of understanding of different Version Control Systems with hands-on exercise you can also refer to this DevOps Certification Training Course by Intellipaat.Previous Next
Download Interview Questions asked by top MNCs in 2019?