跟讀練習: What is Docker? Docker container concept explained || Docker Tutorial 1 - 通過影片學習英語口語

選擇練習模式

每種模式都會開啟全屏練習室。

102 句

如果句子過短或過長，請點選 Edit 進行調整。

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.

下載應用

流利口語所需的一切

AI 發音評分逐句打分

音標練習掌握每個音

詞彙學習建立你的詞庫

詞彙遊戲邊玩邊學

掃碼

Download on theApp Store Get it onGoogle Play

同頻道

Redis Crash Course - the What, Why and How to use Redis as your primary database

Daily ConversationUniversity StudentsWorking Adults

FOR YOU

為什麼與這個影片練習口語？

通過這個影片，您可以深入瞭解Docker容器的概念，這對學習英語特別有幫助。在聽和跟讀講解的過程中，您不僅可以提高您的英語口語能力，還能瞭解技術領域的相關術語和應用。通過結合實際案例，您可以在雅思口語練習中自信地談論與科技相關的話題，增強您的表達能力。通過觀看這個影片並使用英語影子跟讀方法，您將能夠提高理解力和發音，同時掌握實際應用中的語言表達。

語法與表達在語境中的應用

被動語態的使用： 在提到“容器被選擇用於打包應用程式”時，您可以學習被動語態的用法，這在技術和其他領域中很常見。
條件句的應用： 主持人在討論使用容器的情況下常提到“如果您想學習Kubernetes”，這是一種典型的條件句結構，可以幫助您進行假設性討論。
名詞短語構建： “盛裝所有依賴關係的包及所有必要的配置”展示瞭如何使用名詞短語詳細描述事物，這對提高描述的準確性非常重要。
動詞時態的變化： 常見於影片中的動詞使用，例如“打包”和“分享”。瞭解不同時態的轉換對您口語的提高有很大幫助。

常見發音陷阱

在影片中，有一些詞彙可能會引起發音上的困難。例如，“container”這個詞在不同的地區可能會有不同的口音，而“repository”這個詞由於音節較多，初學者可能會發音不清。您可以在觀看影片時，反覆練習這些詞彙的發音並進行英語影子跟讀，這將使您在日常交流中更加自信。在影片講解中，努力模仿主持人的語調和節奏將有助於您更好地掌握這些發音。通過這樣的方法，您能在與他人討論技術問題時，展示良好的英語交流能力。

影片中的語法

說話人最常用的結構，並附上影片中的原話：

結構	影片中的用法
定語從句 who / which + 從句 — 補充說明人或事物	implementations, which is · repository, which is · hub which is
被動語態 be + 過去分詞 — 強調發生了什麼，而不是誰做的	can be easily shared · is actually simplified

什麼是跟讀法？

跟讀法 (Shadowing) 是一種有科學依據的語言學習技巧，最初開發用於專業口譯員的培訓，並由多語言者Alexander Arguelles博士普及。這個方法簡單而強大：您在聽英語母語原聲的同時立即大聲重複——就像是一個延遲1-2秒緊跟說話者的影子。與被動聽力或語法練習不同，跟讀法強迫您的大腦和口腔肌肉同時處理並模模擬實的講話模式。研究表明它能顯著提高發音準確性，語調，節奏，連讀，聽力理解和口語流利度——使其成為雅思口語備考和真實英語交流最有效的方法之一。

影子跟讀法: 閱讀完整分步指南 →

跟讀練習: What is Docker? Docker container concept explained || Docker Tutorial 1 - 通過影片學習英語口語

選擇練習模式

下載應用

同頻道

Redis Crash Course - the What, Why and How to use Redis as your primary database

Every Networking Concept Explained In 20 Minutes

Microservices explained - the What, Why and How?

NGINX Explained - What is Nginx

CI/CD Explained in 5 Minutes

Kafka Tutorial for Beginners | Everything you need to get started

If I would start DevOps from 0 - How would I start and what would I learn

推薦影片

100+ Docker Concepts you Need to Know

Free CCNA | VLANs (Part 2) | Day 17 | CCNA 200-301 Complete Course

Running AI Agents in Secure Sandboxes with E2B & Docker MCP | Docker’s AI Guide to the Galaxy

Network Ports Explained

How I deploy serverless containers for free

The easy way to keep your repos tidy.

what is a database index?

Configure storage accounts | AZ-104 | Episode 16

What is an API?

What is a PLC and how does it work?

How to design a Deployment Pipeline (GitOps)

為什麼與這個影片練習口語？

語法與表達在語境中的應用

常見發音陷阱

影片中的語法

什麼是跟讀法？