Complete CICD setup with Live Demo | #devops #jenkins| Write CICD with less code| @TrainWithShubham
Summary
TLDRIn 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
🎥 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.
🛠️ 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.
🔧 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.
🚀 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.
📝 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.
Mindmap
Keywords
💡CI/CD Pipeline
💡Jenkins
💡Argo CD
💡Kubernetes
💡GitOps
💡Docker
💡Declarative Groovy Scripting
💡GitHub
💡Manifest Repository
💡Git Repository
💡End-to-End
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
Посмотреть больше похожих видео
HOW TO ANSWER CICD PROCESS IN AN INTERVIEW| DEVOPS INTERVIEW QUESTIONS #cicd#devops#jenkins #argocd
#1 What is DevOps ,Agile and CICD
Day-19 | Jenkins ZERO to HERO | 3 Projects Live |Docker Agent |Interview Questions | #k8s #gitops
Day-18 | What is CICD ? | Introduction to CICD | How CICD works ? | #devops #abhishekveeramalla
Day-21 | CICD Interview Questions | GitHub Repo with Q&A #cicd #jenkins #github #gitlab #devops
DevOps Real-time Project 8 || Continuous Delivery of Java Web Application || Visualpath
5.0 / 5 (0 votes)