【Docker入門】初心者向け！Dockerの基本を学んでコンテナ型の仮想環境を作ろう！

Summary

このビデオは、Dockerの基本的な操作方法と利点について説明しています。Dockerの概念から始まり、コンテナ、イメージの作成方法、Docker Hubからイメージのダウンロード、Dockerfileによるカスタムイメージの構築、実例を用いてコンテナの実行方法などを解説しています。要約すると、Dockerを使うことで開発環境の再現性が高まるなどの利点があり、コンテナの作成から実行、停止、削除といった基本的な操作コマンドをマスターすることで、様々な開発環境を手軽に利用できるようになる、という内容です。

Takeaways

• 😀 Dockerとは、コンテナ型の仮想環境を作成・配布・実行するもの
• 📦 Dockerの利点は、同じ環境を構築できること、バージョン管理・配布がしやすいこと
• ☁️ Dockerでクラウド上のサーバーも自動構築できる
• 🗄 Docker Hubには必要なコンテナイメージがたくさん公開されている
• 🐳 Dockerコマンドでコンテナを操作できる(起動、中止、削除など)
• 🔌 ポートフォワーディングを使ってコンテナと通信できる
• 📄 Dockerfileを使えばカスタムイメージを構築可能
• 🗃 copyやaddコマンドでファイルをコンテナにコピーできる
• 📝 docker buildでDockerfileからイメージ作成
• ✅ ENTRYPOINTでコンテナ実行時にスクリプト実行可能

Q & A

Dockerとはどのようなものですか?

Dockerはコンテナ型の仮想環境を作成し、配布・実装するためのものです。ホストOSのカーネルを利用することで、高速に仮想環境を起動できるのが特徴です。

コンテナ型と仮想マシン型の違いは何ですか?

コンテナ型はホストOSのカーネルを利用していますが、仮想マシン型はゲストOS上に仮想ソフトを載せることで仮想環境を作成します。コンテナ型のほうが軽量で高速に起動できます。

Dockerの利点は何ですか?

Dockerの利点は、1完全同一の環境を構築できること、2環境設定をコード化しているためバージョン管理や配布がしやすいこと、3クラウド上でのサーバ構築を自動化できること、4公開されたコンテナイメージを利用できることです。

Dockerイメージとは何ですか?

Dockerイメージはコンテナを構築するのに必要なコマンドやメタデータが含まれたパッケージです。Dockerイメージからコンテナを作成して利用します。

Dockerコンテナの利点は何ですか?

Dockerコンテナを利用することで、簡単に様々な仮想環境をPC上に構築できます。データベースサーバやWebサーバなど、目的に合わせたコンテナを活用できます。

Dockerfileとは何ですか?

DockerfileはカスタマイズしたDockerイメージを生成するためのテキストファイルです。fromやrun、copyなどのコマンドを記述して独自のDockerイメージをビルドできます。

なぜDockerが便利なのですか?

Dockerを使うことで、開発環境の再現性が高まります。コンテナイメージを共有することで、全く同じ環境を他の人と構築できるからです。

Dockerの基本的な操作コマンドを教えてください。

代表的なコマンドとしては、docker pull、docker run、docker ps、docker exec、docker stopなどがあります。イメージの取得からコンテナの操作、停止までを行えます。

Docker Composeとは何ですか?

Docker Composeは、複数のコンテナを定義してアプリケーションを管理できるDockerの機能です。yamlファイルでコンテナ構成を記述し、一括してコンテナを起動できます。

Dockerを使うメリットは何ですか?

開発環境の共有と再現性の向上、デプロイとスケーリングの容易化、リソース利用効率の最適化など、様々なメリットがあります。コンテナ型仮想化を活用することで、開発から運用まで効率的にできます。

Outlines

00:00

😀Dockerの概要とメリットを解説

Dockerはコンテナ型の仮想環境を作成して配布・実行するもの。コンテナ型はホストOSのカーネルを流用して軽量な仮想環境を実現。メリットは、環境の完全な再現性、バージョン管理・配布の容易さ、クラウド上でのサーバ構築の自動化など。

05:03

😊Dockerの基本操作を実践

Docker Desktopをインストールし、Docker HubからMySQLのコンテナイメージをPullしてコンテナを作成。コンテナに入りMySQLに接続、テーブル作成とデータ入力を行う。外部からの接続もしてみる。これらの一連の操作を通じて、コンテナの基本的な取り扱い方を理解。

10:09

🤔Docker Hubでコンテナイメージを検索

Docker Hubにアクセスし、利用目的に合ったコンテナイメージを検索。今回はMySQLコンテナを作成したいので、MySQLのイメージをPullする。バージョンも指定できる。ほぼ必要なものは揃っている。

15:09

🚀コンテナの開始・停止・削除

`docker run`でコンテナを作成して起動。`docker ps`で実行中のコンテナを確認。`docker stop`でコンテナを停止。`docker rm`でコンテナ自体を削除。`docker rmi`でPullしたイメージを削除。操作に習熟すれば、手軽に必要なコンテナを準備できる。

20:10

🐍PythonコンテナからDBデータを取得

コンテナとホストPC間のポートフォワーディングを設定し、PythonからローカルPCの指定ポート経由でコンテナ内MySQLに接続。コンテナ側のDBデータを正しく取得できたことを確認。入出力を容易に分離。

25:14

👩‍💻Dockerfileでカスタムイメージ作成

Dockerfileに基となるイメージの指定、パッケージのインストール、ファイルのコピーなどの命令を記述。これによりカスタマイズされた新しいコンテナイメージをビルド可能。`docker build`コマンドでイメージのビルドを実行。

30:15

🎉カスタムイメージからコンテナを作成

自分でビルドしたイメージからコンテナを生成。Dockerfileの通り環境が構築されていることを確認。ENTRYPOINTを使用して、コンテナ起動時にPythonスクリプトを実行する例も示す。様々な用途に応じたコンテナが作れる。

35:18

🙇‍♀️Dockerの基本操作をまとめ

Docker DesktopによりローカルPC上にコンテナを作成可能。コンテナイメージを基にしてコンテナを生成し、実行・操作。使い終わったコンテナは削除。これを理解すれば、開発時の様々な用途にDockerを活用できる。

Keywords

💡Docker

Dockerは、コンテナ型の仮想環境を作成および配布・実行するためのものです。ホストOSのカーネルを利用することで、軽量で高速に仮想環境を起動できます。ビデオでは、Dockerの概要と基本操作について説明しています。

💡コンテナ

コンテナとは、Dockerなどを利用して作成される軽量な仮想環境のことです。ビデオでは、コンテナのイメージをpullしてコンテナを作成し、中でアプリケーションを実行する方法を説明しています。

💡イメージ

コンテナを作成するためのもとになるパッケージです。Docker Hubなどから必要なイメージをpullしてきて、Docker runコマンドでコンテナを作成します。

💡Dockerファイル

カスタマイズしたコンテナイメージを作成するための設定ファイルです。OSのインストールやミドルウェアの設定などを記述して、Docker buildコマンドでイメージをビルドします。

💡Docker Hub

さまざまなコンテナイメージが公開されているレジストリプラットフォームです。ビデオではMySQLやUbuntuのイメージをpullする例を紹介しています。

💡pull

Docker Hubなどのレジストリからコンテナイメージをダウンロードすることです。ローカルに同じイメージがなければ、Docker run時に自動的にpullされます。

💡ポートフォワーディング

コンテナとホストOS間で特定のポートを紐づける機能です。コンテナ側のアプリケーションにホストOSから接続できるようになります。

💡コンテナ管理

Dockerコマンドを使ってコンテナの起動、停止、削除などライフサイクルを管理することです。psやexecコマンドを使ってコンテナの状態確認や内部での操作ができます。

💡インフラストラクチャ・アズ・コード

インフラの設定やプロビジョニングをコードで実現し、バージョン管理などを容易にするDevOpsの考え方です。Dockerfileがその理念を体現していると言えます。

💡Kubernetes

コンテナをクラスタリングして管理するためのオーケストレーションプラットフォームです。Dockerと連携することで、大規模なコンテナインフラを効率的に運用できます。

Highlights

Dockerはコンテナ型の仮想環境を作成および配布・実行するものです。

コンテナ型はホストOSのカーネルを流用して仮想環境を作成するタイプです。

Dockerの第一のメリットは、どのコンピュータでも完全に同じ環境を作成できることです。

Dockerの第二のメリットは、OSの設定やミドルウェアのインストール、環境設定がコード化されているのでバージョン管理や配布がしやすいことです。

Dockerの第三のメリットは、クラウド上でもサーバーを自動構築できることです。

Docker Hubには必要なものがほぼ揃っているので、公開されたコンテナイメージを用いることができます。

ソフトウェアエンジニアはコンテナイメージを利用することが多いでしょう。

インフラエンジニアはDockerファイルを自分で記述して環境構築をすることが多いでしょう。

コンテナイメージからコンテナを作成し、起動・操作・停止・削除する一連の流れが大切です。

Dockerファイルを使うとカスタマイズしたコンテナイメージを作成できます。

Dockerファイルにはコンテナイメージ作成時に実行するコマンドが含まれます。

DockerビルドコマンドでDockerファイルからイメージを作成します。

コンテナイメージからDocker実行時にプロセスを実行するにはENTRYPOINTを使います。

Dockerにはまだまだできることがたくさんありますが、基本的な操作が分かったと思います。

次回の動画でまたお会いしましょう。

Transcripts

Hello, I'm Sabu from Python VTuber.

This time, I would like to explain the basics of Docker that can make a fast-paced environment.

I've heard of Docker, but I've never used it myself.

I'm explaining it to the software engineers who are wondering when to use it, so I'd be happy if you could watch it until the end.

This channel is sending information about Python and software development, so please subscribe to the channel if you like.

There are also videos and live videos that can only be seen for membership, so please consider becoming a member of the membership if you like.

First of all, what is Docker?

Docker is a thing to create and distribute and implement a container-type virtual environment.

Just listening to this makes you think,

Hmm? What is a container-type virtual environment?

The virtual environment here is a thing that reproduces a virtual computer so that there are other computers in the computer.

For example, you can create a ubuntu server in a Windows PC or create a cent OS server in a Mac.

At this time, we will use the OS that is originally used for a physical computer as a guest OS, and the OS that is used in the virtual environment as a host OS.

So what is a container type?

A container type is a container type that uses a kernel that moves the host OS to create a virtual environment so that there is a guest OS.

The image is like this.

There will be a lot of words like container in the future, but if you say container, please think of the virtual environment that is on top of this Docker.

There are also virtual environments that are not container-type, such as virtual machines that create virtual environments by putting a guest OS on top of a virtual software.

The Docker I'm going to introduce this time is a container type,

but the good thing about this container type is that it uses a host OS kernel, so it has the advantage of being able to stop the virtual environment at high speed with a light weight.

It may be a little confusing, but the detailed understanding of this area does not have any particular problems even if you do not know it on the operation of Docker, so let's proceed without knowing it well.

So what is good about Docker?

First of all, you can create a completely same environment on any computer.

As I said earlier, the virtual environment can create a virtual environment of your favorite OS, whether it is a host OS or whatever, so for example, even if the members of the same development team are

developing on Windows and Mac, even if they are developing on Mac, they can use Docker to prepare a completely same environment for both.

There are problems with the environment that makes it difficult for Mac to work with this code, but Windows to work with this code.

In such a case, if you create a Docker virtual environment that is exactly the same as OS, middleware, and environment settings, and check the code operation in them,

A3 will work, but B3 will not work.

This is the first benefit.

The second advantage of Docker is that it is easy to use and manage versions and distribute because the OS settings, middleware installs, and environment settings are coded in Docker.

To build a virtual environment with Docker, you need a Docker file, but this Docker file is just a text file, and the contents are all recorded as code such as the installation of OS, middleware, and environment settings.

Therefore, if you look at the file, you can see what kind of environment you can build, and if you want to change some of the environment you are creating, you can edit only a part of the file.

It's just a text file, so you can manage the version with Git.

In addition, it is a lightweight text file, so it is easy to distribute to other people.

For example, when a new member enters the development team and builds the development environment, you can install Python with your own hands one by one while reading the procedure written in Japanese, and even if you don't set this to the environment variable by inserting the database, you can just enter the Docker file and execute the command to reproduce the same environment as everyone.

By the way, code-coding infrastructure management operations is called infrastructure as code, and it has become a very important idea recently.

The third advantage of Docker is that you can automatically build servers in the cloud.

So far, I've been talking about using Docker on my computer, but you can also use Docker to build servers in the cloud such as AWS and GCP.

In particular, it is even more convenient to use a container management system called Kubernetes, not just Docker.

When building servers in the cloud, you can press and hold the button from the web console, select OS, and decide the disk capacity and make it manually, but by using the container image created by Docker file, you can automatically build servers, so you can create clusters by building multiple instances of the same container image.

In this case, you can automatically and efficiently work.

This container image is a package that can be implemented in a Docker environment that includes commands and metadata that are necessary to build containers that can be made based on Docker files.

I think it's a little hard to understand, but I think I can understand it somehow because it will be implemented in various ways later.

And the fourth advantage is that anyone can use the container image that is publicly released on the Docker Hub platform.

I've been talking about the need for Docker files to create a virtual environment with so far.

But even if you don't write that file yourself from scratch, you can easily use the environment and tools you want to use by using the image that is publicly released on the Docker Hub platform.

For example, if you want to use an environment that contains MySQL, you can use it by looking for that kind of image.

I think that Docker Hub has almost everything you need, such as NGINX, Node.js, and Redis.

How about it? Did you somehow understand the benefits of using Docker?

Next, I would like to talk about the difference between a software engineer and an infrastructure engineer in handling Docker to make the distribution of this video and the range clear.

That's because Docker is not a software engineer who writes Docker files.

I think there are more cases where you use the image that is publicly released on the Docker Hub that I explained earlier, or use the Docker file that the infrastructure engineer prepared.

For example, it is an image that you can use to develop an app by starting a container for your database on your computer.

So, I think it would be enough if you knew the basic operation of starting a container, getting the image of the container that I will explain in the video after this, and connecting and stopping.

On the other hand, for infrastructure engineers, they often write Docker files to build an environment that is designed to be built, and build servers on the cloud.

So, I often write the Docker file myself.

This video is a Docker entry video for software engineers, so I will not touch on how to make Docker files well like infrastructure engineers.

I will explain how to make a basic writing method of Docker files and how to create a container image from Docker files, but I will not touch on detailed knowledge or techniques that infrastructure engineers need, so please note that.

So, I would like to actually use Docker to create an environment.

First, you need to install Docker Desktop.

There is an installer on the official site of Docker, so download the installer that fits each environment.

I will post the URL of this page in the summary column.

Sapoo is now using a Windows PC, so select Windows on this site, download the installer, and when the installation is complete, double-click the installer.

This installer will start, so proceed with the installation.

Click OK.

When the installation is successful, this screen will appear.

Here you need to restart the computer, so press this button to restart after completing the installer.

When the restart is complete, a screen with a contract change will appear like this, so read the content, check it, and press the accept button.

Then, I think this screen will be displayed, but the Docker desktop itself will be closed and it will be fine.

Basically, the operation of Docker is implemented from the command, so if it is Windows, it is PowerShell, and if it is Mac, it is Terminal.

Also, if the user account is different from the manager account in the case of Windows, you need to add the user to the Docker Users group.

The Mac installation is basically the same, and when the installer is downloaded, double-click Docker.dmd to open the installer, and drag the Docker icon to the application folder.

Then, I think that a contract will be displayed, so check it, and when you select agree, the Docker desktop will start.

First, check if the Docker command can be used properly.

If the Docker version is released, the Docker will be installed properly.

Next, I will search for the container image that is generally released from the Docker Hub.

When you open the official site of Docker Hub, you will see this page.

I will put the URL of this page in the summary column.

As I explained earlier, the container image is a package that contains commands and metadata necessary to build a container.

Therefore, you need to use the container image that meets the purpose, but this time I would like to implement a case where the database is stored as a Docker container.

So, search for the container image with MySQL.

If you enter MySQL in the search var on the top left, you will see some images that are caught in the search like this.

It says Docker official image at the top, so it looks like the image that MySQL is officially releasing.

Open this.

Then, it contains various descriptions, including the use of this image and the sample command.

First of all, I would like to pull this image.

There is a pull command on the upper right, so copy this and run this command on the command line tool.

When you run this, it will take a little time, but when the pull is complete, you can download the Docker container image on the Docker hub to your local PC.

By the way, the Docker pull command can be run in any directory.

There is no such thing as folders or files being created under the current directory like the git command.

Also, in fact, in the Docker run command that will be implemented after this, if there is no container image locally, it will search for images from the Docker hub.

However, this time I pulled it so that it is easy to imagine the container image.

When the pull is complete, run the Docker images command.

Now, the information of the container image in your PC will be displayed.

Here you can see that there is an image of MySQL that you have just pulled.

Then, start this MySQL container immediately.

In many cases, the container's starting method is written on the Docker hub page.

To create and start a container, use the command Docker run, but here the Docker run command is written.

Copy this once and paste it on the command line tool and change it a little.

First of all, this is the option of hyphen hyphen name, but this is a specification of the container's color.

In the sample, it says some-mysql, but I will give you a name that is easy to understand.

This time, I will name it supu-mysql.

The hyphen e option is an environmental variable setting.

So in this case, set a password for the MySQL root user of MySQL, which is called MySQL root password, to an environmental variable.

For example, set a password like K12IJ75H.

By the way, this is not an environmental variable of a local PC, but an environmental variable of a container.

The next hyphen d option is an option to run in detached mode, and if you attach this, the container will be executed in the background.

And the last part that is written as MySQL colon tag is the setting of the image to be used, but the tag after the colon is written.

Set the version of the necessary MySQL.

For the version, open the tab called Tags at the Docker Hub, and you can search for the version.

If you don't do anything, it will be the latest, so I'm going to make it the latest this time, so I'll omit the tag part.

And here I'm going to add a little more options.

If you use the hyphen p option, you can transfer the communication to a specific port with a local PC to a specific port on the container side.

This is called port forwarding.

If you type the port number of the local PC behind the hyphen p, the port forwarding will be possible if you type the port number of the colon container side.

The port of MySQL is usually 3306, so the right side is 3306, and the local side is 13306.

When this command is executed, the container ID is displayed and the container is created.

To actually check what kind of container is running now, execute the command Docker ps.

When this is executed, the container information list that is running at this moment will be displayed.

It's a little hard to see because line breaks, but here you can see that the supu-mysql container has been activated.

By the way, the container image is only to create containers, so you can create several containers from the same image.

This time, I won't handle multiple cases, so I'd like to proceed with one container I made now.

Then I would like to enter the container and check if MySQL can be operated.

To enter the container, you can use the command Docker exec.

If you type the hyphen id option, you can operate the command operation on the container side from this console that you are using now.

And if you specify the name of the container, supu-mysql, and write bash, you will use bash inside the container.

If you execute this, you can enter the container like this.

Then I will try to see if MySQL can be operated.

Login to MySQL with mysql -u root -p root user.

Since you can ask for a password, enter the root user password set as an environmental variable in Docker Run and press enter.

You can log in to MySQL like this.

Now you can see that there is a MySQL properly in the container.

I'd like to make a table and put in one record data.

This video is not a MySQL video, so I will omit the detailed explanation of the command to be implemented from now on.

If you don't know the operation of MySQL, I would like you to see it as if you are adding a record to the database.

First, create a database with create database supu_db.

Set the database to use with use supu_db.

Create a user table with create table users.

Insert into and enter only one record.

Exit to exit MySQL.

Now I have entered only one record data into the MySQL table in the container.

I want to exit from the container in this state, so I can exit from the container by pressing the control button and pressing Q.

Now I'm back on the local PC side, but if you execute the command docker ps, you can see that the supu-mysql container is still running.

In this state, I would like to stop this container from the outside.

Stop the container with docker stop supu-mysql.

If you execute this and execute docker ps again, the container is no longer displayed.

But in this state, if you execute this by setting the option docker ps -a, the stopped container will also be displayed.

Here is the supu-mysql.

And to start the container that was stopped once, use the docker start command instead of the docker run command.

It's a little confusing, but the docker run command is a command that creates and starts the container from the image of the container,

but it will be the docker start command to start the container that has been built and stopped once.

So in the case of docker start, you do not need to specify the number of environments or versions.

Simply type the name of the docker start container and type the command supu-mysql, and you will be able to start the same container as before.

If you execute this, the name will be output and if you execute docker ps again, you will see that it is certainly running.

And since I was port forwarding when I built the container, I would like to acquire the data of MySQL on the container side from the local PC.

As I said earlier, this video is not a MySQL commentary video, so I will omit the detailed explanation of the Python code,

but I will put a library that connects to MySQL from Python called pip install mysql-connector-python.

And with this code, use this password as a root user and access the local host, that is, the 13306 port of this computer.

Since I was port forwarding earlier, the communication to the local PC 13306 is transferred to the port of the container side 3306,

so it means that it connects to the MySQL on the container side.

And if you move this program, which is to take the data of the users table that I made earlier and display it,

to the local PC side, you can see that the data is taken properly like this.

I will stop the container with docker stop because I will no longer use this container.

If you want to delete it, use the docker rm command.

Docker rm supu-mysql.

If you execute this, the container itself that you used so far will be deleted.

Also, if you delete the container image that you have pulled,

you can see that the container image that you have pulled is deleted by using the docker rmi.

If you delete the container image that you have pulled,

you can delete the container image by specifying the image name and version with docker rmi.

If you check if there is no image left in the docker images, you can see that there is no image left at all.

How about it?

Did you get an idea of how to think and operate the container?

Let's sort out what we've done so far around containers.

First, if you put a docker in a local PC, you can create a virtual environment container on top of it.

Containers are created from the container image,

but this container image is a container image that can be built with containers that contain MySQL,

and a container image that can be built with containers that contain NGINX.

Since various images are generally released in the Docker Hub,

you can download them from there, get the image, create and start the container.

You can also enter the docker exec into the container and directly operate it,

or you can also connect to the container app through the port from the local PC by port forwarding.

I explained a lot, including the actual performance,

but for the first time, my head may be confused,

but I think that while operating several times, I can understand it as,

oh, that's what it is, and when I remember the operation command,

I think it's convenient to build the necessary container on my PC and use various things.

Next, I would like to explain how to create an image from a Docker file and build a container.

Until earlier, the container image was used as it was,

but you can also create a customized container image based on that image,

instead of using the container image as it is.

The Docker file is the one that can generate that customized container image.

The Docker file is just a text, but first create a file called Docker file.

Next, specify the image of the container that will be the base.

This is to specify the image on the Docker Hub,

but I think that it is often used to make a container image of a specific OS that does not contain anything.

For example, if you want to create a container image of 20.4 of Ubuntu,

search for Ubuntu in the Docker Hub,

and click on Ubuntu with the Docker official image,

and open the tab called Tags in this,

you will see that there are some versions, so if you look at the bottom,

you can see that there is 20.4.

So, copy the command in the pull command and write from ubuntu colon 20.04 in the Docker file.

This will be able to base the container image of Ubuntu 20.04.

There are several commands for Docker files like from,

but we will customize the container image using these commands.

Here are some of the representative commands.

First, there is a command called run that executes the shell command

when creating a container image.

For example, if you leave this Docker file, it's an empty Ubuntu,

and you want to install various packages with run apt install here.

In that case, run is used.

First, to update the apt itself,

write run apt update and the shell command behind run.

This time, I want to install Python 3.9, so I will use the run command in the same way,

and write run apt install -y python 3.9.

Originally, run apt install uses and to write the shell command in one liner,

and it is more desirable to write a command to delete the cache at the end,

but in this video, we are counting each line based on the ease of understanding of the command.

In addition, I want to install the pip itself,

so run apt install -y python3-pip and install pip.

Next, I would like to install the library at once using the requirement.txt

to install the Python library with pip.

Even if there is a requirement.txt on the local side,

you cannot install this file with pip unless this file is actually used on the container side.

So, to copy the file on the local pc to the container side,

use the command copy.

Since it is a copy of the local file,

there is a requirement.txt in the same folder with this Docker file,

so write copy requirement.txt and half space dot.

By the way, numpy and pandas are specified in this requirement.txt.

In addition, I will install pip using that requirement.txt,

run python 3.9-m pip install-r requirement.txt

You can also change the user by using the user command.

Since the user name is written as user half space,

for example, write user half space root.

You can also set the environmental variable by using the command ENV.

Write nb.halfspace.environmental variable.

For example, if you want to set the value of site domain to vtuber.supu.com,

write ENV SITE_DOMAIN=vtuber.supu.com.

You can also change the work directory,

and if you specify the work directory and directory path,

the directory will be the work directory.

You can specify the corresponding path and absolute path.

For example, write the work directory, absolute path var, etc.

Also, it is very similar to copy,

but there is an instruction that you can add files to the container side from the local pc.

Add, add the original file path, half space, add the file path.

This is quite similar to the copy I explained earlier.

What is different is that the copy can not be copied to the container side

by the URL specification of the file that is released on the net, for example.

On the other hand, you can add a remote-like file to the container side.

Also, when copying the compressed file to the container side,

it will be copied as it is in the copy command,

but it will be automatically returned by using add.

So basically, I think it's good to use copy and add only if necessary.

I would like to add the previous Ayame's public data to the container side.

Add, if you write the url. of Ayame's data,

an irisdata file will be added to the container side.

There is also an ENTRYPOINT.

This is a shell command that you want to move when you are running the container.

After the ENTRYPOINT, open the half space and write it like a Python list,

and then write the execution file, parameter 1, parameter 2.

The difference from run is that run is executed when creating a container image,

and the ENTRYPOINT is moved when the container execution of the Docker run is executed.

This ENTRYPOINT is used when creating a container to execute a certain process

such as handling the container as a file that can be executed using the ENTRYPOINT.

For example, if you want to create a container only to execute a certain Python script,

prepare a Python script, copy the Python script file to the container side,

and write python3.9 script.py at the ENTRYPOINT, and enter the command to move this script.

If you run Docker run with the image you made like this, the script.py will move at that time.

And when this script.py is finished, the container will also be stopped.

However, I want to check the results of various environments in the container,

so I will delete the command for this ENTRYPOINT and check the operation later.

There are several other commands, and the reference is on the official website for details,

so I hope you can refer to it.

I will put the reference URL in the summary column of the video.

I'm going to create a container image with this Docker file I just wrote.

To create a container image from a Docker file, use the Docker build command.

Now I'm in a place where the Docker file is placed.

Set the container image tag with a hyphen t behind the Docker build.

It's the same as the MySQL colon latest and the Web2 colon 20.04 that I've mentioned so far.

For example, if it's this time, add a tag like supu-python:1.0.

You can also specify the path of the Docker file with hyphen f.

This time, the place I'm in is the place where the Docker file is, so you can write it as a Docker file,

but the default of hyphen f is a Docker file, so I will delete this option this time.

Finally, specify the build context.

All files of the directory specified in the build context will be read when creating an image.

Of course, it's just read, so if you don't copy or add, the file will not be included in the image.

However, it will take time to read each one, so I will not put unnecessary things in the build context.

It's a little confusing, but basically move to the location where the Docker file is placed,

check that there are no unnecessary files, and when building a Docker,

specify the current directory, that is, the dot, in the build context.

Then, when you run this, it takes a lot of time, but the image of the Docker is created like this.

If you look at the image with Docker images, you can see that there is a supu-python:1.0.

All you have to do is run Docker as before.

However, the difference is that you have to add the hyphen it option to prevent the container from starting.

Because the container is finished when the process is finished,

for example, if you write an order that starts a process at the end of the Docker file,

you don't need this hyphen it, but this time I didn't add it, so I'll add hyphen it.

So, for example, the name of the Docker run hyphen hyphen name container,

and then run it with hyphen it hyphen d, and then run it with the image of the supu-python:1.0.

When you run this, the container id is displayed, and when you run the Docker piece,

you can see that one container has been created.

As before, enter the container with Docker exec hyphen it supu-server bash.

Then, if you look at where you are in pwd, you can see that you are in the var folder specified in the work directory.

In addition, if you run echo, dara, and site domain,

you can see that the value specified in the Docker file is set to the environment variable of the site domain.

In addition, if you run ls, you can see that there is iris.data brought from the web by the ad command.

If you check the contents with the head, it looks like Ayame's data.

If you move to the directory above one, you can see that there is a requirement.txt.

And if you run python3.9, python can be executed, and if you run import pandas as pd,

you can see that the library can be installed using the requirement.txt.

Now you can create an image from the Docker file you made and start a container,

and you can operate it.

So, I will remove python and this container, and stop this container.

I would like to use the ENTRYPOINT that I left earlier.

In the script.py file of python script, it is written that the print python script was implemented.

As I explained earlier, copy this script and set it to be implemented at the ENTRYPOINT.

Now create a container image with Docker build again.

Docker build-t supu-python, this time the version will be 1.1 and the build context will be defined as ..

If you execute this, you can get the Docker image supu-python:1.0.

Check the position with Docker images, and you can see that the image is made of supu-python:1.0.

By the way, it takes a long time to build the first build, but Docker builds with difference,

so the second supu-python 1.1 was built pretty early.

When you run Docker, remove the background mode and the .it.

The image is 1.1 of supu-python, and set the container name to supu-server 2.

If you execute this, you can see that the python script has been implemented and is output, so you can see that the python script has been running.

By the way, you can see that there is no supu-server 2 even if you do it like Docker ps.

As I said earlier, when Python script is completed by executing the ENTRYPOINT,

nothing has been created, so the container has been stopped.

That's all for this time.

There are still many things that Docker can do, but I hope you understand the basic operation explained this time and use Docker conveniently.

See you in the next video.

Bye bye.