Loading video player...
Hello everyone, welcome back to my
YouTube channel. So in this video we are
going to discuss how we can set up a
CI/CD pipeline to deploy our application
on Azure Kubernetes services using Argo
CD. So this is the architecture which we
are going to follow. So the very first
thing
we are going to set up two Azure DevOps
repositories. So the ones repository we
are going to use to store our
application source code and another
repository we are going to use to store
our manifest file. Manifest file could
be your plain ML file your HALM charts
like whatever it suits best to you you
can use it. So this is a demo simple
demonstration which we are going to see.
So I'm going to use a simple ML file. So
let me do for one thing. Let's see uh
both the repositories first. And when
you are doing Azure DevOps plus Argo CD
or maybe genkins plus Argo CD or any any
tool any combination with Argo CD, it is
recommended you always use separate
repositories for your application source
code and your manifest file. Why that
I'll come to little later. So where
first thing we will verify this
repositories.
Okay. So this is the repositories python
flask. So this is simple python
application which we are going to build
and push on azure container registries.
So when we will uh deploy this
application we will see simple this
message on our browser. So this is kind
of simple hello world applications. And
another thing we have on this file
requirement.txt txt file which is
required because when you deploy when
you build any Python based applications
you need a dependencies. So so those
dependencies we will uh mention in
requirement.txt file. So these are the
two main file of application source
code. Then we have a docker file. So for
docker file we are going to use python
3.9- slim as a base image. Then we are
going to create a app folder. Then we
are going to copy our requirement.txt
file. Then we are going to install these
requirements like dependencies whatever
we have mentioned in requirement.txt
file. Then we are going to copy our
source code. So under source code we
have single file app. py which we are
going to copy and then we are going to
expose it to 5,000 port. So this is
basically 5,000 port is a local port.
It's not this port will not use in your
Azure sorry kubernetes services. So if
you are building application locally
then you can use this port 5,000 and
this is the command line argument like
whenever our container will start which
file it will trigger. So it will go and
hit this app. py. So this is very simple
docker file which we are going to use.
Pipeline.ml
file I will come little later. Let's
verify another repositories. So another
repositories we have let me see
okay GitHubs repo. So here I have
created a folder called called K8S and
here I have simple two deploy two files
the very one first is deployment.ml file
where basically
we want two replicas of our applications
and this is the name of our application
demo app. We have defined labels because
we need to reference this to a
service.ml file [snorts]
and this is the image which we are going
to use. So now why we need two
repositories. So the the answer is
because the the very first repose which
is your application source repos from
that particular repose you are going to
build your image and push your image to
a docker container sorry uh it could be
a docker container registry but in our
case we are going to use Azure container
registries. So basically we are going to
push our image on azure container
registry. So,
so what we are going to do as part of
this file during the pipeline basically
so we are going to change this
particular tag. So tag is something
called a commit id basically. So if we
are going to make any changes new build
will be triggered and automatically this
particular version this tag basically it
will update. So if you can see as of now
we have 1074. As soon as we will run a
build this particular path will
automatically updated because end of the
day we cannot use continuous delivery
using Azure DevOps. So in our case Azure
DevOps we are going to simply use to
build and push our docker image and we
are going to update the tag of our image
on this githops repo because in arg we
are going to reference this githops
repositories. So we will come on that
part little later. Now let me go back to
my architecture. So here what we are
going to do so we are going to build our
docker image and we are going to push to
azure container registry. So let me open
a pen here.
So from Azure pipeline we are going to
building our docker image and we are
pushing pushing to Azure container
registries and once the docker image
will be pushed the next next in next
stage basically we are going to update
our GitHubs repositories with the latest
image tag because in Argo CD this
repositories will be referenced and it
will automatically shrink and deploy
your resources to Kubernetes cluster. So
this is very simple architecture which
we are going to follow. [snorts]
I hope it's clear.
Okay. Now let me
okay so this is a service service.ml
file which I forgot to explain. So this
is simple API version kind
as a load balancer because we want to
[clears throat] access our application
from the local system. And this is the
selector demo app. The same label we
have defined in deployment.mml file. So
at least service should know where it
needs to forward the traffic. And we are
going to expose our application on port
80. And target port we have defined here
5,000 which we have mentioned in app.py.
Okay. So this is very simple manifest
file but in real time you will have so
many ml file or maybe halum charts.
Now the interesting part is
pipeline.ml file.
So let me go to my repositories and let
me explain pipeline.ml file because that
is the heart of cicd.
So let me check python flask.
Okay. So this is our pipeline.mml file.
So here trigger we are going to use main
branch because we have a main branch
here. So whatever changes we will commit
on this main branch it is going to
automatically trigger your pipeline. If
you have enabled continuous integration
in your pipeline and we have defined two
variables here image name this is the
name of our image demo app and this is
the azure container registry which is
Argo CD21. If I will go to my ashure
folder sorry portal and this is the
repos sorry container registry name Argo
CD21. Here we are going to push our
images.
So if you see this particular stage
build and push docker image this is very
straightforward.
So we are going to use a built-in task
here. So here we will not able to see.
Let me do one thing. Let me open the
pipeline itself. I've already set it up
this pipeline because at unnecessary it
will take lot of time to set up a
complete pipeline.
Okay. So here we have declared two
stages basically. This is the very first
stage is build and push docker image and
another stage we have created here
update githops repository.
So let's see what we have in first
stage. So in stage one we are simply
going to build and push our docker image
sorry uh oh sorry yeah docker image on
uh azure container registry.
So for that we are using built-in task.
So if I will go to settings here. So
this is the cast task which we are going
to use container registry and this is
the container registry name. This is the
uh variable which we have created here
because we have already defined the
variable here demo app. If you if you
don't want to specify variable in
pipeline.ml file you can use library
variable as well.
And here we are going to use tag build
dot build ID. So this will be the image
tag which we are going to update in our
manifest file deployment doml file
and again this is also a very important
part here. So this is the commands I
have added here to explain this
particular command command basically
what this command is going to do. So
here what we are going to do here
basically we are going to create a
output variable where we will store our
image tag so we can use in stage two.
So this is the internal
uh this script hy eco and this is the
basically internal command syntax or we
can say a built-in command syntax on
ashure devops which we can use. So
the very first thing if you see here
this particular part here. So basically
this particular part tells Azure DevOps
create a pipeline variable with the with
this name and value. So you can see task
dot set variable and variable name is
image tag because variable equal to
image tag. So this is the variable which
we are going to create and another here
you can see is output equal to true. So
this basically makes this output
variable to available outside the job or
outside the stage basically. So suppose
if you want
such or if you want to use this
particular variable in another job or
maybe in another st for that you have to
define is output equal to true. So your
variable will be available to use in any
other jobs or in any other st. And this
is the build dot build ID. So this is
the value which we are going to set for
this image tag variable.
So this is the very first stage which we
are going to use. Simply we are just
going to build our docker image and we
are going to push our image to Azure
container hs and we are going to create
a output variable to store our image
sorry a build ID basically and if I will
come to a next stage which is update
githops repos. So here we are just
replacing the image tag with the build
ID on githops repositories.
So the stage name is update githops
display name is whatever name you want
you can give it depends on build and
push. So once this st if you see the
name of this st is sorry build and push.
So once this stage is successfully
completed then only this stage two will
be triggered because we have specified
here condition succeeded
and this is the variable image tag. So
if you can see
uh
okay so image tag
we have created here this variable image
tag. So if you can see how we are going
to reference it here uh dollar bracket
open bracket stage dependencies dot this
is the stage name build and push and
build job dot outputs
and
set image tag dot image tag. So this is
the variable which we are going to
create. So here basically we are getting
the image tag value that we have created
as part of this particular task. So here
we are going to store build dot build ID
under this particular variable which is
image tag.
Second is jobs update githops jobs
whatever name you want you can give it
here. Similarly for display name and
here we don't need to check out the
complete uh GitHubs repositories or
whatever name you are going to give for
your manifest repositories you don't
need to check out that particular uh
what is called
repository sorry
so here uh basically we are going to use
a script
so we are going to use inline script if
you want you can uh keep this script in
your uh repositories as well and you can
use file path as well.
Okay. So the very first thing what we
are going to do we are going to create a
variable called
get high clone_dir
on azure devops agent and the value is
githops - local. So this is the
environment variable which we are going
to create uh on Azure DevOps agent where
in background this task or this script
is going to execute and the folder name
will be GitHub local means the value of
this variable will be GOP local. So
whatever code we are going to use or
copy or maybe clone that will be cloned
under GitHub local folder. And another
folder or we can say uh sorry
environment variable we are going to
create here is ks - deployment path. So
this is the path of our deployment. ML
file. So if I will go to my
repositories. Let me open it another
window.
Okay. So here we have a folder called
K8S and under this folder we have a
deployment.ml file. So that's what we
are going to create a variable here. K8-
sorry a K8S
deployment path equal to this value. Now
we are going to configuring the
identity. This is uh required when you
commit your changes or when you push
your changes. For that you need need a
uh user email and user uh name. So you
can give any name it doesn't matter but
it is required. So here we are going to
use clone our g repositories. So this is
a very important part here because and
we are going to clone this repositories
under
uh githopsy local folder which we have
created. [snorts]
Okay. So now if you can see here in get
URL this is the variable which we have
declared. Here we are going to use https
colon double/x. So x is here is a
username
and githops_p
secret is a variable which we have
created. So basically to you need to
authenticate your githops repositories
as well. So for that you need a pat
token. So this is the pet token which we
have created. Let me show you how you
can create it.
So you have to simply uh go to here
personal access token
and for example in our case we are going
to use cicd githops push.
So if I will edit this we cannot see the
password here but we can see the name
here. So this is the token which we are
going to use and we have given a
permission here as well. So if I will
come here uh if you can see under code
read and write in under build we have
defined read and execute. So these are
the custom permissions which we have
given to this pet token. So this
personal access token is going to use to
authenticate your githops repositories
where you have your manifest file. So
this is required
and I have declared this under
variables. So here you can see githops_p
this is the variable and this is the
value of this pet token which we have
saved here
and this is our repository URL. So if
you see uh let me go to repository
again.
So if I will do a clone. So this is the
repository URL you can see githops -
repo and same thing we have mentioned
here but before that we need this
username and password to authenticate
this our repository if you want you can
also use uh get credentials as well like
for example you can generate a get
credentials so this will also basically
generate a pack token for you
okay so this is required for cloning our
uh repositories on ascent basically
where we are going to do a replace
image tag.
Okay. So this is the command which we
are going to use get clone and this is
the URL. So we have used a variable
dollar URL and this is the get clone
directory which we have defined here
which is githopy local. So this code uh
this repos will be cloned under githops
- local folder inside your azure devops
agent
and here we have defined which branch
you want to check out. So we have
defined a main branch because this
manifest file also we have under main
branch
and this is the full image. So here
basically we are using a variables ACR
repositories. So this variable we have
declared uh top of the uh ML file. So
this is the repository URL sorry
container registry URL and uh similarly
image name. Image name also we have
defined here which is demo app. So these
two variables we are going to use here.
[snorts]
Okay. Where it is? Okay. And this is the
image tag. So image tag is uh
this one.
This is basically build id. This is the
output variable which we have set it up
in st one here basically.
Okay. So this is the full image and this
is the basically simple message using
the eco command. Uh we are passing like
updating deployment file with new image
and this is the very important command
which is actually doing a replacement
here.
So you can see the first sedd i. So sed
oh sorry so sedd stand for
[clears throat] stream editor command
and hyphen i basically it's addit the
file in place like basically override
the file. So for that we use hyphen i
and s pipeline symbol image. So this
basically find any line which start with
image
[clears throat] because if you can see
we have used image colon dot dot start.
So any line which is start with image uh
image thing basically it will override
it. So if I will go to here uh let me go
to deployment.mml file. So you can see
the image. So anything it find after the
image it will replace entire thing
basically [snorts]
[clears throat] and this is the full
image path which we are going to use. So
full image we have uh covered here
and uh
okay so there it is okay and this is the
deployment path so where is your ML
deployment doml file so this is also we
have checked it out here like basically
we have created our environment variable
for that
so insert short. This is the line which
is going to replace your image docker
image id or sorry not id image tag
basically here.
So this is the replace pattern like what
this command is going to do. So that's
what I have explained in this particular
line. What I will do I will update this
entire code on uh GitHub and I will
share the link in description box. If
you want to do hands-on with your own,
you can do that also. So simply we are
going to use we are going to add a local
changes then we are going to commit the
changes and they are we are going to
push those changes to our our GitHubs
repositories. So simple terms like what
we do in our local system we will
download the code or we will check out
the code on local system. We will do
some modifications and we will update it
back to any repositories GitHub, GitLab
whatever you are going to use. So here
simply we are just using we are just
replacing the build ID which is required
because that new tag will have the
latest changes as well. So this is the
pipeline.ml file which we are going to
use. So now let me do one thing. Let me
uh run this pipeline. So if you see
here, let me open this. So for now you
can see the build ID here is 1074.
So once we will run this pipeline, let's
see what ID will come.
So [clears throat] new ID here is 1075.
So this file will automatically replace
with 1075.
Let's wait to complete this pipeline.
And as of now uh we have not set up the
Kubernetes cluster and Argo CD. So that
part is also remaining. So meantime this
pipeline is going on. Let's quickly go
and set up a Azure Kubernetes cluster as
well.
Here the important thing is like we are
not using or integrating Kubernetes
cluster with Azure DevOps. We are just
updating building our image and pushing
our image to Azure container registries
and we are just updating our manifest
file and in Argo CD we are directly
referencing our Azure repos with Argo
CD. So whatever the latest changes we
will push on uh GitHubs repo it will
automatically deploy to Argo CDN. That's
why we call as a GitHubs pipeline as
well.
So let's quickly create a Kubernetes
cluster here.
So [clears throat] I'm not going to
explain uh this thing because I have
already covered many times in my
previous videos. So let me use cluster
name. Okay. Rest all the fields I will
leave uh default.
Okay. Under note poolool I will change
the image sorry uh VM size here because
we don't need this high configuration
for this demonstration.
So here I will go with a series.
Let me choose A2 B2.
And uh number of node counts we need max
minimum one and maximum two. Let me
update this.
[snorts]
[clears throat and cough]
Okay. So here also I will leave
everything default networking. Let me
add my container registry here. This is
uh anyways not required because we are
not going to use an assure container
history here. So let me uncheck it
because it is not necessary
and ashure policy it's fine. I don't
want any monitoring even alert as well.
Next.
Next. uh and review and create.
So uh this setup is going to take at
least 5 to 10 minutes. So meantime uh
let's verify our pipeline. Okay. So we
can see our CI pipeline is completed.
Image tag output it's okay. completed
build and push.
Okay, so it successfully pushed our
Docker image as well. Let's quickly
verify it. Let me go to
Okay, so in container is repository
which is demoy app and here we have a
latest build ID which is 1075.
Okay, now let's verify here. Let me
refresh this.
So here we have latest changes which is
1075.
We have not made any changes but once we
will set up this Argo CD part we will
make some changes and we will do again
we will build our pipeline. So we will
at least verify okay how Argo CD is
automatically going to pick our changes
from the GitHubs repository.
[clears throat]
Okay. So, uh let's Okay. This is also
completed and we have also verified the
build ID is 1075
here. So, let's wait couple of minutes.
Uh once the deployment of AKS cluster
will be completed, we will move forward.
Okay. Uh so deployment is completed
successfully.
Now let's connect to this cluster first.
So let me open the command prompt.
So here I will go to connect and I will
use Azure CLI and I will download the
cluster credential which is required to
connect to the Kubernetes cluster. So
let me run it.
Okay, let me copy again.
So basically it will download uh cluster
config credentials in my local system
which is this location under cube
config. So let me run cubectl
get ports and let me verify all the
ports.
So if you can see uh we don't have any
pod
with the name of Argo CD and Argo CD
server run inside a Kubernetes clusters.
For that there are few steps which we
need to follow. So let me clear the
screen first
and I will go to my GitHub. So here are
the steps which I have mentioned here.
So the very first thing we need to
create a nameace called Argo CD. It is
recommended you have to create a
separate nameace for your Argo CD
server. So let me copy it this command.
Let me run it. So if I will run c ubectl
get name spaces. So we have these many
default arcd and these are the system
node spaces.
Next thing we need to install the Argo
CD. So for that we will this is the
official command which we are going to
use.
[snorts]
So this will install lot of things which
is required to run Argo CD server inside
a Kubernetes cluster.
Okay. So this is completed. Let me
verify the ports. Cubectl sorry cubectl
get ports - sorry we will use a name
space called argo cd.
So here we can see the status of
containers. Argo cd application
controller. Then we have uh notification
controller, radius repo server, Argo CD
servers. But we are interesting about
this particular part Argo CD server. So
from this basically once this part is up
and running, we can access the user
interface of Argo CD server.
[snorts]
So let's wait a couple of minute. Once
the status of all the ports will be
running, we will uh try to access our
Argo CD server.
Okay, let me rerun it.
Okay, so now we can see the status is up
and running. But still we can see a zero
out of one. Uh maybe it will take again
few seconds. Okay, now it's came up one
out of one which is up and running.
So now we need to access
the Argo CD server from our local
system. So when we install Argo CD using
this particular official command, this
particular command basically use a
cluster IP which will not provide us a
external IP address. So if I will go and
check the services, let me clear this
cubectl get SBC.
So here we can see sorry uh we have to
specify name space which is Argo CD.
So these are the services if you see
Argo CD server. So we have it is by
default is using cluster IP and we don't
have any external IP. So we cannot
access Argo CD server from our local
system. For that we need to change the
type here. we have to change it to
either node port or load balancer. So
for that we are going to use cubectl
patch command. So this will update the
configuration.
[snorts]
[clears throat]
So let me check again.
So you can see a cluster sorry here
network type is load balancer and the
external IP status is pending state.
Okay. So now we get the external IP
address of our Argo CD server. So let me
copy it and open it in our browser.
Okay. So this is self-sign certificate
official. So sorry not this is not a
valid certificate that's why we are
getting HTTPS warning here and by
default username of Argo CCD server is
admin
and for password so for password
basically
uh let me check the command.
Okay. So the initial password of Argo CD
server will be stored under
this particular
uh [clears throat] application part. So
if I will simply run cubectl get
secrets.
Let me clear the screen first.
Okay. Let me use name space aroc.
So this is the initial admin password.
So under this file basically under this
secret we will have a encrypted
password. So we need to use or we need
to basically decrypt the password first.
So first we need to identify what
password we have inside this file. So
for that what we will do we will simply
output this as a x ml file. Okay it's
not copied. Let me copy again.
So this is the password but this is the
encrypted password. If I will use this
password here it will not work.
You can see invalid username or
password. So what we have to do? We have
to decrypt this password first. So I'm
not using a window. So I'm going to use
a power cell to decrypt this password.
So let me copy this command and let me
open the power cell.
Now this is the value of our password
basically. So let me copy it
and let me run it here.
Okay.
Okay. Still it's showing invalid.
Let me refresh it.
Let me open a notepad as well. Maybe the
password which I'm copying is not
correct or maybe some spaces is there.
Okay, let's verify it.
Okay, it looks like correct only.
Okay. So there is one thing which I have
missed here. So the very first thing
what we have to do.
Let me open it in this window. So it
will be more clear.
Okay.
Let me copy it again because this is not
a correct encrypted password. So let me
copy it here and I will go to my command
prompt and let me copy this encrypted
password first.
And I will change the value here.
Now let me run it. So this is the
correct password.
[snorts]
Okay. So this is the user interface for
Argo CCD server. So now what we have to
do? We have to add our Kubernetes
cluster on this Argo CD server. So for
that we will go to settings and
clusters. But here you will not see any
options to add Kubernetes cluster. So
for that we need to use command line or
Azure CLI. Whatever preference you want
you can use it. So for that
uh first we will log to Argo CD server
and let me open my command prompt. Let
me clear the screen.
And here we need to change this IP
address. So what is the IP address of
our Argo CD server? Let me copy it.
Let me put Y. Now we need to again give
a username. So which is admin. And let
me copy the password.
Okay. So now it's logged in
successfully.
Let me minimize this. This is also not
required.
Okay. Now we need to add our cluster. So
this is the command argu cluster add and
this is the cluster name which is my AKS
cluster and hyphen insecure because we
don't have a valid HTTPS certificate.
So let me uh run this command.
Let me run yes.
Okay. So now if I will go to Argo CD and
let me refresh this. So now we have
added our cluster on Argo CD servers.
Next thing what uh next you need you
need a repositories
which will be automatically sync. So for
that we will use repositories connect
repo and here we will use http and https
type g
and you can give any name. So let me
give my repo
project name. Let me use default
repository URL. So now let me take a
repository URL. Let me clone it
and I will copy this command.
Oh sorry.
Now again we need a credentials to
authenticate this particular
repositories. So what we will do? We
will uh go to repositories and we will
generate a credentials. So you can see
the username is sub.agraal but we can
give any username here. Let me copy the
password. So here let me give username
uh demo and password I will give
password here.
Now let me click on connect.
So you can see connection status is
successfully. Now my Argo CD server is
connected to my GitHubs repo. Next thing
what we have to do you have to create a
new application here. So here you have
to define your application name. In our
case we will define uh Python app.
Project name we will use default.
Synchronization policies how you want to
synchronize your repositories
using Argo CD server. So we want
automatic like whatever changes we will
push as soon as we will make any changes
or any commits on our repositories it
will automatically shrink those changes
selfhealing as well this is also
required and rest all the fields I will
leave default. So now we need to define
source and destination. So source will
be our repositories which we have added
and revision is head. So head basically
is a commit id and path. So let me check
the path here. So path we have
k8 - s sorry a k8 s not hyphen.
Now cluster URL we will select from the
list and name space we will use default.
So whatever the resources will be
deployed that will be deployed in
default nameace.
So let me create this application.
So we have just created the application.
Now you will see the synchronization. I
have not done anything. It is
automatically start synchronization.
Sorry it will it is automatically
started shrinking our repositories.
So let's wait couple of minutes. The on
the status will be healthy or successful
then we will verify it.
So you can see we have defined two
replicas of our application. So we can
see a two replicas here. Two part is
getting created but the health is still
progressing. So let's wait couple of
seconds.
Okay. So we can see still it's in
progressing. Why? If I will open my pod
here and let's verify the events.
So we are getting a back of pulling
image. Why? Because when we have created
a Azure Kubernetes cluster we have not
integrated Azure container registries.
So AKS cluster is not able to pull the
image from the ACR. So what we need to
do now we need to integrate or we need
to attach Azure container registry to
Kubernetes cluster first. So let me do
one thing. Uh let me open a command
prompt here. Let me clear the screen
and let me use this command.
Okay. So the source group is not
demo.
Let's see if it works.
Okay, so it is adding ro
So basically uh when when I was creating
Azure coordinate services I completely
forward we need to integrate our Azure
container registry as well because end
of the day the image will be pulled from
the ACR itself. So that's what now we
are going to attach our Azure container
registries with Kubernetes clusters. But
like if you are creating
fresh Kubernetes clusters then it is
recommended you always integrate your
ACR while you are doing setup using
Terraform or maybe using Azure portal.
So let's wait couple of minutes. Let's
see what will be the result.
Okay. Okay. So we can see this command
is completed successfully. So it is
attached our Azure container registry
with uh AKS clusters. Now let's go and
verify the health status.
Okay. So now we can see the app health
is healthy and both the application pod
is up and running.
Let me go to this and
let's browse our application first. So
what we will do? We will go to uh Google
demo services and from here we will get
a load balancer IP address. Let me copy
this
and
so we are getting a message hello from
Azure DevOps plus Argo CD pipeline. So
now what we will do we will make some
changes and we will again build our
application and and you can see this
commit ID is 2 AC 9345.
If I will come to this and check
history.
So let's see commit ID here is 2 AC 93.
So this is the commit ID. So it will
basically automatically use a latest
commit ID if you are using had. But if
you want to specify any tag, you can do
that as well. So what we will do? Uh let
me go to my application
and here I will make some changes on
this file.
So let me sorry remove this and let me
add this is a simple demo of
Argo CD.
Now let me commit the changes.
Okay, let me go to pipeline. So I have
not enabled a CI/CD. Sorry, continuous
integration that's why it is not
triggered. So let me run this pipeline.
Let me minimize it again. Run.
So now if we will see uh
latest latest commit ID. So that we will
see here as of now it's 2 AC. Let's uh
wait to complete this pipeline first.
[clears throat]
If you want you can add some health
status on uh Azure DevOps as well to
verify the health status of your
applications.
So now build ID is 1076.
You can see here now the commit ID has
been changed to AC2. It is now 023
something. So let's go to this
repository and refresh it. So we have a
latest commit which is 0231.
And if I will go to
deployment doml file as well.
So here you can see 1076 is a build ID
and same we can here is build ID is
1076. Now let's go to here. Go to
application.
So here we have
okay it is not shrink yet. So let's wait
for few seconds
because you can see a last shrink is 60
minute ago and it is automatically
should be refreshed. So let me refresh
this one.
You can see it is start
shrink and you can see the last string
is the few second ago. We have not done
anything. We have simply run our CI
pipeline which build and push our docker
image and uh update the GitHubs
repository and it is automatically
deploy the latest changes on our
Kubernetes cluster. If I will come to
this and refresh it. So this is the
message which we have added. This is a
simple demo of Argo CD. So that's how
basically you you can set up a CI part
with Azure DevOps and CD part with Argo
CD. similar combination you can use any
CI tools basically
and uh
this is the GitHub sorry uh GitHub repo
link which I will add in description box
and these are these two folders contain
the entire applications code and
manifest file as well so I hope it's
clear in case if you have any doubts you
can uh definitely ping me on comment box
so that's all for today see you in next
video thank you so
📌 Azure DevOps CI/CD with Argo CD | Full GitOps Deployment to Kubernetes (End-to-End Workflow) In this video, you’ll learn how to build a complete CI/CD pipeline using Azure DevOps and Argo CD to automate Kubernetes deployments using the GitOps workflow. We walk through the entire real-world setup, from configuring pipelines to deploying applications into AKS using Argo CD’s declarative GitOps model. 🔥 What You’ll Learn ✔ What is GitOps & Why Argo CD? ✔ Setting up Azure DevOps Repos for GitOps workflow ✔ Creating CI pipeline for container image build & push (ACR) ✔ Writing Kubernetes manifests / Helm charts for GitOps ✔ Setting up Argo CD on Azure Kubernetes Service (AKS) ✔ Configuring Argo CD Application to watch Git changes ✔ Automating CD pipeline with pull-based deployments ✔ Full end-to-end workflow demonstration 🧰 Tools & Technologies Used Azure DevOps (Repos, Pipelines) Argo CD Kubernetes / AKS Docker Azure Container Registry (ACR) GitOps Workflow 📂 GitHub Repository - https://github.com/shubhamagrawal17/Tutorial/tree/main/ArgoCD 👍 Like • 🔔 Subscribe • 💬 Comment If you found this helpful, support the channel by liking the video and subscribing for more DevOps, Kubernetes, and CI/CD tutorials. #azuredevops #argocd #gitops #kubernetes #aks #azurekubernetesservice #cicd #azuredevopspipelines #devops #cloudcomputing #kubernetesdeployment #gitopsworkflow #argocdtutorial #azuredevopstutorial #containerization