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