Complete CICD setup with Live Demo | #devops #jenkins| Write CICD with less code| @TrainWithShubham

Summary

In this informative video, Abhishek demonstrates how to create a simplified CI/CD pipeline using Jenkins for continuous integration and Argo CD for continuous delivery. He emphasizes the ease of setup with minimal coding, showcasing a live demo of updating a to-do application and automating its deployment to a Kubernetes cluster. The tutorial is designed to be accessible, even for those new to CI/CD, and highlights the future of Jenkins pipelines with Kubernetes architecture.

Takeaways

• 😀 The video is a tutorial on setting up a CI/CD pipeline using Jenkins for continuous integration and Argo CD for continuous delivery.
• 🔧 The presenter, Abhishek, simplifies the process by minimizing the use of Groovy scripting and focusing on a streamlined approach to writing the pipeline.
• 📝 The tools used in the tutorial are Argo CD for deployment on Kubernetes and Jenkins for building and pushing Docker images to a repository.
• 🚀 The video emphasizes the future-proof nature of using Kubernetes architecture and GitOps tools like Argo CD for modern CI/CD practices.
• 🔄 Abhishek demonstrates updating a to-do application, showcasing the pipeline's ability to reflect changes quickly with minimal manual intervention.
• 💻 The tutorial includes a live demo of modifying the application's code, triggering the Jenkins pipeline, and deploying the update via Argo CD.
• 🔑 The video explains the importance of using a Jenkinsfile in a GitHub repository for version control and traceability of changes.
• 📖 The presenter provides a step-by-step guide on writing the Jenkinsfile and configuring Argo CD, suitable for viewers with little to no prior experience.
• 🔍 Abhishek mentions the advantages of Argo CD, including its user-friendly UI for non-technical users and its ability to automatically sync and heal configurations.
• 📚 The tutorial also covers best practices like separating code and artifact repositories for better management and security.
• 🌟 The video concludes with an invitation for viewers to provide feedback and suggests further exploration of Argo CD through previous videos on the channel.

Q & A

What is the main focus of Abhishek's video?

The main focus of Abhishek's video is to explain how to write and execute a complete CI/CD pipeline using Jenkins for continuous integration and Argo CD for continuous delivery.

Why did Abhishek choose Argo CD for the demonstration?

Abhishek chose Argo CD because it is a tool based on the principles of GitOps, designed specifically for deployment on Kubernetes, and it requires minimal coding for configuration, making it user-friendly.

What is the advantage of using a separate repository for Kubernetes manifests in a CI/CD pipeline?

Using a separate repository for Kubernetes manifests helps in implementing good principles of GitOps, keeping the artifacts unique and more secure, and allows for better management of infrastructure configurations.

What does Abhishek suggest for triggering the Jenkins pipeline automatically?

Abhishek suggests using a webhook from GitHub to trigger the Jenkins pipeline automatically, but due to his firewall settings, he demonstrates manually triggering the build using the 'Build Now' button.

How does Abhishek demonstrate the end-to-end CI/CD pipeline?

Abhishek demonstrates the end-to-end CI/CD pipeline by making a live code change in a to-do application, committing the change, and showing how the Jenkins pipeline builds a new Docker image and updates the Kubernetes manifest, which Argo CD then deploys to the Kubernetes cluster.

What is the significance of the Jenkinsfile in a Jenkins pipeline?

The Jenkinsfile is significant as it contains the definition of the pipeline's stages and steps, and it allows for version control and tracking of changes, making it easier to manage and audit the pipeline configuration.

What is the purpose of the 'checkout' stage in a Jenkins pipeline?

The 'checkout' stage in a Jenkins pipeline is used to pull the latest changes from the source code repository, ensuring that the pipeline works with the most recent version of the code.

How does Argo CD handle the deployment of new changes in a Kubernetes cluster?

Argo CD continuously watches the specified GitHub repository for any changes in the Kubernetes manifests. When it detects a change, it automatically syncs the new configuration to the Kubernetes cluster, ensuring the deployment is up-to-date.

What is the role of the 'build Docker' stage in the Jenkins pipeline demonstrated by Abhishek?

The 'build Docker' stage in the Jenkins pipeline is responsible for creating a new Docker image for the application changes, tagging it with the build number, and pushing the image to a centralized Docker repository.

How does Abhishek propose to simplify the process of writing a Jenkins pipeline?

Abhishek proposes using the declarative pipeline syntax in Jenkins, which is simpler and more standardized, and provides a pipeline syntax generator that can create the necessary script based on user input, reducing the need for extensive knowledge of Groovy scripting.

What are the benefits of using declarative pipelines in Jenkins according to Abhishek?

Declarative pipelines in Jenkins offer a standard structure that is easy to understand and maintain, allows for easy searching of examples and solutions online, and promotes a consistent pipeline structure across an organization.

What is the main difference between declarative and scripted pipelines in Jenkins?

The main difference is that declarative pipelines provide a standardized and simpler structure, while scripted pipelines offer more flexibility and customization at the cost of being more complex and harder to maintain.

What does Abhishek recommend for those who are new to Argo CD?

Abhishek recommends filling out the Argo CD form to set up the tool, which simplifies the process and requires minimal prior experience with Argo CD.

How can viewers access and use the to-do application demonstrated in the video?

Viewers can access and use the to-do application through the provided GitHub URL, where they can also follow Abhishek's GitHub account for updates and use the application for their own demo or practice purposes.

What is the purpose of the 'update kubernetes manifest' stage in the Jenkins pipeline?

The purpose of this stage is to update the Kubernetes deployment manifest in the separate artifact repository with the new Docker image tag after the image has been built and pushed to Docker Hub.

What does Abhishek plan to do to help viewers who might have missed some details in the video?

Abhishek plans to update the README.md file with the details of the CI/CD end-to-end process explained in the video, so viewers can refer to it for a step-by-step guide.

Outlines

00:00

🎥 Introduction to CI/CD with Jenkins and Argo CD

Abhishek introduces a tutorial on creating a CI/CD pipeline, responding to audience interest and a poll result. The video aims to simplify the process using Jenkins for continuous integration and Argo CD for continuous delivery. It emphasizes the use of declarative Groovy scripting in Jenkins and the user-friendly interface of Argo CD, which requires minimal coding. The tutorial will demonstrate the robustness of this pipeline, particularly in the context of Kubernetes architecture, and will compare Argo CD to other GitOps tools in future videos.

05:01

🛠️ Setting Up the CI/CD Pipeline with Argo CD and Jenkins

This section provides a step-by-step demonstration of modifying a to-do application, which is already deployed on a Kubernetes cluster using Minikube. The process involves making a change to the application's header, committing it, and triggering the Jenkins pipeline to build a new Docker image. The video explains the simplicity of Argo CD's setup and its ability to deploy updates to the Kubernetes cluster without manual intervention. It also discusses the importance of separating the code repository from the artifact repository for better security and management practices.

10:01

🔧 Technical Details of Jenkins Pipeline and Argo CD Configuration

The paragraph delves into the technical aspects of writing a Jenkins file for the CI/CD pipeline. It explains the stages of the Jenkins pipeline, starting with the checkout stage, followed by building the Docker image, and pushing it to a repository. The video also covers the process of updating the Kubernetes manifest repository and how Argo CD watches this repository for changes, automatically deploying updates to the Kubernetes cluster. The speaker provides a practical example of updating an image tag in the deployment manifest and how Argo CD reflects this change in the cluster.

15:03

🚀 Executing the CI/CD Pipeline and Observing the Results

The speaker demonstrates the execution of the CI/CD pipeline by making a live code change to the to-do application and observing the automated deployment process. The video shows the speed and efficiency of the pipeline, which takes less than a minute to execute. It also reassures viewers that even without prior knowledge of CI/CD pipelines, Jenkins, or Argo CD, they can set up their own pipeline following the steps explained in the video.

20:05

📝 Conclusion and Further Assistance on CI/CD Pipelines

In conclusion, the video provides a summary of the steps taken to set up the CI/CD pipeline using Jenkins and Argo CD. It invites viewers to subscribe to the channel, like the video, and comment with their experiences or suggestions for improvement. The speaker offers to create additional content or live sessions to address any questions or difficulties viewers might have in setting up their CI/CD pipelines. The video ends with an invitation for further interaction and support in learning CI/CD.

Keywords

💡CI/CD Pipeline

A CI/CD (Continuous Integration/Continuous Deployment) pipeline is a software development practice where code changes are automatically built, tested, and prepared for a release. In the video, the presenter discusses how to write and execute an end-to-end CI/CD pipeline using Jenkins for continuous integration and Argo CD for continuous delivery, emphasizing the simplification of the process with minimal code.

💡Jenkins

Jenkins is an open-source automation server that facilitates the parts of software development related to building, testing, and deploying applications. In the script, Jenkins is used for the continuous integration part of the CI/CD pipeline, where it builds a new Docker image and updates the Kubernetes manifest repository with the new image tag after code changes are committed.

💡Argo CD

Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. It automatically deploys applications to a Kubernetes cluster whenever there is a change in the application's code repository. The video highlights Argo CD's ability to manage deployment without writing any code, just by watching a Git repository for changes and syncing them to the Kubernetes cluster.

💡Kubernetes

Kubernetes is an open-source container orchestration system for automating application deployment, scaling, and management. The video discusses deploying applications onto a Kubernetes cluster using Argo CD, which takes care of the continuous delivery aspect of the CI/CD pipeline by syncing Kubernetes manifests from a Git repository.

💡GitOps

GitOps is a set of practices and tools that use Git to manage and operate cloud-native applications. The video mentions Argo CD as a tool based on the principles of GitOps, which uses Git repositories to determine the desired state of the system and automatically deploys changes to the Kubernetes cluster.

💡Docker

Docker is a platform that uses containerization to simplify the deployment of applications. In the context of the video, Docker is used to create images of the application after changes are made, which are then pushed to a Docker registry and deployed via the CI/CD pipeline.

💡Declarative Groovy Scripting

Declarative Groovy scripting is a way of writing Jenkins pipelines that focuses on what the pipeline should accomplish, rather than how to accomplish it. The video script mentions using a declarative pipeline with minimal lines of code to define the steps for building and deploying the application.

💡GitHub

GitHub is a web-based hosting service for version control using Git. It is where the video's presenter stores the application's code and Kubernetes manifests. GitHub is also the source that Argo CD uses to watch for changes and trigger deployments to the Kubernetes cluster.

💡Manifest Repository

A manifest repository in the context of the video refers to a separate repository that holds the Kubernetes deployment manifests, such as 'deploy.yaml' and 'service.yaml'. This is a best practice to keep the application code and deployment configurations separate, allowing Argo CD to watch and update the Kubernetes cluster configuration as needed.

💡Git Repository

A Git repository is the storage location for a project's files using the Git version control system. The video script discusses using a public GitHub repository for the to-do application code and another for the Kubernetes manifests, which are both integral parts of the CI/CD pipeline process.

💡End-to-End

End-to-end, in the context of the video, refers to the complete process from making a code change to deploying it to a live environment. The presenter demonstrates an end-to-end CI/CD pipeline, showing every step from code commit to application update on the Kubernetes cluster.

Highlights

Introduction to creating a complete CI/CD pipeline with simplified code using Jenkins and Argo CD.

Explanation of using declarative Groovy scripting for Jenkins pipeline with minimal lines of code.

Introduction to Argo CD for continuous delivery in Kubernetes architecture.

Comparison of Argo CD with other GitOps tools like Flux, with a promise of future detailed comparison.

Demonstration of non-technical configuration through Argo CD's user interface.

Quick installation of Argo CD with just two lines of script.

End-to-end demonstration of modifying a to-do application and deploying it using CI/CD pipeline.

Use of minikube as a Kubernetes cluster for the demonstration.

Explanation of the Jenkins pipeline stages including checkout, build, and push artifacts.

Use of separate repositories for code and Kubernetes manifests for better practice.

Live update of the to-do application showcasing the CI/CD pipeline's efficiency.

Description of the Jenkins file and its role in automating the CI process.

Guidance on writing a Jenkins file for a declarative pipeline.

Discussion on the advantages of using declarative pipelines over scripted pipelines.

How Argo CD watches a Kubernetes manifest repository and updates deployments automatically.

Step-by-step guide on setting up Jenkins and Argo CD for CI/CD pipeline.

Invitation for viewers to suggest topics for future videos and offer help for any setup or configuration issues.

Encouragement for viewers to subscribe, like, and comment on the video for further interaction and support.

Transcripts

hello everyone my name is Abhishek and

welcome back to my channel

so a lot of you have been asking me

about a complete CI CD pipeline how to

write it how to execute it and even I

posted a poll last week I guess asking

what should be my next video on the

channel and uh you know cicd1 hands down

even on that poll so I am here today to

explain you how to write an end to ncicd

Pipeline and unlike the other videos

there are a lot of videos on the YouTube

but you know this will be very very

simplified uh you will be able to write

with very little lines of code uh will

not use a lot of groovy scripting uh I

mean to write Jenkins pipeline we are

using a declarative groovy scripting but

I'll show you how to write this one with

a very little lines of code and the

tools that we are using today is Argo CD

so this is Argo CD we are using it for

continuous delivery and this is Jenkins

that I am using for continuous

integration that's it so we'll just use

two tools and we will see how robust

this cacd pipeline is and trust me this

will be the future of your Jenkins

pipelines because

you know end of the day everybody is

moving to the kubernetes architecture

and the tools like Argo CD they are

github's based tool which are

specifically designed for deployment on

kubernetes so there are alternatives

like either you can go for Argo CD you

can go for flux but I'm not going into

the comparison today we'll look into

Argo CD which is better according to me

which may be in the future videos I'll

explain you why arcosity is better than

the other gitops tools but yeah going

back today we'll use Jenkins for

continuous integration and Argo CD for

continuous delivery and one advantage

with Argo CD is you don't have to write

even a single line of code so let's say

you're using ansible let's say you're

using any other configuration management

tools so in such cases you at least have

to write your ansible place or your

ansible yaml files but Argo CD if you

are a non-technical guy you can

configure everything through the UI and

installation is just two lines of code I

mean not code just two lines of script

which you can copy from the internet and

you can install Argo CD which I mean you

can get it up and running in like less

than a minute so today I'm showing you

the end to end part of it we'll make a

change to the uh I mean we'll use the

same to do application which we were

using in the previous videos we also did

the same to-do application on train with

shubham channel so I'll continue the

same thing uh firstly I'll show that the

2-do application is up and running right

so I hope you're able to see my terminal

so we are using minicube as a kubernetes

cluster the same one that we were doing

in the last video as well so let me just

uh show you that if I do mini Cube

service

okay instead let me start from the

beginning uh I have deployed this

application now the application is

already deployed and our end goal today

is to make change to the application and

the application is deployed so firstly

I'll show you the application okay so

Cube CTL get SVC so my application is

deployed as a kubernetes deployment and

this is the service that I have now to

get this service running either I can

use Ingress or you know I can also

create a tunnel so what I'll do is

minicube service

to do service is the name of the service

right which we are trying to do there

are other services which you can ignore

okay when I do this mini Cube will

generate an uh URL to me so mini Cube it

will generate a URL for me which I can

use to access this service from my

browser or any other place right you can

use any other uh

okay so this is the URL that I have

perfect this is a to-do service URL now

let me go back to the same browser that

we are using

and let's see how this application looks

initially okay so I can simply say

this and this is my to-do application

that we are already using from the

previous videos now what I'll do is I

will slightly modify the header it will

make a very simple change okay so

instead of to-do list modify once again

what we'll say is to do list Abhishek

okay so this is my to-do list so

okay so firstly let me show how I placed

my applications okay so this is my

end-to-end application this is a public

GitHub repository even you can use this

application and so this is my GitHub

account uh I am virumala so you can

simply use this uh URL you can access

this application you can you know follow

me on GitHub so that you can frequently

see what are the reports that I am

posting I'm you know everything that I

do on my YouTube uh typically I use

GitHub for storing the artifacts so you

can

follow me on GitHub

okay so without any delay this is my

to-do application uh and uh so I'll make

a simple change to the studio

application and we'll see how this is

deployed and then we'll go to the

technical details right how did I write

a Jenkins file how did I use this uh

Argo CD I'll show you but firstly let's

start with the demo okay so that you

guys have an end-to-end understanding of

what is happening after we have the demo

we'll go and debug how did I write the

Jenkins file how did I install Argo CD

how did I configure it which will not

take much time even if you have zero

knowledge on the end-to-end cicd

pipelines don't worry with this video

you can understand uh everything you can

use the same GitHub repository for your

demo purposes for your practice and you

can deploy your applications with CI CD

so firstly uh what I'll do is I'll try

to modify this one to-do list modified

once again I'll change this to

okay so let me change this to turo

application Abhishek so for that I need

to open the index.html file so this is

since we are already using this python

application I know which file has which

changes uh if you are not aware of it

you can simply browse through the code

or you can use your hello world

application but some of my viewers

already know about the studio

application and so this is the piece of

line that we are trying to change if you

see here to do list modified once again

I'll change this to to-do list

Abhishek

okay now I'll commit this changes okay

so as soon as I commit these changes my

Jenkins pipeline will get triggered and

it will uh build a new image and then

using Argo CD Argo CD will deploy the

new image onto the kubernetes cluster

there is zero manual intervention but

unfortunately I cannot uh trigger a web

Hook from my GitHub to Jenkins because

of the firewall settings that I have and

the workstation rules that I have okay

so uh it's very easy I'll show you that

process as well once you make a change

you can automatically trigger your

Jenkins pipeline but for now we will

simply click on the build now the

configuration is not difficult but I

have some firewall settings which I

cannot modify so because of which

I'll use the build Now button so as soon

as I use the build Now button now what

happens is that a new Jenkins pipeline

will be triggered as you see here and

this new Jenkins pipeline what it will

do is it will pull the Jenkins file from

the same Jenkins from the same GitHub

repository so what I have done is within

this repository I have placed the

Jenkins file so this Jenkins file is

written in grooving let me increase the

font okay and this is a very simple

Jenkins file okay so this is the syntax

of your Jenkins pipeline if you are

writing a declarative pipeline you start

with a pipeline then if you want to

Define any agent for your pipeline you

can Define agent is nothing but in which

on which Jenkins node you want to

execute this pipeline if you want to use

kubernetes or if you want to run it as a

container you can also Define your

kubernetes configuration or your pod

configuration here but I am simply using

a Jenkins agent okay so agent I mean I'm

simply using a Linux node and this is

Agent NE it can run on any agent so the

different stages in my Jenkins pipeline

so the first stage is checkout which

will check out the art artifacts so

while I am explaining you this the

pipeline is running in the background so

let it run meanwhile we will see the

configuration of the Jenkins file so

initial stage is checkout what will

checkout do checkout will take the

latest changes now I made a change to my

GitHub repository right so Jenkins will

pull the latest change using this bit

this specific stage so this

configuration let's say you are not

aware how to write it it's very simple

uh what you can do is that if you are

very new to groovy scripting or Jenkins

don't worry Jenkins has something called

as pipeline syntax so come here and

let's say you want to write this same

thing that I have written here okay so

what you can do is that if you are not

aware on how to write this

come here

click on git okay there are different uh

so pipeline syntax generator what it

will do is it will generate a Syntax for

you and depending upon what command that

that you want to execute let's say I

want to use uh https

um github.com this is my let's say let's

assume this is my GitHub repository okay

I don't have this repository but I'm

just giving it as a example and let's

say my Brand's name is Main

okay if you have any credentials that

you want to access you can pass in your

credentials so let's say I have

credentials uh that are already stored

in my Jenkins now simply click on this

pipeline uh syntax script and this is

the same thing that you can copy in here

okay so it's very simple uh if you don't

know and when you're using declarative

pipelines in Jenkins uh there are two

different pipelines that you can use

either declarative or scripting so

mostly go for declarative pipelines

because declarative pipelines are a

standard pipelines and even if you have

any issues you can Google and you can

find examples anything and you can also

set up a common uh you know structure

across your organization but if you're

going for a scripted pipelines it

depends upon the developer to developer

so I can write it differently and you

can write it differently to keep the

structure unique uh and to create to

keep the structure very formatted you

can use a declarative pipelines uh so

scripture pipelines also have some

advantages where you know if you you

have a flexibility of writing uh more

and more code or you have flexibility of

uh solving things that are not possible

with your declarative pipeline plugins

but okay in our example uh we are doing

a very basic one so I use the uh

declarative pipeline declarative

Pipeline and the next stage is build

Docker uh that is very simple I'm simply

building using the build number of my

Jenkins pipeline uh and then I'm using

the push artifacts with which I am

pushing the artifacts to a centralized

repository which is docker

and if you see here the commands are

very very simple after this what I am

doing is I stored my kubernetes manifest

in a different repository okay so this

is my code repository and this is so

cicd end to end right so this is my code

repository and this is my artifact

repository where I have my deploy.yaml

and service.ml why I have to do it I can

keep it in the same folder as well but

uh there is a reason uh you know it is

always a good practice to have your

artifacts that is your kubernetes

artifacts in a different repository so

that you can implement the principles of

githubs I'm not saying you cannot do it

with the same repository but to keep it

unique to keep it more safe to uh to

adopt good principles of githubs you

should always keep them in a different

repository so that you know whether you

are managing configuration of your

infrastructure like kubernetes or

whether you are managing configuration

of your hundreds of applications so you

can simply use a different repository

and you can ask your Argo CD to watch

for this repository for anything in this

okay

perfect so now uh let's go back to the

pipeline where is this

Jenkins file yeah so what I'm doing is I

am checking out my uh kubernetes

manifest repository and I am simply

updating the kubernetes Manifest

repository okay so what I'm doing is I

am updating the so let's say this is my

deploy.dml okay so my deploy.yaml uh

okay let's go back I'll show you the

change that is submitted by Jenkins so

that you will understand what is the

change so if you see here there is a

change that is that has happened four

minutes ago okay this four minutes ago

is the same change that we did so what I

have done is I have updated my uh

the kubernetes Manifest Report with the

new tag okay so if you look at the

change that I have submitted

okay so what is the change my Jenkins

pipeline has submitted it has simply

updated the image ID from 32 to 33. so

where okay so what is this image ID 33

so if you look at my Jenkins uh build

that that has happened okay

so this is the new image that Jenkins

has built right so Docker push Abhishek

fi CI CD end to end 33 so this image is

pushed to my Docker Hub as well as

Jenkins has updated the GitHub

repository with the new image stack now

once this is updated Argo CD which is

watching continuously this repository

what it has done is if you see here it

has synced the configuration a couple of

minutes ago

okay and if you watch the uh where is

this sorry if you watch the application

okay so it is updated with the new image

so now if I go back okay let's go back

and if you see Cube CTL

get deployed

and let's try to look at the

Cube CTL edit deploy okay

and let's use the to-do application

to understand what is the image is the

image updated by Argo CD or not

the responsibility of Argo CD is

continuous delivery and it has to update

the image tag right so it has updated

the image stack to 33. okay so let me

repeat one more time what did we do is

okay so we use the Jenkins file

to initially look at the source code

repository which has my to do

application code and then

the change that we have submitted right

we have made a simple HTML change

calling it to do application Abhishek

okay so my Jenkins file will build a new

Docker image for this change that we

have made it will deploy the I mean it

will push the docker image to Docker Hub

and it will also check out and update my

repository which has the kubernetes

deployment manifest right so this

kubernetes deployment manifest has

nothing but my uh yaml files or my

deployment files to deploy the to-do

application onto the kubernetes cluster

so once the new Docker image is created

the new Docker image is updated back to

my kubernetes

sorry my GitHub repository which has the

deployment manifest okay now let's call

this back and see what has happened so

it's a to-do list Abhishek okay isn't it

very simple

how much time did it take for the entire

pipeline it hardly takes 30 seconds or

less than a minute for the entire

pipeline to be executed and even if you

want to write the same pipeline it will

not take more than 10 minutes right you

don't have development skills you don't

have uh configuration I mean knowledge

of writing groovy pipelines or you don't

have prior experience with Argo CD don't

worry I'll show you everything it will

not take more than 10 minutes okay

so now we are good with the demo right

so to do list is updated to to-do list

Abhishek okay now let's see what I have

done step by step and in case you don't

understand anything comment uh make a

comment uh and I'll try to look into the

comments and if I feel that there is

something that I have not covered in the

video I'll definitely uh make a new

video or we can go live and I can show

you step by step again one more time

okay so and uh let's take a pause here

and if any one of you have not

subscribed to my video uh my Channel

please please please please take a

minute to subscribe to my channel and

like this video and also comment on the

video to

tell me like you know if you want to

share your uh experience watching this

video or if you like this or if you

don't like this you feel that I can

improve in explaining your specific

thing uh don't hesitate please uh

comment on this video so that I can

improve in the next videos

okay so firstly what we need to do okay

to write this entire cicd pipeline first

step is that

go to your GitHub repository let's say

that your development team has this

GitHub repository called cicd end-to-end

it can be any application it can be

Amazon it can be Flipkart anything so in

the root of your uh repository what you

need to do is you need to write a file

called as Jenkins file okay so what is

the significance of this Jenkins file

it's nothing but

when you create a Jenkins pipeline or

when you create a job in Jenkins what

does Jenkins job will do is that so I'll

show you how to even create that okay it

does not take much time so come to your

Jenkins okay firstly you need to write a

Jenkins file and then come to Jenkins

and inside Jenkins you can select this

pipeline uh type of your Jenkins job or

depending upon your requirements the

other things which I'm not going into

the details and let's call me test okay

once you create this pipeline okay if

you come here there are two options one

is you can write your pipeline script

here or the other way is you can use the

pipeline script from the sem SCM is

source code repository so when you use

this it will ask you for your SCM path

when I say Git it will ask me for the

git URL and when I provide this URL it

will simply use the

foreign

file from your

GitHub repository and you don't have to

write anything in your Jenkins file

sorry you don't have to write anything

in your

Jenkins job what is the advantage that

you get with it so the thing is if you

are writing somethings here okay let's

say your colleague wants to modify

something in your Jenkins file and you

wrote everything in uh your you have not

used pipeline script from ACM and you

have simply used the pipeline script so

he you wrote something like this and he

updated now you don't have a track of

the things right you don't have auditing

or you don't have version controlling

whereas if you are using the Jenkins

file in your GitHub repository or in

your bitbucket or gitlab you have a

track of things so let's say I have

modified something you can go back and

see why is my Jenkins Jenkins file

working yesterday I'm not working today

so that's why it's always preferable to

put your Jenkins file in a GitHub

repository

now once you do this that's all you can

simply come here and you can execute

your Jenkins file so you can take a

reference of this Jenkins file I'll put

this uh like I told you this GitHub

repository is public you can use this

GitHub repository to create multiple

copies you want to try out some pocs you

want to do anything you can feel free to

uh Fork this repository clone this

repository do any changes that you want

okay I mean you can keep create a copy

of it and you can make any changes that

you want no fine once I write this

Jenkins file the thing is this Jenkins

file will update my deployment your

diploma.yaml so now you will ask me okay

this is all updated but how will this

actually get deployed onto my kubernetes

cluster so the magic happens with Argo

CD so if you are new to Argo CD Argo CD

is a tool that is based on the

principles of githubs what it will do is

that whatever you put in your GitHub

repository okay so you can put your Helm

charts you can put customize or you can

put a plain kubernetes manifest files

like I did okay so whatever you put in

your GitHub repository will take those

manifests and deploy onto your

kubernetes cluster that's it okay there

are other advantages of Argo CD that it

can Auto heal your configuration so

let's say Somebody went to your

kubernetes cluster they modified the

deployment.yaml so Arbor City will say

no no git in git there is some

configuration and you are trying to

override this configuration so I will

not allow things

but uh for this video it is out of

context for this video you can simply

remember that Argo CD is a tool that

will take manifest our artifacts from

your git repository whether it's Helm

charts whether it's customized whether

it's claim kubernetes manifest and

deploys these things onto your

kubernetes cluster so remember just that

thing

now uh you can ask me that I don't have

experience with Argo CD how do I do this

it's very simple just fill this form and

everything is done so application name

you can give anything randomly your wish

you can call it test project name stick

to default okay and then here is the

configuration so do you want to do this

automatically or do you want to come to

your Argo CD console and click on a

button so I want to have I want

everything to happen automatically so I

say automatic and do you want to Auto

heal Auto heal is something that I just

explained if you want Select Auto heal

if you don't want if you just want Argo

CD to use as a deployment tool right you

know just you just want Argo CD to pull

the changes from GitHub and Deploy on to

kubernetes you can stick with this

configuration and here you can provide

your GitHub repository and here you can

provide the path and you can provide

your kubernetes cluster URL and the

namespace where you want to deploy

that's it

Argo CD will pick all the changes and it

will deploy so in future if you make any

new changes you don't have to bother

about updating this GitHub repository at

all so this GitHub repository which

holds the kubernetes Manifest is managed

by Jenkins and Argo CD will watch for

these files and deploy onto kubernetes

cluster so as a devops engineer what you

need to do is you just need to write

this Jenkins file that's it once you

write this Jenkins file and you use uh I

mean you also should come here and

create a Jenkins job once you do it your

end to end cicd pipeline is completed

right so I'll also try to put uh the

entire details that I've explained here

in the readme. MD file so currently it

is only updated with your uh application

details what does this to-do application

do and all but I'll also try to put the

CI CD end-to-end details that I have

done so that you know uh in case

somebody did not follow this video well

they can look at the readme file and

they can you know manually do all the

steps that we have discussed but to

explain one more time in a nutshell we

have executed The Continuous integration

and continuous delivery using Jenkins

and argosity so Jenkins is doing your

continuous integration part and Argo CD

is using your continuous delivery part I

have done a lot of videos on Argo CD on

my channel so you can go back to my

previous videos and look into the Argo

CD videos if you don't know uh things

about Argo CD but for this video uh you

can simply like you know execute the

steps that I've explained and understand

that rocd is a deployment tool which

pulls artifacts from GitHub and deploys

on to kubernetes without any manual

intervention so that is the video for

today and I hope you like the demo as

well where we made the Live code change

in case you have any further questions

or you know in case uh you want me to

comment live and explain this uh using

the setup and installation as well like

if you feel that you're not comfortable

in installing or configuring Jenkins or

installing on configuring Oracle CD we

can go on a live video and we can do it

together

but for that please uh let me know in

the comment section and don't forget to

like this video and share share this

video with your friends who uh you know

want to learn cicd

thank you so much I'll meet you in the

next video take care bye