शैडोइंग अभ्यास: How to design a Deployment Pipeline (GitOps) - वीडियो के साथ अंग्रेजी बोलना सीखें

अभ्यास मोड चुनें

हर मोड पूरी स्क्रीन का अभ्यास कक्ष खोलता है।

127 वाक्य

यदि वाक्य बहुत छोटे या लंबे हों, तो समायोजित करने के लिए Edit पर क्लिक करें।

Hey everyone, in this video we're going to talk about how you can design a deployment pipeline using GetOps principles.

So if you're looking into designing a deployment pipeline or just want to learn a little bit more about GetOps,

this is going to be the video for you.

Now this video takes place after my last video which was how to design a CICD pipeline.

So if you're not sure how to design a CICD pipeline, make sure that you watch my previous video.

I'll let's go ahead and get started with the design of our getops pipeline.

Alright so here you can see that we have a pretty simple CI CD pipeline.

This pipeline takes our application code stored in our application repository, takes it through the source build test and release stage

and basically the output is going to be a container image and that container image is stored in our registry.

So you can see we have our application right here and it's version 1 .0.

So where do we go from here?

This is where we need a continuous deployment pipeline to actually take this application image

and bring it over to our different environments.

So the first thing that we want to do

when designing our deployment pipeline is create a second repository to house our configurations.

So our CI -CD pipeline is going to check out code from our application repo,

but our deployment pipeline is going to use our configurations from our configuration repo.

So this is a traditional GitOps pipeline.

So let's create another repo here, and then we'll call it config repo.

And this config repo is going to contain all the configuration files that we need for deploying our application.

So this could be anything from like Docker Compose files to Kubernetes Manifest.

So let's go ahead and populate this config repo with some manifest files.

So I'm going to put a Kubernetes Manifest file here.

And let's just think about what would be in this manifest.

So in this manifest, we would probably have something like a Kubernetes deployment.

So we'll call it deployment and this deployment probably uses an image

and the image it's going to use is going to be the image from our CI CD pipeline.

So we called it my app and we'll just tag it with v1 .0.

Now let's just move this out of the way and get an environment for us to deploy to.

So we have our server here, and this could be any type of server.

We'll just call it our test slash QA environment.

Now your GitOps pipelines can deploy to your environments in two different models.

The first model is known as the push model.

So we'll call this push.

Now the push model is really simple.

It's as simple as just doing something like a cube control apply.

So we're just going to keep it as that for now.

And then I'm going to discuss the pull model,

which is the more modern approach of actually having an operator installed in your environment that pulls down your configurations.

So let's talk a little bit about how this pipeline gets triggered in the first place.

So your deployment pipeline should be triggered automatically at the end of your CI -CD pipeline.

So let's draw an arrow here from our CI CD pipeline

because it's going to trigger our deployment pipeline as soon as it's done completing.

Now, every time you run your CI CD pipeline, it should be churning out a new version of your application.

So you can see here we have version one of our application.

And the next time we run our pipeline, we're going to get version 1 .1.

Now, if you have a really well -designed pipeline,

what you may want your pipeline to do is to actually go into your configuration repository

and submit a pull request or just push a change to it to actually update the image.

So here I'm going to update the image tag to v1 .1

and all my deployment pipeline really needs to do is rerun kubectl apply

and that's going to deploy it to my test and QA environment.

Now once the code is actually running in your environment, you should have some observability tools plugged in to monitor your application.

So at the very least, you should have something like Prometheus to scrape metrics from your applications.

And then you should have something like Grafana

so your QA teams can actually visualize the changes

and make sure things like the latency hasn't increased and all your key performance indicators are up to snuff.

Now once your deployment has been running in your test and QA environment for some time, what's next is to promote it to your other environments.

So usually you'll have something like.. a staging environment and a production environment.

So staging environments are usually just environments that are similar to production.

It's where you send your deployments first, and you're basically pretending it's production.

You sort of treat it like production, but it's not production.

And then production, of course, is where your live code runs.

This is where the customers are accessing your applications.

So let's draw some arrows to these environments here and the way

that these environments get pushed to is they can automatically get pushed to by your GitOps pipeline

or these can be manually gated by a person.

So sometimes companies aren't comfortable with having everything automatically trigger to their staging and production environments.

Usually they want an engineer to actually run the pipeline manually.

So these ones might be manually or automatically triggered.

Let's now talk about the pull model and then I'll get into canary testing, which is a common thing that's done in production environments.

So with the pull model, I'm just going to take these arrows

and I'm just going to change the direction since they are pulling their configurations and deployments down from our configuration repo.

So instead of CICD server doing a kubectl apply, they would have what's known as an operator installed in them.

So if this is our Kubernetes cluster, then we would have something like Argo CD installed into each of our clusters.

And basically what Argo CD does is it just checks your repository and it checks the state of your clusters.

And if it notices

if the state is different in your clusters than it is in your configuration repo

then it tells you it's out of sync.

Now it can automatically sync your environments for you or it can be manually triggered again.

So you may have your test and QA

and even your staging environments do what's known as an auto synchronization through something like Argo CD

and then you can have your production environment where someone actually needs to click the button to sync the environment.

So Argo CD is really simple to set up actually

and basically you just point it to your get ops repository

and then it just checks your configurations

if anything's out of sync it'll help you sync

it i do have a full length video on how to set up

and get started with argocd so

if you're interested in working with argocd make sure to check

that out i have a link in the description below let's now talk about canary deployments

which is something you should absolutely introduce into any deployment pipeline

So let's talk about how our user actually talks to our application.

So we got some users here, and those users usually talk to our application,

not directly, but they talk through what's known as a load balancer.

So the load balancer is going to load bounce traffic to our application.

So our application is running under a Kubernetes pod.

So we'll just say this is myapp v1 .0 and then we'll say myapp v1 .1.

In a traditional Canary deployment, what would happen is you would have both of the applications deployed.

100

But at the start, it would send 100 % of the traffic to your original application.

101

So we'll say 100 % there and then 0 % here.

102

And then gradually the traffic will be moved over to the new version of your application.

103

So maybe you do it in increments of 10%.

104

So you go 90 % there,

105

10 % there, and then eventually you go 80 % to 20 % and you sort of get the idea.

106

Basically, you're drifting the traffic from the old version to the new version until eventually

107

you have 100 % of the traffic going there.

108

And you can just cut off all the traffic to version one and remove that from your environment.

109

And you just keep doing this for all your new releases.

110

Now, if you're using something like Argo Rollouts in Kubernetes, it would look more like this.

111

This would be actually your rollout object.

112

If you're familiar with Kubernetes, a rollout is basically just a deployment.

113

And a deployment is something that creates your pods, which is basically just your containers.

114

So the rollout object would run a certain number of pods for your version 1 of the application,

115

and then a certain number of pods for version 1 .1.

116

And then as the rollout progresses...

117

It would basically add new pods running the new version of the application

118

and then remove old pods running the old version until eventually all the pods are gone in version one

119

and they're all running in the new version.

120

All right, so I hope this video was helpful on getting to know and understand GitOps and deployment pipelines.

121

If you have any questions, please leave them down below.

122

I know these deployment pipelines can be a little bit confusing at first, especially if you're coming from just designing CICD pipelines,

123

which are pretty much the same no matter which organization you work for.

124

All the stages are sort of the same, but with deployment pipelines, it's really going to be customized to your environment and how your company functions.

125

So make sure to ask some questions below and check out the other videos linked in the description below.

126

I'll have all my Argo related videos that goes over Argo CD as well as one for Argo rollouts.

127

Thanks again for watching and I hope to see you all in the next video.

ऐप डाउनलोड करें

धाराप्रवाह बोलने के लिए ज़रूरी सब कुछ

AI उच्चारण स्कोरहर वाक्य का स्कोर

IPA अभ्यासहर ध्वनि में महारत

शब्दावलीअपना शब्द भंडार बनाएँ

शब्द गेमखेलते हुए सीखें

QR स्कैन करें

Download on theApp Store Get it onGoogle Play

FOR YOU

अनुशंसित वीडियो

90 वाक्य

इस पाठ की शब्दावली और बोलने के सुझाव

यह स्पीकिंग पाठ वीडियो “How to design a Deployment Pipeline” पर आधारित है। सबसे ज़्यादा दोहराए गए शब्द ये हैं: pipeline, environment, deployment, application, version। इस वीडियो में शैडोइंग के लिए 127 वाक्य और 1713 शब्द हैं। बोला गया हिस्सा 11:01 लंबा है। वक्ता लगभग 156 शब्द प्रति मिनट की स्वाभाविक गति से बोलता है, जो रोज़मर्रा की बातचीत के करीब है। केवल 81% शब्द अंग्रेज़ी के 3,000 सबसे आम शब्दों में से हैं, इसलिए शब्दावली कठिन है।

इस वीडियो की मुख्य शब्दावली

वीडियो के 15 सीखने लायक शब्द, उच्चारण और अर्थ के साथ:

शब्द	उच्चारण	अर्थ
pipeline संज्ञा	/ˈpaɪpˌlaɪn/	पाइपलाइन
pod संज्ञा	/ˈpɑd/	फली
manifest संज्ञा	/ˈmæn.ɪ.fɛst/	घोषणापत्र
cluster संज्ञा	/ˈklʌstɚ/	गुच्छ
server संज्ञा	/ˈsɝvɚ/	सर्वर
arrow संज्ञा	/ˈæɹəʊ/	तीर, बाण
container संज्ञा	/kənˈteɪ.nəɹ/	पात्र, डिब्बा
operator संज्ञा	/ˈɑpəˌɹeɪtɚ/	संचालक
gate संज्ञा	/ˈɡeɪ̯t/	फाटक, द्वार
helpful विशेषण	/ˈhɛlp.fl̩/	मददगार
introduce क्रिया	/ˌɪntɹəˈdus/	परिचय
monitor संज्ञा	/ˈmɑ.nɪ.tɚ/	पर्यवेक्षक
principle संज्ञा	/ˈpɹɪn.sɪ.pəl/	जड़सूत्र, असूल
pretend क्रिया	/pɹəˈtɛnd/	ढोंग
continuous विशेषण	/kənˈtɪn.juː.əs/	निरंतर

वीडियो में आने वाली फ़्रेज़ल वर्ब

शब्द	उच्चारण	अर्थ
go ahead क्रिया	/ˌɡoʊ əˈhɛd/	आगे बढ़ना

इस वीडियो का व्याकरण

वक्ता जिन संरचनाओं का सबसे अधिक प्रयोग करता है, वीडियो के असली शब्दों के साथ:

संरचना	वीडियो में
Passive voice be + past participle — ज़ोर इस पर कि क्या होता है, न कि कौन करता है	is stored · is known · should be triggered
Relative clauses who / which + उपवाक्य — व्यक्ति या वस्तु के बारे में अतिरिक्त जानकारी	video which was · testing, which is · pods, which is

ध्यान देने योग्य उच्चारण

वक्ता 32 बार संक्षिप्त रूपों का प्रयोग करता है, जैसे we'll, you're, I'm। इन्हें वैसे ही छोटा बोलें जैसा आप सुनते हैं।

“sh” और “zh” की ध्वनियाँ: configuration /kənˌfɪɡ.əˈɹeɪ̯.ʃən/, visualize /ˈvɪʒuəˌlaɪz/
लंबे शब्द — बलाघात सही रखें: configuration /kənˌfɪɡ.əˈɹeɪ̯.ʃən/, manually /ˈmænj(u)əliː/, operator /ˈɑpəˌɹeɪtɚ/, continuous /kənˈtɪn.juː.əs/, automobile /ˈɔː.tə.məˌbil/

हिंदी भाषियों के लिए मुश्किल ध्वनियाँ:

/v/ और /w/ का फ़र्क़ — /v/ में ऊपर के दाँत निचले होंठ को छूते हैं, /w/ में होंठ गोल होते हैं: server /ˈsɝvɚ/, visualize /ˈvɪʒuəˌlaɪz/
/z/ — इसे “ज” (/dʒ/) न बनाएँ: confuse /kənˈfjuːz/, repository /ɹɪˈpɒz.ɪ.t(ə.)ɹɪ/, customize /ˈkʌs.tə.maɪ̯z/, visualize /ˈvɪʒuəˌlaɪz/
शब्द की शुरुआत में s + व्यंजन — पहले “इ” न जोड़ें: scrape /skɹeɪp/, snuff /snʌf/

इस वीडियो से अभ्यास कैसे करें

पहले बिना बोले पूरा वीडियो एक बार सुनें और जो शब्द नहीं आते उन्हें लिख लें।
0.75× गति से शुरू करें, एक-एक वाक्य की शैडोइंग करें, और सहज लगने पर सामान्य गति पर लौटें।
अपनी आवाज़ रिकॉर्ड करें और मूल से तुलना करें, ख़ासकर pipeline, pod, manifest जैसे शब्दों पर ध्यान दें।

शैडोइंग तकनीक क्या है?

शैडोइंग (Shadowing) एक विज्ञान-समर्थित भाषा सीखने की तकनीक है जो मूल रूप से पेशेवर दुभाषिया प्रशिक्षण के लिए विकसित की गई थी। विधि सरल लेकिन शक्तिशाली है: आप मूल अंग्रेज़ी ऑडियो सुनते हैं और तुरंत इसे ज़ोर से दोहराते हैं — जैसे वक्ता की छाया 1-2 सेकंड की देरी से। शोध से पता चलता है कि यह उच्चारण सटीकता, स्वर, लय, जुड़ी हुई ध्वनियाँ, सुनने की समझ और बोलने की प्रवाहशीलता में काफ़ी सुधार करता है।

शैडोइंग तकनीक: पूरी चरण-दर-चरण गाइड पढ़ें →

शैडोइंग अभ्यास: How to design a Deployment Pipeline (GitOps) - वीडियो के साथ अंग्रेजी बोलना सीखें

अभ्यास मोड चुनें

ऐप डाउनलोड करें

If you’re an aspiring product designer, watch this (roadmap included)

Did Anthropic Kill Git?

What is Docker? Docker container concept explained || Docker Tutorial 1

Design a File Upload Service Like a Senior Engineer

STOP Running Code On Your Computer

Database Sharding! Designing Data-Intensive Applications chapter 6

Prompt Engineering - Guidelines

SDLC Vs STLC: Software Development Life Cycle and Software Testing Life Cycle

Best NextJS Folder Structures | Beginner - Intermediate - Advanced

How I Learned Procedural Generation

Inside a Biotech Company: Roles, Teams & Where You Could Fit In | EP 14

GitHub Copilot now controls your command line...