[Music]

have you ever wondered how big companies

deploy their applications into

production

environments understanding the process

and the best practices when deploying to

production is very important for all

devops Engineers to know and in this

video I will explain you all the steps

in this process with the flowchart

diagram so make sure you watch this

video till the end and also subscribe to

Cloud champ if you haven't subscribed so

the process starts in the planning phase

where the client or the team discuss

about the goal and the objective of the

application also the task required to of

this application which are broken down

into smaller pieces such as epics or

user stories also known as tickets and

added into a project management tool

such as jira your company might be using

Azure devops or Trello but all the

tickets are added into a project

management tool which are then picked up

by the developers so the developers are

going to pick up the tickets that are

assigned to them and start writing code

for it so they will build a code locally

test it and also deploy the application

out properly they will then push this

code onto a central repository maybe

using GitHub or gitlab or bit bucket

anything you want to use so developers

will push this code from their local

machine to GitHub using

git on GitHub we have different branches

so we have the main or the master branch

and we can also create more branches if

you want usually it is not recommended

to post directly on the main branch so

we don't follow it while doing it in

production we will instead create a

feature Branch so developers are

requested to create a feature Branch

depending on what feature or bug they

are working on so they will create a

feature Branch let's call this at

feature

branch and instead of pushing it to the

main branch they will first push to the

feature Branch so they're going to push

to the feature branch and they will test

the feature Branch properly if

everything works out they will create a

merge request which will go ahead and

merge this scode from the feature Branch

to the main branch so you will be

merge request so this full request is

usually reviewed by a senior devops

engineer or a developer before it is

merged into the main branch because on

the main branch we usually have cicd set

up for example let's say we using GitHub

actions for cicd here GitHub actions is

a very popular tool that lets you

automate building testing and deploying

your application so whenever you push to

a main branch this will trigger a cicd

pipeline in the GitHub actions and that

will go ahead build your code also test

it and deploy it either on your

kubernetes cluster or let's say AWS

cloud in our example here so this is the

process followed whenever you want to

push your code to production the

developer is going to create a feature

Branch a pull request will be created

reviewed by a senior devops engineer and

then merged into main branch which will

go ahead and Trigger the pipeline this

pipeline will build test and deploy the

application on AWS cloud or any other

the provider but this is not the best

practice when deploying critical

application you should have different

environments like Dev environments

to the main or the production

environment so instead of pushing a

changes to the main branch and creating

an application through it we will first

push the change to the dev branch and

test out if everything is working

properly if it works properly we will go

to the upper branch which is the test or

the staging branch in this Branch we are

going to be using the prepr data which

is very similar to the real data that is

going to be used in our application so

we will test out things using the prepr

data this will be very similar to the

production application or production

environment here and we are going to be

doing load test to make sure that the

application is able to sustain the load

we will also do some smoke test to make

sure our application works properly in

the production if everything works

properly then we will merge this into

the production Branch so that the final

application should be available to the

users and you should have no the problem

so this is the process companies follow

to deploy their applications to

production they start by writing the

merge that Branch into the dev Branch

test if everything is working properly

if it works properly then they merge

that Branch into the staging branch

check it with the prepr data do smoke

test integration test load test

everything to make sure that the

production is going to have no problems

once that is done from staging you push

that application to the prod and then

the prod is going to deploy your

application which is going to be used by

your end users so the end users are

going to consume this so this

application is going to be used by the

end user after it is deployed in the

production

environment now once the application is

deployed properly we are also going to

be making sure that the application runs

properly by continuously monitoring it

continuously making sure that the

application is highly available which is

called as the post deployment stage

where we continuously check and monitor

that the application is working properly

so this is a continuous process where

you make changes merge it to the

branches take feedback from your users

companies deploy their code to

production I hope this video was

informative if you have any questions

any doubt let me know in the comment

section so this was our video I hope

this video was informative if you have

any questions any doubt let me know in

the comment section if you want me to

create more videos like this please let

me know in the comment section thank you

and have a good day