DEV Community: Adil Shahzad

Managing Google Cloud using Infrastructure as Code (IaC)

Adil Shahzad — Sun, 14 Jan 2024 17:00:19 +0000

Infrastructure as Code

Infrastructure as Code (IaC) is a method used to manage and set up computer networks, servers, and other IT infrastructure through machine-readable files, rather than physical hardware configuration or interactive configuration tools. To understand it easily, think of it like building a model house using LEGO blocks. In traditional methods (like building a house by hand), you would manually place each brick. But with IaC, you create a blueprint or a plan that tells an automated system exactly how to build your model house. Whenever you want to build the house, you just use this plan, and the system automatically assembles the LEGO blocks as per your design.

This approach makes the entire process of managing IT infrastructure more efficient, consistent, and error-free. You can easily modify the plan if you want to change something (like adding a room to your model house), and the system will adjust everything accordingly. It's like updating your LEGO blueprint, and the model updates itself.

Understanding API

API stands for Application Programming Interface. Imagine an API as a menu in a restaurant. The menu provides a list of dishes you can order, along with a description of each dish. When you specify which dish you want, the kitchen (the system) prepares the dish and serves it to you (the user). In this analogy, the menu is the API, the order is the request, and the dish that is served to you is the response.

Now, when it comes to Google Cloud API, think of it as a specialized menu offered by a very advanced restaurant (Google Cloud). This restaurant offers a variety of dishes (services) like storing your data, running your website, or analyzing large amounts of information. Each dish/service is accessed through its part of the menu/API. So, when you ask for a specific service, like data storage, the Google Cloud kitchen works behind the scenes to provide you with that service.

In simpler terms, APIs allow different software programs to communicate with each other. Google Cloud API, in particular, lets your software access the various services offered by Google Cloud, like storing files, processing data, or even running complex algorithms.

Exploring Cloud Shell

Google Cloud Shell provides a convenient, ready-to-use command-line environment for interacting with Google Cloud services without the hassle of setting up and maintaining a separate computer or server for these tasks.

Managing Version Controlling using Git

Managing version control using Git is crucial for efficient collaboration in software development. Git allows multiple individuals to work on the same project without interfering with each other's changes. Here are the top git commands you can use , for more commands checkout here : Git Cheatsheet

1. `git init`

Usage: Initializes a new Git repository in your project directory.
Command: git init

2. `git status`

Usage: Shows the status of changes as untracked, modified, or staged.
Command: git status

3. `git add`

Usage: Starts tracking new files and stages any changes to existing files.
Command: git add <filename> or git add . (to add all files)

4. `git commit`

Usage: Records your changes as a commit with a descriptive message.
Command: git commit -m "Commit message"

5. `git push`

Usage: Pushes your commits to the remote repository.
Command: git push -u origin master

6. `git pull`

Usage: Fetches and merges changes from the remote server to your local repository.
Command: git pull

GCP Deployment Manager

Google Cloud Deployment Manager is a tool that lets you manage your Google Cloud resources using a declarative format. Here is the overview of how to write a Deployment Manager template file.

Specify the Template Version: At the top of the file, you define the version of the template that you are using. This helps the Deployment Manager understand how to process the file.
Resource Definitions: Each resource you want to create, like a virtual machine or a storage bucket, is defined in a section called 'resources'. For each resource, you provide details such as:

Name: A unique identifier for the resource.
Type: The kind of resource you want to create, like a
compute engine instance or a Cloud SQL database.
Properties: The specific settings for the resource. For
a compute instance, this could include the
machine type, the image to use, the network
settings, and more.
Configuration Parameters (optional): Sometimes, you might want to pass in parameters that can change, like the machine type or the zone you want to deploy to. You can define these parameters at the beginning of your file and reference them within your resources.
Outputs (optional): After your resources are created, you might want to output certain information, like the IP address of a virtual machine. You can define outputs to retrieve this information after deployment.

Here is the sample YAML template for Deployment Manager to create a virtual machine.

resources:
- name: my-vm
  type: compute.v1.instance
  properties:
    zone: us-central1-a
    machineType: zones/us-central1-a/machineTypes/f1-micro
    disks:
      - deviceName: boot
        type: PERSISTENT
        boot: true
        autoDelete: true
        initializeParams:
          sourceImage: projects/debian-cloud/global/images/family/debian-9
    networkInterfaces:
      - network: global/networks/default

Lab

First, access the Cloud Shell and ensure you have access to the project

Then, from the terminal, type the following command to clone the repository

git clone https://github.com/GDGCloudLahore/GCP-Deployment-Manager-IaC.git

Next, navigate to the basic01 lab.

Now, add the following command. The Google Cloud Shell will ask you for authorization

gcloud deployment-manager deployments create my-vm-deployment --config vm-deployment.yaml

"In case you face any issue or error, please open an issue on our GitHub repository."

After receiving a successful creation message, you are now able to view the compute resource.

I hope you like this blog. We have many blogs in the pipeline that we are working on. You are welcome to contribute to our GitHub Repository if you have experience working with Deployment Manager. If you have any questions, please feel free to ask me on LinkedIn.

This blog is written and managed by Adil Shahzad

Join our discussion room to ask questions from cloud experts : https://www.googlecloudlahore.com/

Git Cheat sheet for Beginners

Adil Shahzad — Sat, 19 Mar 2022 06:32:57 +0000

This Git cheat sheet saves you time when you just can't remember what a command is or don't want to use git help in the command line. It is hard to memorize all the important Git commands by heart, so this can help you when you get stuck.

Setup


git --version	To check the version of git
which git	See where Git is located
git help	terminal-based documentation
cd	Navigate to the directories using terminal
ls	list files and directories
ls -A	list hidden files and directories
mkdir	Creating a new directory using terminal
touch readme.txt	creating new file

Git configuration

Configuring user information used across all local repositories

git config --global user.name "First name last name"

git config --global user.email "[valid-email"

Git basics


git init	initialize an existing directory as a Git repository
git status	show modified files in the working directory, staged for your next commit
git add [filename]	Stage all changes in for the next commit.
git commit -m "Describe Message"	commit your staged content as a new commit snapshot

Branches


git branch	List all branches
git branch newbranch	Create a new branch
git checkout newbranch	switch to another branch and check it out into your working directory
git checkout -b newbranch	Create and switch to new branch at the same time
git branch -m branchname new_branchname	Renaming a branch
git branch -d branchname	Delete merged branch (only possible if not HEAD)
git branch -D branch_to_delete	Delete not merged branch

Merge


git merge branchname	Merge the specified branch’s history into the current one
git merge --ff-only branchname	Merge to master only if fast forward
git merge --abort	Stop merge in case of merge conflicts
git cherry-pick 073791e7	Merge a Specific commit
git checkout branchname » git rebase master	Rebase the current branch onto master
git rebase --abort	Cancel rebase
git rebase -i HEAD~3	Squash Multiple commits into one

Git log


git log	show all commits in the current branch’s history
git log --oneline	Show oneline-summary of commits
git log -p	show changes
git log --stat --summary	Show stats and summary of commit
git log --graph	Show history of commits as graph
git log --oneline --graph --all --decorate	Show history of commits as graph-summary

Compare


git diff	To compare modified files
git diff --staged	To compare modified files within the staging area
git diff master..branchname	To compare branches
git diff 6eb715d	Compare with the previous commit
git diff --ignore-space-change 6eb715d..HEAD	to compare without caring about spaces:
git diff --ignore-all-space 6eb715d..HEAD	To compare without caring about all spaces

Make sure you replace this commit 6eb715d with your commit ID

Stash


git stash	Save modified and staged changes
git stash save "Message"	Put in the stash with message
git stash list	list stack-order of stashed file changes
git stash show stash@{0}	Show stash stats
git stash pop	write working from the top of stash stack
git stash branch new_branch	Create branch from stash
git stash drop	discard the changes from the top of stash stack


git tag	Show all released versions
git tag -l -n1	Show all released versions with comments
git tag v1.0.0	Create release version
git tag -a v1.0.0 -m "Message"	Create release version with comment
git checkout v1.0.0	Checkout a specific release version

Reset


git revert 073791	Go back to commit
git reset --soft 073791	Soft reset (move HEAD only; neither staging nor working directory is changed)
git reset --soft HEAD~	Undo the latest commit

Remote


git remote add origin [repo-url]	Adding remote origin to local repository
git remote -v	Show remote details
git remote rm origin	Remove origin
git branch -M main	Renaming a branch
git push -u origin master	Push changes to the remote repository
git pull	Pulling changes from the remote repository
git pull origin branchname	Pull specific branch
git clone [repo-url]	Cloning a local repository
git push origin --delete branchname	Deleting branch from the remote origin

Understanding GitHub Workflow

Adil Shahzad — Sat, 19 Mar 2022 06:32:08 +0000

Previously, we have learned how to synchronize the local git repository with the Remote GitHub Repository to store the content history of the project on GitHub. In this lesson, we will learn how you can follow the GitHub flow to easily experiment with new ideas safely without the risk of compromising the project.

What is GitHub flow?

GitHub's flow is a lightweight branch-based workflow. The GitHub workflow is helpful for everyone. With the help of GitHub flow, you can experiment on your repository.

By Default, our project is on the main branch; any changes made on the main branch will directly update the project.
When we want to experiment with new features or even fix an issue, we can create a new branch on the project. The branch will duplicate the main branch and the changes reflected in the new branch.

Creating a branch

Open your repository and click the "Code" tab
Click Branch: main in the drop-down
In the field, enter a name for your branch (e.g., 'dev')
Click Create branch.

Committing a file

Now that we are on the dev branch created earlier, you can create a new file or edit the file already in the dev branch.

You can add the file from the Add file, and from the dropdown, select the create new file option or edit already existing files in the dev branch.
When you are done with changes, give the commit a name and description.
Make sure your newly created (dev) branch is selected.
Click on Commit changes.

You have made your first commit! The next step is to share the changes with your team via a pull request.

Open a Pull Request

A pull request is where we share our proposed project changes with our team — with the intent of discussing & revising them before applying the changes to the main branch.

Open the Pull requests tab and click on "New pull request."
In the base: dropdown menu, ensure the main branch is selected.
Select the dev branch you created earlier in the compare: dropdown menu.

After successfully merging the dev branch changes to the main branch, we can delete the dev branch by clicking on the delete branch button.

Summary

In this lesson, we learned the git-flow while adding features or fixing bugs in the project; with the help of git-flow, you can save your default branch and do experiments on the new branch. Practice the commands using the quiz and make sure you understand entirely Git & GitHub. You can access the Git cheat sheet, which helps you with the basic and advanced commands. When you are confident, you can go to the second module, in which we will get started with GitHub actions.

Introducing Git & GitHub

Adil Shahzad — Sat, 19 Mar 2022 06:05:51 +0000

We have already covered git in advance, and now we are also familiar with GitHub and the features provided by GitHub. In this lesson, we will sync the local repository with GitHub; you will get a complete idea of how you can sync your local repository with the remote repository of GitHub.

Let's get started

We have covered Git & GitHub in detail. We learned that git is a Distributed Version Control System, and GitHub is a web-based git, version control repository and internet hosting service. Furthermore, we will learn how to synchronize the Local repository with GitHub in this lesson.

Creating local repository

First, we need to create an empty directory. Use the following command.

mkdir <gitandgithub>

Then, we need to Navigate to the Directory we created earlier with the following command.

cd <gitandgithub>

Git Init

Now we created the Directory; we can initialize the git repository in the empty repository using the following command.

git init

Remember that the command ls -A is used to list the .git/ folder on the terminal because .git/ is the hidden file in the working directory.

Git add

Adding File Using Terminal

We can create a file using the following command touch index. html and edit the file through the terminal easily using the vim or nano editor.

vi index.html

You can also read the text inside the file using the following command.

cat index.html

Git status

So files are now added to the Directory. Before we add the files to the staged area, firstly, we need to check the status of the git repository, which files are modified or deleted in the Directory, which can be checked using the git status command.

Adding file to the staging area

Now, we need to stage our files, which are added to the Directory, to track our files every time we modify, delete or add to the Directory. With the git add . command, you can add your files to the staged area, and then with the help of the git status command, you can check the status of your git local repository.

Git commit

When the files are in the staged area, you have committed on the files; when you make changes on the file, the commits history is created and can be accessed later using the command git log. To Commit to the changes, you can use the following command.

git commit -m "Describe message."

main.css file is also added to the Directory, which means the changes have been tracked in the git repository. To stage the changes, we can use the git add . command, and to commit, we can use the command git commit -m "Adding main.css file. Whenever you modify, delete or change the file or folder, you need to repeat this process and check the status of the git repository. You can use the command git status.

Git branch

As we have already discussed the concepts of the branches in detail, here we need to rename the master branch to the main branch because Github's new repositories are pushed to the main branch. Use the following command to rename the master branch to the main branch.

git branch -M main

Creating a new GitHub repository

You'll need to find a "+" sign at the top right of your GitHub account to get this started. The profile tab is next to it. Click the profile, and you will see a dropdown with the first option to create a "New repository." Once clicked, you will be redirected to another page where you will have to set certain information regarding your project, such as providing your repository's name, adding a description of the project, and declaring the repository as public. Do not select the README file and License. We will create these files later on.

If you follow the above image, you will redirect to the manual, which might be useful for the beginner.

Git Remote

Now, let's go back to the local repository where we created the index.html file and main.css file; in the git bash terminal, we need to add the GitHub repository which we have created earlier; with the following command, you can add the remote repository to the local git repository.

git remote add origin <GitHub REPO URL>

To get the GitHub Repository URL, you need to go to your repository created earlier, and by clicking on the Code button, you will get the GitHub Repo URL.

The command will look like this.

git remote add origin https://github.com/gitlearning892/gitlearning892.github.io.git

With the git remote -v command, you can check the remote origin is added to the local repository or not.

If you accidentally add the wrong repository to your local repository, you can change the existing remote repository with the following command.

git remote set-url origin <GitHUB REPO URL>

Git push

The Git push command is used to upload local repository content to the remote repository. Pushing is how you can transfer commits from your local repository to a remote repository. Pushing can overwrite changes; cautions should be taken when pushing to the remote repository.

git push -u origin main

Go to your repository and refresh it; you will see all of your local content now pushed to the Github repository.

A popup will come for the Github authentication. Click on Login using a browser and provide your credential to push all of your changes to the Github repository.

Git pull

The git pull command is used to fetch and download content from a remote repository and immediately update the local repository to match the content.
For example, If someone from your team made some changes in a file or created some file on a remote repository. A developer created a file named user.txt, but you don't know the changes made on the remote repository. Let's say you have created another file named team.txt. After you commit the file and try to push that file to your remote repository, git will not allow you to push your code because the remote repository contains work that you do not have locally. So, In this case, the git pull command is used to fetch and download content from a remote repo to a local repo.

Let's create a new file on GitHub Repository.

As users.txt file is created on the GitHub Repository but this file is not available on the Local repository.
You can pull your GitHub changes using the command

git pull origin main

Git Fetch

When we use git fetch command, we fetch the commits of a remote repository into our local repository. The fetched commits are saved as remote branches separate from the local branches. So, this helps in reviewing the commits before integrating them into the local working branches.

Lets create a new file news.txt in the new branch

Click on propose change and this will redirect us to the Pull Request.

So, To work on “newbranch” we need to switch from the main branch to the “newbranch”. The command to switch branch is

git checkout newbranch

Got an error, notifying newbranch doesn’t match any file doesn’t match any branch or this branch does not exist in the git repository, this does not mean to create a new branch and push it to the GitHub repository because the newbranch is already exiting, you need to fetch this branch before being able to work on it so in order to fetch the branch simply write git fetch origin and then git checkout newbranch. If you want to fetch just a specific branch you can just specify the below command

git fetch origin [branch-name]

After reviewing the changes in the remote branch you can merge it into the local branch using git merge command.

git checkout main 
git merge origin/newbranch

Then you can push the changes to the main branch and it will automatically merge the new branch changes to the main branch.

Git clone

git clone is a Git command-line utility that is used to target an existing repository and create a clone, or copy, of the target repository. The command for cloning the repository is.

git clone <REPO-LINK>

Summary

In this lesson, we have learned how to sync the local repository with GitHub and how to use git push, pull, and fetch commands with GitHub. We have also learned how to push changes to GitHub from a local repository.

If you have any question, please feel free to connect with me on LinkedIn.

Exploring GitHub

Adil Shahzad — Sat, 19 Mar 2022 05:57:26 +0000

GitHub repositories

A GitHub repository contains the project's source code and commits history related to the project changes. You can work individually or in a team and provide restricted access to GitHub repositories. The GitHub repositories can be public or private.

How to create GitHub repositories

The process to create a GitHub repository is simple. Firstly, we have to sign up for the GitHub Account. As we already learned, how to signup for a GitHub account.
You will need to find a "+" sign at the top right of your GitHub account to get this started. The profile tab is next to it. Click the "+,", and you will see a dropdown with the first option to create a "New repository". Once clicked, you will be redirected to another page where you will have to set certain information regarding your project, such as providing a name of your repository, adding a description of the project, declaring if it is public or private.

Enter any repository name and click on “Create Repository”. You can also give a description to your repository (optional).

Enter the repository's name and click on "Create Repository". Describe the repository (optional). Private repositories are only accessible to you, While public repositories are available on the internet and accessible to everyone.

You can easily create the first repository; let's explore the repository features.

GitHub Issues

GitHub issues is a tracking feature that integrates to the GitHub repository. You can use issues to be focused on upcoming tasks, fixing bugs, feedback, or tracking ideas related to your project.

What is forking

Forking is a repository copy that allows you to experiment with the changes without affecting the original repository.

For example, John told Smith to make some changes to the project, so Smith needs to Fork John Repository before making any changes.

GitHub Pull Request

A Pull Request is a feature on GitHub which allows informing changes you have made to the repository throughout your branch.
The Repository owner reviews your changes; the reviewer can also request changes if there is any merge conflict or bug; once a pull request is reviewed and approved by the repository owner and can be merged to the main branch.

keep in mind that all-new repositories created on GitHub will be named "main" instead of "master" as part of the company's effort to remove unnecessary references to slavery and replace them with more inclusive terms

GitHub project board

Project boards are integrated into the GitHub repository, which helps organize and prioritize project work. You can create a project board for specific feature work, roadmap, or even a release checklist. Project boards are used for issues and pull requests.

GitHub wiki

GitHub wiki can share detailed information about our project; GitHub wiki can also be used for the project documentation. GitHub wiki can be used with public repositories, and in private repositories, we can use GitHub wiki using GitHub pro, GitHub Team, and GitHub enterprise pricing tier. GitHub wiki uses Markdown Language, a widely useable language for documentation and blogs.

What is Markdown language

John Gruber makes markdown, you can use markdown to write blogs, texts, books, and practically 100% of your writing work in a single format, and you can efficiently distribute it in Word, PDFs, EPUBs, HTML, and many other formats.

GitHub webhooks

GitHub Webhook provides a notification to the external server like Discord Servers, and they are integrated into the repository can be found in the settings. Whenever an action is performed on the repository or GitHub organization, You can configure your GitHub webhook whenever you execute.

You push changes to the repository
You Open a Pull request
Push changes to the GitHub Pages.

GitHub organization

GitHub's organizations are shared accounts where business and open-source projects can collaborate across the platform. The GitHub organization provides a manageable access level of members and administrative-level security.

How to create a GitHub organization

You will need to find a "+" sign at the top right of your GitHub account to get this started. Your profile tab is right next to it. Click on that, and a dropdown will open with the fourth option to create a "New organization." Select the pricing team accordingly, and then you can easily create your GitHub organization.

GitHub pages

GitHub Pages is a static site hosting service that hosts HTML, CSS, JavaScript-based websites. Also, ReactJS and Jekyll (ruby) can be easily hosted using GitHub Pages. GitHub pages run the files through a building process and publish a website, which can be accessed from the username.github.io domain, or you can also use your custom domain.

GitHub gist

GitHub gist is the simplest way to share code snippets. All GitHub gists are git repositories, so they are automatically versioned, forkable, and usable from git. It is used to share or embed a sample code or technique with your team.

How to create GitHub Gist

You will need to find a "+" sign at the top right of your GitHub account to get this started. Your profile tab is right next to it. Click on that, and a dropdown will open with the third option to create "New gist."

GitHub codespaces

GitHub Codespaces is a cloud-hosted VSCode based editor which can be accessed from a Web Browser that includes the editor, terminal, debugger, settings sync, and any extension, so you can easily collaborate on the project.

GitHub Rest API

What is API?

API Stands for Application Program interface, which developers use to access information on the cloud. It allows the different cross-platforms to communicate with each other—for example, Google Assistant.

What is GitHub Rest API?

GitHub RestApi or (GitHub API) can interact with GitHub. With the help of GitHub API, we can create and manage repositories, pull requests, issues, and more. You can access the public repositories and information using GitHub API. However, if you need to access, create or manage resources on GitHub, you need to provide your GitHub access token.

How to use GitHub Rest API

You can access the public information of the GitHub account by following the command.

curl https://api.github.com/users/adilshehzad786

Replace @adilshehzad786 with your GitHub username

GitHub CLI

GitHub CLI helps bring the pull requests, issues, and other GitHub concepts to the terminal.

You can get more information about the GitHub CLI related to installation and usage on the GitHub CLI Website.

Summary

In this lesson, we have explored GitHub features and how they could benefit us. We have learned about GitHub repositories and how to create a repository on GitHub. You can Explore GitHub and its services from your GitHub account.

If you have any question, please feel free to connect with me on LinkedIn.

Signing Up For GitHub

Adil Shahzad — Sat, 19 Mar 2022 05:51:51 +0000

Signing up for a new GitHub account is simple; if you already have a GitHub account, you might be going to the next lesson, which is to explore GitHub Services in more detail. For Students, A GitHub Student Developer might be helpful; you can apply with your university email. For teachers, GitHub also provides a Special Toolkit.

Setup GitHub account

Joining GitHub is very easy. Firstly, go to GitHub SignUp Webpage and enter the unique GitHub username, email address, secure password, verify yourself, and click on create an account.
Check your email; you will receive an email from GitHub for the email verification.
You can skip personalization or provide the required details so that GitHub can personalize some features for you, like a Student Developer Pack or a Special Pack for Teachers.
Right now, click on the continue with free; I will let you know how you can apply for the GitHub student developer pack if you are a current student.
Hurray ✨ Now you are officially on GitHub.

Let's Discuss GitHub Pricing briefly.

GitHub pricing

GitHub has three pricing tiers, starting with free tier having unlimited private and public repositories, 2000 minutes/month for automation, which we will use during the course, as a GitHub Action tool and community support. In the Team pricing tier, we have code spaces, 3000 minutes/month for automation, and 2 GB of Packages storage. In the Enterprise tier, we have 50,000 automation minutes/month and 50 GB of Packages storage exclusively used for the prominent organization.
Students can avail GitHub student developer pack, which provides the Team tier to the students to collaborate efficiently. Next, I will explain how students can avail themselves GitHub student developer pack.

About GitHub Student Developer Pack

The GitHub Student pack is specially designed to avail themselves of domains, hosting, and learning resources free of cost. With the student developer pack, they can help themselves with the Team tier, through which they can benefit more advantages on the GitHub Platform.

Summary

In this lesson, we learn how to create your first GitHub account, about the different pricing tiers of GitHub and how students and teachers benefit from the GitHub programs. I hope you have your GitHub Account, so let us get started to explore more about GitHub in the next lesson.

Appendix

If you have any question, please feel free to connect with me on LinkedIn.

Understanding Git Remote

Adil Shahzad — Sat, 19 Mar 2022 05:46:36 +0000

Git remote

Previously, we have learned about the advanced concepts of Git, and we are familiar with most of the ideas, such as the branches, merging which are very important when it comes to Advance GitHub. You will now be introduced to typical teamwork workflow and using remote repositories correctly.

What are remote repositories

A remote repository is a git repository hosted on the internet or another network.

Why work on remote?

From the start, we have been working on the local repository. Git is a distributed version control system, which means that the repositories are not stored in a single server. However, each client has its local repository with its commits and history in many repositories. These commits can be easily shared, and files can also be edited. This is how Git can easily manage teamwork locally. As teamwork is more based on the commit history, we can quickly get an idea about the project’s modifications through commits logs. So, where does Git remote play its role? For example, one of the developers from the team needed to access the commits. However, the person who has committed in the local repository is not available, so how the developer can access the project commits, through which the developer works, might slow down. This is where git remote helps us; through remote repositories, we can easily host our code on the remote server. Everyone who has access to the team’s repository can quickly push or pull commits through the remote server. Even if you are working individually on a project, adding the remote repository to your local repository will learn how to add it to your local repository. The way you have a backup of your project history and the help of the remote repository, you can access and modify your project anywhere.

Git remote platforms

GitHub, GitLab, and Bitbucket are the most popular service code hosting services on the internet. They all have different pricing tiers and features; we will explore GitHub in this course, so let us get started with GitHub.

What is GitHub?

GitHub is a web-based git or version control repository and internet hosting service. From Open source to business, you can easily host code, manage projects, and build software alongside 50 millions developers around the globe. GitHub also offers distributed version control and source code management (SCM) functionality of Git and its features like GitHub Actions.

GitHub and Open source

GitHub is a platform for the largest Open Source community in the world. With GitHub, you can contribute to the projects you have expertise in. For example, I have expertise in python, so I will find python based projects on GitHub to contribute by fixing bugs or adding new features to the project. A GitHub workflow for open source contributions needs to be followed; we will discuss it more in the GitHub workflow lesson. For GitHub workflow, you need to follow some setups. Firstly, we need to clone it to contribute to a project, so this process is called forking. You can make your code changes on the copy project, and when you are done with your changes, submit a pull request to the maintainer of the code. The maintainer will review the code, and when the maintainer is satisfied with the changes, the maintainer will merge the changes to the default branch. Open source projects are limited to the code; they need docs, translators, community managers, maintainers, and so much more. We will discuss GitHub more and its feature in the next lesson. Let us get started on GitHub by creating a GitHub account.

Summary

Working on local repositories is fun, but sometimes you need to work remotely on a project with teammates; whenever you need to host your project online on the remote repositories. We also discuss GitHub and Open source. In upcoming lessons, we will explore more about GitHub features. If you do not have an account on GitHub, let us create a GitHub account, and if you are a student or an academic teacher, then a special surprise for you in the next lesson.

If you have any question, please feel free to connect with me on LinkedIn.

Understanding Advance Git

Adil Shahzad — Sat, 19 Mar 2022 05:42:20 +0000

Branches

Git branching allows developers to diverge from the production version of code to fix a bug or add a feature.
Here is an example of how git branches are helpful. Let's say you need to work on a new website feature, create a branch and checkout to the new branch, and start working. Once you complete new features, you can merge your changes to the master branch.

As shown in the image above, we have a default branch, the master branch. To add new features to the project, we can easily create a new branch and start working; someone else from the team member can also contribute to the Repository by creating a new branch.

How to create a branch

Option 1: Creating a branch & Checkout

You can create your new branch with the following command.

git branch <new_branch>

Replace with whatever name you want.

and with the following command, you can list the branches

git branch

The current local branch will be marked with an asterisk (*).

If the asterisk is not visible on your new branch, it means you are not on the new branch. With the following command, you can easily check out the new branch.

git checkout <new_branch>

Now, you can use the git branch to check which branch you are currently using. The current branch will be marked with an asterisk(*).

Option 2: Creating a branch using checkout

Through this command, you can easily create a new branch and checkout to the branch simultaneously.

git checkout -b <another_branch>

And with the git branch you can check on which branch you are currently. The current branch will be marked with an asterisk(*).

delete a branch

To delete the local branch, use the following command.


git branch -d my-branch-name

The -d option only deletes the branch if it has already been merged. The -D option is a shortcut for --delete --force, which deletes the branch irrespective of its merged status.


git branch -D my-branch-name

merging

Once you complete your work with the branches, you need to use the Merge method. Merging takes your branch changes and merges them to the main branch, the master branch, by default. Depending on the commit history, git performs two ways of merging.

Fast-forward or two-way merging
Three-way merging

Fast-forward

In the Fast Forward method, where merging includes only snapshots, let me clear more with an example. Let's say you have completed your work on the feature branch (which is your new branch), and you merge the changes with the master branch, which is the default branch in git. Assume that the master branch has no more commits from the time you created a new branch.

When the feature branch has to be merged with the master branch, the two of the most recent commits on either of these branches, C3 and F2, compare and merge automatically, unless no merge conflict error occurred—called fast forward or two-way merge.

Three-way merge (or recursive)

The Three-Way process involves three snapshots, two of the snapshots are involved in the two-way process (Fast-Forwarding) as already discussed. The third one is the base file or the Parent, with which two files are compared.

As you see, C3 is the Parent with which C4 and F2 files are compared for merging.

How merging works

As we have already discussed Merge in detail, let's do some practical hands-on. We have also learned how to create a new branch, the file created inside the new branch will not be accessible to the master branch, which is our default branch in Git, until we merge the new branch with the master branch.

Merging branches in a local repository

Use git checkout to switch the branch you want to merge into to merge locally. The branch we usually switch first is typically the master branch, which is the default branch. Next, use the git merge and specify the branch name to merge the new branch with the master branch. This method is also called Fast Forward Merge.

Create a new branch using the command git branch new branch you can change the new branch name specifically to your project feature, for example, dev branch and you can easily checkout using the git checkout command when you create a new file in the new branch you need to follow the staging and committing procedure. Once the process is completed, you can follow the commands given below;


git checkout master

git merge <newbranch>

Aborting merge

You can also abort the merging process in case of merge conflict issues with the following command.

git merge --abort

Merge only one specific commit

Sometimes we need to merge a specific commit; use cherry-pick. Let's discuss what cherry-pick is.

Cherry-pick

Cherry-pick allows you to choose the specific existing commit to include in another branch, and with the help of cherry-picking, you can merge a particular commit of exiting.

Create a new branch, checkout to the new branch, add the files, stage, and then commit your changes in the new branch. Use the following command to get the specific commit ID.

git log --pretty=format:"%h %s"

You can easily merge the specific commit ID to the default branch master using commit ID. Once copied, the commit ID is then checked out to the master branch and used the following command.

git checkout master
git cherry-pick 12670fd

Merge Conflict

Merge conflicts may occur if completing changes are made to the same line of a file, or if the file that someone else is attempting to edit is deleted. We will discuss further how to resolve to merge conflict issues using Github.

What is Rebase?

If you are collaboratively working on a project with other developers, then you would notice very quick changes on the repository, and it would not be the same repository you have started to work with, as new features and changes would be added. This is where rebasing comes into action. Rebasing takes commits and stores them in a temporary location. It takes the latest version and adds the commit on top of the latest version. So in this way rebasing ensures that your commits are added to the current state of the project, and not to the old state of the project.

Rebase Vs Merge

Rebasing and rebasing both are designed to integrate change from one branch to another branch but in different ways.

Let's say we are working on a project with a repository having committed. Merge will result as combinations of commits, whereas rebase will add changes in the feature branch starting from the last commit of the master branch.

When you rebase a feature branch onto the master, you move the base of the feature branch to the master branch's ending point.
Merging takes the content of the feature branch and integrates it with the master branch. As the result, only the master branch is changed. The feature branch remains the same.
Merging adds a new commit to your repository history.

How Rebase Works

To Rebase the feature branch onto the master branch, use the following commands:

git checkout feature
git rebase master

Squash

Git squash is a technique that helps you to take a series of commits and consider it to a few commits. for example, Assume that you have a series of commits with the help of git squash we can me all the n number of commits to a single commit.

Squashing is mainly used to describe a large number of commits, to make it to a small number of meaningful commits so that you can make the git history clean.

Git squash is also used for the merging of branches. Most developers also advise you to always squash the commits and rebase them with the parent branch(master).

So when you are squashing and rebasing with the parent branch, the history of the master branch will be way clean, and you will have meaningful commits.

How to do git squash

First, we will use the following command to print the logs in one line.

git log --oneline

Let's squash the last three commits. These commits explain that we have added a new file. We can use the following command to squash the last three commits.

git rebase -i HEAD~3

The Interactive -i command will open up the editor which will have the three commits. Just add the s word to the last commit as shown in the image below and save the file.

In Vim you can Insert by pressing the key i. The command to save a file in Vim and quit the editor is:wq. To save the file and exit the editor simultaneously, press Esc to switch to normal mode, type:wq, and hit Enter.

After writing and quitting your file using vim, the editor will open another editor having the commits, you can change the commits, as shown in the image below. And when you are done with your changes, git squash will merge the commits to one.

You can check whether the last three commits are merged by the git squash using the command below:

git log --oneline

Git stash

According to the Atlassian

The Git Stash command takes your uncommitted changes(both staged and unstaged changes), saves them for later on, and then revert them from your working copy.

It is a way to store any uncommitted changes and revert your file to the last commit. Then you can do any other git command during this time. When ready, you can reapply your stored changes into your working directory.

Why should we use git stash

Imagine the scenario, you are working on a new feature branch for a project. A Developer asks for some help and wants you to check something in another branch. However, the changes you made in the new feature branch are not entirely committed. Here, git stash comes in handy; instead of making half-completed commits, you can temporarily save your uncommitted changes using git stash. Then you can safely check out to another branch. When you are finished helping the developer, you can return to your branch and continue exactly where you left.

How to use git stash

These are the two basic commands which we will use.

Use this command to stash your current work.

git stash

Use this command to reapply your stashed work back to your working area, and with this command, you can remove it from the stash.


git  stash pop

gitignore

.gitignore file is a file that specifies the files or folders that we want to ignore.

Let's say we want to ignore a text file; with the help of the .gitignore file, we can easily ignore the text file. Assume that you created a readme.txt file in my working directory, and you want to ignore the file; write the readme.txt file to the .gitignore file.
And if you want to ignore files using the extensions, write the *.txt to the .gitignore file.
Let's say you want to ignore a folder. Assume that you are working on a python project and usually use the venv environment in python. You can write the venv/ to the .gitignore file to overlook this folder.

How does gitignore work?

From the Git bash terminal, we can easily create the .gitignore file.


touch .gitignore

While using Vim to edit the .gitignore file, you can edit the file from the terminal with this command,

vi .gitignore

Press I key to insert text into the .gitignore file

to quit :wq to successfully write and leave from the vim editor.

With the git status command, you can check whether the file is ignored or not.

releases & version tags

Tags are a simple aspect of git; they allow you to identify specific release versions of code. You can think of a tag as a branch that does not change. Once you create the tag, it loses the ability to change the history of commits.

There are two types of git tags.

Annotated tags
Lightweight tags

Annotated tags

Annotated tags store metadata such as author name, release notes, tag message, and data stored as an object in the git database. All this data is important for the public release of the project.

To create a tag using the following command.

git tag -a v1.0.0

In case if you want to add a tag message, then use the following command.

git tag -a v1.0.0 -m " Release version v1.0.0"

Lightweight tags

Lightweight tags are the simplest way to add a tag to your git repository because they store only the hash of commit as lightweight tags do not contain extra information.

Lightweight tags are essentially bookmarks to a commit; they are just a name and pointer to commit. - Bitbucket

To create lightweight tags, you can use the following command.

git tag v2.0.0

What have we learned so far?

We learned different advanced concepts of Git, containing branches, merging, cherry-pick, and tags. As these concepts are a bit hard for beginners, but if you focus more on the hands-on git commands, you can easily get the concepts of the git advance features, as we discuss every topic in detail, this is a brief overview of some git advance commands.

To list branches, we use the command git branch and to create the branch, we use git branch new branch and then switch to the new branch we use the command git checkout new branch.
To merge the new branch with the default branch, first, we need to switch back to the default branch with the following command git checkout master and then we can merge the new branch to the default branch with the following command git merge new branch.
To merge a specific commit, we learn about the cherrypick, with the following command, we can merge a specific commit git cherrypick <commit-ID>

Please feel free to use the terminal for the git commands so that you can learn and have hands-on experience with the git advance commands. Please follow up as I already added the working on every git command.

Summary

This lesson mainly dealt with the advanced git concepts; as we covered branches and why we use branches, we learned advanced concepts of Git. In the next lesson, we will learn about the Git remote repositories, why we use git remote repositories, and How to learn about a handy tool: GitHub.

If you have any question, please feel free to connect with me on LinkedIn.

All About Git & GitHub—Beginner to Advance ️

Adil Shahzad — Fri, 18 Mar 2022 19:41:01 +0000

Please follow to get more blogs on such technical topics.

Connect with Me 👋

Let me know if you have any question or suggestion. You can connect with me on LinkedIn, Also Feel free to get a Mentorship Session if you have any query related to DevOps.

Understanding Git

Adil Shahzad — Fri, 18 Mar 2022 19:39:09 +0000

Git overview

Git is a Free and Open-Source Distributed Version Control System. Git’s purpose is to keep track of projects and files as they change over time from different users.
A repository is committed to the project, and the HEAD refers to the current commit viewing in the repository.

All this information related to the project is stored in the .git/ folder, usually known as a git repository, which is mainly hidden by default in the project directory. So basically, Git keeps track of changes made by the developers on the project they are working on. Also, developers can work on the different branches, which helps them add more features to the project to resolve bugs, and when they are done with the changes, they can merge the changes to the default branch, which is the main branch. These techniques help the developers to track down bugs or software failures with the help of commits made to the project.

What is HEAD?

HEΑD is a pointer, which αlwαys points to the latest commit in the branch. Whenever a user commits to the project repository, HEAD is updated with the latest commit. The heads of the branches are stored in the .git/refs/heads/ directory.

What is a git repository?

A Git repository is a .git/ directory inside a project which tracks and saves all the history and changes made to the files or folders in a git repository.

If you delete the .git/ folder, you delete your project history.

Git uses a Distributed Version Control System to track all changes made to the project and save them into the repository. Users can then delete or copy the existing repository or create a new one for the current projects.

Types of git repository

Bare repository

The software Development team uses Bare Repositories to share changes. Individual users cannot modify or create new versions of the repository.

non-Bare repository

In non-Bare repositories, users can easily modify the existing repository and create a new version. By default, the cloning process creates a non-bare repository.

Git workflow

These are the Git stages (workflow)

modified
staged
committed

modified

Whenever users make changes to the files, git cannot track those changes. We must move the file to the staged area using the git add command to track the changes.

staged

On the other hand, in the stage, files modifications are tracked by git, part of the snapshot.

committed

The changes made into the file successfully become a part of the latest snapshot.

First, when we add the file to the working directory, the file is usually untracked, and to track the file, we need to stage the file; for this, we use the git add command, and when the file followed, we need to commit on the file with the following command git commit. When we edit the file, the file will be again in the untracked stage, and we need to stage and commit to the file. We can also reset the staged area to untracked the file that we tracked accidentally. Let us get started with git by installing it first.

Git installation

To get started with Git, Download the Git concerning your operating system. Once installation is complete, you can check the git version with the following command after installation is completed.

git --version

Git configuration

The purpose of the git configuration is to configure user information used across all local repositories. The username and email are associated whenever the user commits changes to the repository.

git config --global user.name "[firstname lastname]"

After the name configuration on git CLI, configure the email with the following command.

git config --global user.email "youremail@yourdomain.com"

Once done, you can confirm that the information is set by running:

git config --list

Using git for a new project

Let’s see how we can set up a new project using Git.

Initializing the repository

First, we need to create a new directory.


mkdir <git_basic>

Now, we need to navigate to the directory which we created earlier.


cd <git_basic>

Run the following command to initialize an empty git repository inside the working directory.


git init

After this command, a .git/ folder will be initialized to the working directory; you can use the following command to list the hidden files and folders.

ls -A

Git status

Git status is used to show the level of file changes as untracked, modified, or staged.
Let us create the first file that we will be tracking using git. Make Sure still in the git_basic directory terminal. To create new files in the current directory from the terminal, run the following command:


touch README.md

.md extension is used for the Markdown Language. Markdown is a lightweight markup language with plain-text-formatting syntax.

Use the following command to open the file in the vim editor.


vim README.md

Once in the Vim editor, press I from the keyboard to start editing. When done with editing, press the ESC button. The command to save a file in Vim and quit the editor is :wq. As soon as the file is saved, the state of the repository will be changed. The status of the file can be easily tracked by running the following command:

git status

The git status command does not change or update anything. Instead, it prints out which files are modified, staged, or untracked. To stage the file, we need to learn about staging and committing.

staging and committing

staging

Before committing, we must tell git what files we want to (untracked, modified, or deleted) to the project directory. To track the git working directory files, we use the git add command. Why do we need to do this? Why can't we commit directly? Let us work on two files simultaneously but want to commit only one completed file, so in this situation, the "git add" command helps stage the file. Even deletion of files can also be tracked in the git history, so deleted files must be staged and committed.

Run the following command on Git Bash to stage the files or folders.


git add .

in the git add . dot can be used to simultaneously track all the project changes.

Alternatively, sometimes only we need to stage one file.


git add <filename>

The folder can also be staged using the following command.


git add <myfolder>

After the add command, you can check the status of the file, whether it's staged or not, using the git status command.

unstaged Files

Sometimes you accidentally staged the files, so with this command, you can unstaged the files from the git staging area.


git reset [file]

commit

Commits work as a snapshot or milestone along the timeline of git progress. Commits are created directly with the git commit command after the staging of the files. Git snapshots are always committed to the local directory.

Use the following command to commit changes.


git commit -m "Message that describes what this change does."

TIP: For commit messages, do not use the past tense, such as "I made a change in the file " use language like "making navbar blue" as you are giving orders to the git.

Fixing your last commit

If you made a mistake in your last commit message, run this command.


git commit --amend -m "Put your correct message here."

View a List of Commits

You can view the latest and previous commit details using the following command

git log

You can also use the following command to see a simplified list of commits.

git log --online

To see a list of commits with even more detail (including which files changed), run this command.

git log --stat

Note: if the commit list is long, you can use the UP/ Down Arrow key and press the q button from the keyboard to exit from the terminal.

What have we learned so far?

To Initialize Git Repository, we use git init
To Stage all the files, we use git add .
To Commit the changes, we use git commit -m "You Message"

Every time you modify, delete or add the files, you have to use the git add command and then commit your changes to the git repository using the git commit command.

Summary

This lesson is essential for the basic understanding of Git. The main takeaways are the three states that a file can be:

• Modified: To modify a file on the Working Directory.

• Staged: To add the file to the Staging Area, so it could be snapshotted.

• Committed: Snapshot of the entire project (the unmodified and staged files).

If a file was part of the previous commit and did not modify it, it will automatically be part of the next commit. A modified but unstaged file is considered unmodified. Git will not automatically track the changes, as you have to ask git to follow them by staging those files.
After staging the files, we also learned about committing to the changes.
In the next lesson, we will explore more about advanced concepts of Git such as branches, merge, tags etc.

If you have any question, please feel free to connect with me on LinkedIn.

Understanding Version Control System

Adil Shahzad — Fri, 18 Mar 2022 19:31:09 +0000

Wrote a code for development, defined variables performed a dry run, and undertook multiple code revisions only to discover that the previously written code was better than the latest one. Reverting to the previous code well is not an easy thing to do. At times, it was a difficult task on the developer's end.

The modification, update, reversion formulated Version Control System. Version Control System keeps track of files modification, deletion of files, or folder in a working director.
Let's discuss the version control Systems more in detail.

Version Control System

What is Version Control System? Essentially, Version Control Systems allows recording changes to files over time to view specific versions of those files later on.

Version Control Systems, or VCS, are specialized software. The primary purpose is to manage the codebase changes whenever changes are applied. Also, with the help of a Version Control System, we can recall a specific version later.

Why do you need one?

Did you work on a project that required recalling the specific changes made to each file? If yes, how did you manage and control each version? Maybe tried to duplicate and rename the files with suffixes like “review,” “fixed,” or “final”, as shown in the below image.

All those problems can solve by using a Version Control System or VCS. A Version Control System tracks each change made to every project file and provides a simple way to compare and roll back those changes.

Types of Version Control system

Version Control Systems have three types, which are following.

1. Local Version Control System
2. Centralized Version Control System
3. Distributed Version Control System

Local Version Control System

In the Local Version Control System, the user manages and controls all the file changes within the local system. All changes are saved in a local database. Revision Control system (RCS) is one of the most common Versions Control System tools. As seen in the image below, each developer has their version control history, and they are only limited to the local databases.

Centralized Version Control System

A Centralized Version Control System contains one repository in which users have stored a working copy of the project they are working on. Users need to commit their changes to the repository to update and reflect its changes.

Distributed Version Control System

A Distributed Version Control System contains multiple repositories. All users have their repositories and working copies. Committing the changes will not give other users access to the changes because the commit will only reflect in the local repository. The user needs to push the changes to the central repository. The most popular distributed version control systems are Git and Mercurial.

Benefits of Version Control System

These are the benefits of the version control system.

Using a Version Control System allows collaboration between the team, and users can easily contribute to the codebase simultaneously without overwriting or conflicting with each other works.
The Version Control System also enables developers to quickly revert the codebase changes to the last good state in case of any bug or software failure.
Distributed Version Control Systems like Git can restore the entire project and the history from any developer's local repository if the central repository is lost or deleted.

Why do we use git?

According to the 2021 survey of StackOverflow, 90% of developers use Git, making it the most used distributed version control system in the world. Git is used to tracking changes in a project file.
According to the 2021 survey, 90% of developers use Git, making it the most used distributed version control system in the world.
These are the few reasons developers prefer Git to other distributed version control systems.

Developers can easily track their entire timeline of any project's changes, decisions, and progressions from a single repository. They can access their project history, and the developer has all the context they need to understand it and start contributing to the open-source world.
With the help of Git, developers can quickly work in every time zone. Team collaboration can efficiently maintain source code integrity. Using branches, developers can safely propose changes to the production environment.

Summary

Git has many more powerful features covered throughout this course.
We learned about the version control systems and types of different version control systems from this lesson. In the next lesson, we will learn about the basics fundamentals of Git, Installations, Configurations, and basic commands to get started.

If you have any question, please feel free to connect with me on LinkedIn.

Website deployment Automation with Continuous Integration Using AWS, Jenkins & GitHub

Adil Shahzad — Wed, 16 Jun 2021 11:56:18 +0000

DevOps is all about the Agile and speed release of the software and well solutions . one of the best ways is to automate the daily tasks.

In this blog, we are going to learn how we can automate the website deployment using open-source software called Jenkins with Amazon Web Services and GitHub which is an online version control system platform. Before moving on to the practical work, first, let's learn what is Continuous integration.

According to Circle CI, Continuous integration (CI) is a software development strategy that increases the speed of development while ensuring the quality of the code that teams deploy. Developers continually commit code in small increments (at least daily, or even several times a day), which is then automatically built and tested before it is merged with the shared repository.

We are also going to use GitHub Webhooks. so whenever we push to the GitHub repo, Webhooks automatically push all the changes to the Jenkins server. The complete architect design of the project is available below which we are going to design.

Before starting working on Jenkins please make sure you have an AWS Free tier **account **and also an idea of how to use commands on Ubuntu Terminal.

Creating AWS EC2

First, we need to create a Ubuntu Server 20.04 LTS on Amazon Web Services and then we will install the Jenkins server on Ubuntu.

There are ways to create an AWS EC2 Machine, one is that you can create an AWS EC2 Machine using AWS Dashboard, the second one is that you can create AWS EC2 Using AWS CLI, the third option is that you can create an AWS EC2 using Terraform which is Infrastructure as Code (IaC) process. Please find the following blog resources if you need any help to get started

Getting Started with Terraform Using AWS
Creating AWS EC2 Using AWS Dashboard

Now, we need to connect with the Instance using Command shell which I found easier . Keep your key secret! Do not share with anyone!

ssh -i "Jenkins-Server.pem" ubuntu@ec2-3-86-216-74.compute-1.amazonaws.com

I am using ssh using command shell and **Jenkins-Server. pem **is the name of my secret key.

Installing JDK on Ubuntu Server

since Jenkins is the java based application so we need to install the JDK on the ubuntu server by following commands.

sudo apt update
sudo apt install default-jdk-headless

Install Jenkins

After successfully installing JDK, now we need to install Jenkins.

wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -

sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > \
    /etc/apt/sources.list.d/jenkins.list'

sudo apt update

sudo apt-get install jenkins

Let's check whether Jenkins is Up and running or not by following the command

sudo systemctl status jenkins

Go back to your Ubuntu instances, inside the security scroll down, you will found the inbound rules. Jenkins will update your inbound rules, if your rules did not update you can manually add up your inbound. on your left side find the Security Group. on Security Page, you will found the Edit Inbound Rule and Afterwards, you can add your own rules and save your settings.

Now We need to access Jenkins using a browser

Go to your AWS EC2 and copy your Public IPv4 address

http://3.86.216.74:8080

Please make sure you are not using HTTPS because it will return a security error. later on, we will install the HTTPS Package on the Jenkins server.

You can retrieve your Jenkins password from your server which you access using the command shell by following the command.

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Jenkins Getting Started

Customize Jenkins

Now, you need to click on the — Install Suggested Plugins

Creating Jenkins Admin Panel

You can create your Admin user or you can skip this by continuing as Admin.

Jenkins is Ready!

Finally, your Jenkins server is set up on an ubuntu machine now click on the Start using Jenkins.

Jenkins using GitHub WebHooks

In this part, you will learn how to configure a simple Jenkins job/project. This job will be triggered by GitHub Webhooks and will execute a ‘build’ task to retrieve codes from GitHub and store them locally on the Jenkins server.

You can Fork my Repo to get started with Jenkins and GitHub WebHooks because I make it easier for the beginners to get started with Jenkins Journey → https://github.com/adilshehzad786/Website-deployment-Automation-with-Continuous-Integration-Using-AWS-Jenkins-GitHub
Go to your Settings → Webhooks and add your Jenkins Server link

http://<YOUR-JENKINS-URL>/github-webhook/

Now, Enter an item name and select the Free-Style project and then click on OK.

To connect your GitHub Repository, we need to set the following things

Checked GitHub Project → Paste your GitHub Repository URL
Source Code Management → Git
Branches to build → main

Jenkins Built

Save all the configurations of your project and click on apply. For now, we can only do it manually. Click the “Build Now” button, if you have configured everything correctly, the build will be successful.

You can open the build and check-in Console Output on your left menu and it will show you that you're built run successfully.

If so — Congratulations! You have just made your very first Jenkins build!

But this build does not produce anything and it runs only when we trigger it manually. Let us fix it.

On your left menu select Configure and then change the following settings

Built Triggers → GitHub hook trigger for GITScm polling
Post-build Actions → Archive the artifacts (Add ** to Files to archive)

Now we configure the settings — Apply the settings and save the settings.

Now, go ahead and make some changes to any file in your GitHub repository (e.g. README.MD file) and push the changes to the main branch. You will see that a new build has been launched automatically (by webhook) and you can see its results — artifacts, saved on the Jenkins server.

From now on whenever you push to your Github repository, your building will be updated on your Jenkins server. As I just updated my README.md file from my Github Repo because right now I want to keep this on beginner level so you understand it easily.

Congratulations! You have now configured an automated Jenkins job that receives files from GitHub by the webhook trigger. There are also other methods like trigger one job (downstream) from another (upstream), poll GitHub periodically, and others.

By default, the artifacts are stored on the Jenkins server locally. You can access it by following the command

ls /var/lib/jenkins/jobs/<Project-Name>/builds/<Built # >/archive/

Installing Plugin to Jenkins Server

Jenkins is a highly extendable application and has more than 1400+ plugins available. In this blog, we are going to install “Publish Over SSH”.

Go to Jenkins Dashboard . on the left side click on the Manage Jenkins

and now click on the Manage Plugin

Search for “Publish over SSH” and then click on Install without Restart

Configuration of Jenkins Plugin

On the left menu, we have “manage Jenkins” options, click on it, and then go to the Configure system.

Scroll down you will found the Publish over SSH

 **Passphrase: your passphrase**
 2. **path to key:** your private key path
 3. **key **: blank
 4. **Disable exec :** un-check

SSH Servers

 1. **Name:** remote_user@remotehost.com
 2. **hostname**: remotehost.com
 3. **Username:** remote_user
 4. **Remote Directory:** empty

Advance

 5. check the box "use passsword authentication, or use a different  key" `important`

 6. **Passphrase / Password:** your linux login password`important`

 7. **path to key:** blank

 8. **key:**blank

 9. **port:** 22

 10. **Timeout(ms):** 300000

Test the configuration and make sure the connection returns Success. Remember, that TCP port 22 on the NFS server must be open to receive SSH connection

Save the configuration, open your Jenkins job/project configuration page and add another one “Post-build Action”.

Configure it to send all files produced by the build into our previously define remote directory. In our case we want to copy all files and directories — so we use **. If you want to apply some particular pattern to define which files to send — use this syntax.

Save this configuration and go ahead, change something in README.MD file in your GitHub Tooling repository.

Webhook will trigger a new job and in the “Console Output” of the job you will find something like this:

SSH: Transferred # of file(s)
    Finished: SUCCESS

Conclusion :

I hope you enjoy reading my Jenkins blog. I have other articles like how to create AWS services using terraform, and also how to create an AWS ec2 easily. Feel free to connect with me on Linkedin and also on the following platform by clicking the below link. this is the end, see you in another blog. Feel Free to Reach Me out on Linkedin

DEV Community: Adil Shahzad

Managing Google Cloud using Infrastructure as Code (IaC)

Infrastructure as Code

Understanding API

Exploring Cloud Shell

Managing Version Controlling using Git

1. git init

2. git status

3. git add

4. git commit

5. git push

6. git pull

GCP Deployment Manager

Lab

Git Cheat sheet for Beginners

Setup

Git configuration

Git basics

Branches

Merge

Git log

Compare

Stash

Tags

Reset

Remote

Understanding GitHub Workflow

What is GitHub flow?

Creating a branch

Committing a file

Open a Pull Request

Summary

Introducing Git & GitHub

Let's get started

Creating local repository

Git Init

Git add

Adding File Using Terminal

Git status

Adding file to the staging area

Git commit

Git branch

Creating a new GitHub repository

Git Remote

Git push

Git pull

Git Fetch

Git clone

Summary

Exploring GitHub

GitHub repositories

How to create GitHub repositories

GitHub Issues

What is forking

GitHub Pull Request

GitHub project board

GitHub wiki

What is Markdown language

GitHub webhooks

GitHub organization

How to create a GitHub organization

GitHub pages

GitHub gist

How to create GitHub Gist

GitHub codespaces

GitHub Rest API

What is API?

What is GitHub Rest API?

How to use GitHub Rest API

GitHub CLI

Summary

Signing Up For GitHub

Setup GitHub account

GitHub pricing

About GitHub Student Developer Pack

Summary

Appendix

Understanding Git Remote

Git remote

What are remote repositories

1. `git init`

2. `git status`

3. `git add`

4. `git commit`

5. `git push`

6. `git pull`