跟读练习: What is Docker? Docker container concept explained || Docker Tutorial 1 - 通过视频学习英语口语

Hello and welcome to Kubernetes tutorial.

Kubernetes is an open source technology developed by Google in order to make orchestrating containerized applications easier.

That's why an official definition of Kubernetes is actually a container orchestration tool.

So as you can see, containers are the base part of Kubernetes technology.

So if you want to learn Kubernetes, you first have to understand what a container is and why we use them.

So in this video series, we'll talk about container concepts and one of its most popular implementations, which is Docker.

So we'll talk about what a container is and what problems it solves.

We will also look at a container repository, which is basically a storage for containers.

We'll see how a container can actually make the development process much easier

and more efficient and also how they solve some of the problems that we have in the deployment process of applications.

So let's dive right into it.

What a container is a container is a way to package applications with everything they need inside of that package,

including the dependencies and all the configuration necessary.

And that package is portable, just like any other artifact is,

and that package can be easily shared and moved around between a development team or development and operations team.

And that portability of containers plus everything packaged in one isolated environment gives it some of the advantages

that makes development and deployment process more efficient.

And we'll see some of the examples of how that works in later slides.

So as I mentioned, containers are portable, so there must be some kind of a storage for those containers so that you can share them and move them around.

So containers leave in a container repository.

This is a specific this is a special type of storage for containers.

Many companies have their own private repositories where they host or the way they store all the containers.

And this will look something like this where you you can push all of the containers that you have.

But there is also a public repository for Docker containers where you can browse

and probably find any application container that you want.

So let's head over to the browser and see how that looks like.

So if I here search for a doctor hub which is the name of the public repository for Docker, I will see this official website.

So here if you scroll down,

you see that there are more than 100,000 container images of different applications hosted or stored in this repository.

So here you see just some of the examples and for every application there is this official Docker container container image.

But if you are looking for something else, you can search it here.

And I see there is an official image for Jenkins.

There's also a lot of non official images or container images that developers or or even from Jenkins itself.

They actually store it here.

So public repository is where you usually get started when you're using

or when you're starting to use the containers where you can find any application image.

So now let's see how containers improve the development process by specific examples.

How did we develop applications before the containers?

Usually when you have a team of developers working on some application,

you would have to install most of the services on your operating system directly.

Right.

For example, you are developing, developing some JavaScript application and you need a Postgres QL and you need Redis for messaging.

And every developer in the team would then have to go and install the binaries of those services and.

Configure them and run them on their local development environment and.

depending on which operating system they using, the installation process will look actually different.

Also, another thing with installing services like this is that you have multiple steps of installation.

So you have a couple of commands that you have to execute

and the chances of something going wrong and error happening is actually pretty high because

because of the number of steps required to install each service. And this.

And this approach

or this process of setting up a new environment can actually be pretty tedious depending on how complex your application is.

For example, if you have 10 services that your application is using, then you would have to do that 10 times on in each operating system environment.

So now let's see how containers solve some of these problems with containers.

You actually do not have to install any of the services directly on your operating system

because the container is its own isolated operating system layer with Linux base image as we saw in the previous slides,

you have everything packaged in one isolated environment.

So you have the Postgres QL with a specific version packaged with the configuration and the start script inside of one container.

So as a developer, you don't have to go and look for the binaries to download on your machine,

but rather you just go ahead and check out the container repository to find

that specific container and download on your local machine.

And the download step is just one Docker command which fetches the container and starts it at the same time.

And regardless of which operating system you're on, the command, the Docker command for starting the container will not be different.

It will be exactly the same.

So we have ten applications that your that your JavaScript application uses and depends on.

You would just have to run ten Docker commands for each container and that will be it.

Which makes the setting up your local development environment actually much easier and much more efficient than the previous version.

Also, as we saw in the demonstration before,

you can actually have different versions of the same application running on your local environment without having any conflict.

So now let's see how containers can improve the deployment process before the containers.

A traditional deployment process will look like this developer development team

will produce artifacts together with set of instructions of how to actually install and configure those artifacts on the server.

So you would have a jar file or something similar for your application.

And in addition, you would have some kind of a database service

or some other service also with a set of instructions of how to configure and set it up on the server.

So development team would give those artifacts over to the operations team

and the operation team will handle setting up the environment to deploy those applications.

Now the problem with this kind of approach is that, first of all, you need to configure everything and install everything directly on the operating system,

which we saw in the previous example

that could actually lead to conflicts with dependency versions and the services running on the same host.

Another problem that could arise from this kind of process is when there is misunderstanding between the development team and operations.

Because everything is in a textual guide,

there could be cases where developers miss to mention some important point about configuration.

And when that fails, the operations team have to go back to the developers and ask for more details.

And this could lead to some back and forth communication until the application is successfully deployed on the server.

With containers, this process is actually simplified.

Because now you have the developers

and operations working in one team to package the whole configuration dependencies inside the application just as we saw previously.

And since it's already encapsulated in one environment, you don't have to configure any of this directly on the server.

So the only thing you need to do is

run a Docker command that pulls that container that you stored somewhere in the repository and then runs it.

And that makes the process.

This is, of course, a simplified simplified version, but then makes exactly the problem that we saw on the previous slide much more easier.

No environmental configuration needed on the server.

The only thing, of course, you need to do is you have to prepare,

you have to install and set up the Docker runtime on the server before you will be able to run containers there.

But that's just one time effort.

And later in this tutorial, we will also see how Kubernetes actually offers even more abstraction

of the deployment environment to make the deploying of super complex

applications much much easier than it was possible with the traditional approach.

100

have any questions if something wasn't clear in the video please post them in the comment section below

101

and I will try to answer them.

102

So thank you and see you in the next video.

什么是跟读法？

跟读法 (Shadowing) 是一种有科学依据的语言学习技巧，最初开发用于专业口译员的培训，并由多语言者Alexander Arguelles博士普及。这个方法简单而强大：您在听英语母语原声的同时立即大声重复——就像是一个延迟1-2秒紧跟说话者的影子。与被动听力或语法练习不同，跟读法强迫您的大脑和口腔肌肉同时处理并模仿真实的讲话模式。研究表明它能显着提高发音准确性，语调，节奏，连读，听力理解和口语流利度——使其成为雅思口语备考和真实英语交流最有效的方法之一。

跟读练习: What is Docker? Docker container concept explained || Docker Tutorial 1 - 通过视频学习英语口语

为什么与这个视频练习口语？

语法与表达在语境中的应用

常见发音陷阱

什么是跟读法？