https://www.opseas.net/api.php?action=feedcontributions&feedformat=atom&user=Johnson開源之海 - 用户贡献 [zh-cn]2026-06-12T22:51:02Z用户贡献MediaWiki 1.43.6https://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/image&diff=157基礎原理:容器技术/Docker/Concepts/image2026-05-08T09:10:17Z<p>Johnson：</p>
<hr />
<div>== 说明 ==<br />
鑑於容器是一個隔離的進程, 它從哪裡取得檔案和設定？該如何共享這些環境？<br />
<br />
That's where container images come in. A container image is a standardized package that includes all of the files, binaries, libraries, and configurations to run a container.<br />
<br />
For a PostgreSQL image, that image will package the database binaries, config files, and other dependencies. For a Python web app, it'll include the Python runtime, your app code, and all of its dependencies.<br />
<br />
There are two important principles of images:<br />
<br />
# Images are immutable. Once an image is created, it can't be modified. You can only make a new image or add changes on top of it.<br />
# Container images are composed of layers. Each layer represents a set of file system changes that add, remove, or modify files.<br />
<br />
These two principles let you to extend or add to existing images. For example, if you are building a Python app, you can start from the Python image and add additional layers to install your app's dependencies and add your code. This lets you focus on your app, rather than Python itself.<br />
<br />
=== Finding images ===<br />
Docker Hub is the default global marketplace for storing and distributing images. It has over 100,000 images created by developers that you can run locally. You can search for Docker Hub images and run them directly from Docker Desktop.<br />
<br />
Docker Hub provides a variety of Docker-supported and endorsed images known as Docker Trusted Content. These provide fully managed services or great starters for your own images. These include:<br />
<br />
* Docker Official Images - a curated set of Docker repositories, serve as the starting point for the majority of users, and are some of the most secure on Docker Hub<br />
* Docker Hardened Images - minimal, secure, production-ready images with near-zero CVEs, designed to reduce attack surface and simplify compliance. Free and open source under Apache 2.0<br />
* Docker Verified Publishers - high-quality images from commercial publishers verified by Docker<br />
* Docker-Sponsored Open Source - images published and maintained by open-source projects sponsored by Docker through Docker's open source program<br />
<br />
For example, Redis and Memcached are a few popular ready-to-go Docker Official Images. You can download these images and have these services up and running in a matter of seconds. There are also base images, like the Node.js Docker image, that you can use as a starting point and add your own files and configurations. For production workloads requiring enhanced security, Docker Hardened Images offer minimal variants of popular images like Node.js, Python, and Go.<br />
<br />
== Try it out ==<br />
Follow the instructions to search and pull a Docker image using CLI to view its layers.<br />
Search for and download an image<br />
# Open a terminal and search for images using the docker search command:<br />
<syntaxhighlight lang="docker"><br />
docker search docker/welcome-to-docker<br />
</syntaxhighlight><br />
You will see output like the following:<br />
<syntaxhighlight lang="docker"><br />
NAME DESCRIPTION STARS OFFICIAL<br />
docker/welcome-to-docker Docker image for new users getting started w⦠20<br />
</syntaxhighlight><br />
This output shows you information about relevant images available on Docker Hub.<br />
# Pull the image using the docker pull command.<br />
<syntaxhighlight lang="docker"><br />
docker pull docker/welcome-to-docker<br />
</syntaxhighlight><br />
You will see output like the following:<br />
<syntaxhighlight lang="docker"><br />
Using default tag: latest<br />
latest: Pulling from docker/welcome-to-docker<br />
579b34f0a95b: Download complete<br />
d11a451e6399: Download complete<br />
1c2214f9937c: Download complete<br />
b42a2f288f4d: Download complete<br />
54b19e12c655: Download complete<br />
1fb28e078240: Download complete<br />
94be7e780731: Download complete<br />
89578ce72c35: Download complete<br />
Digest: sha256:eedaff45e3c78538087bdd9dc7afafac7e110061bbdd836af4104b10f10ab693<br />
Status: Downloaded newer image for docker/welcome-to-docker:latest<br />
docker.io/docker/welcome-to-docker:latest<br />
</syntaxhighlight><br />
Each of line represents a different downloaded layer of the image. Remember that each layer is a set of filesystem changes and provides functionality of the image.<br />
<br />
=== Learn about the image ===<br />
<br />
# List your downloaded images using the <code>docker image ls</code> command:<br />
<code>docker image ls</code><br />
You will see output like the following:<br />
<syntaxhighlight lang="docker"><br />
REPOSITORY TAG IMAGE ID CREATED SIZE<br />
docker/welcome-to-docker latest eedaff45e3c7 4 months ago 29.7MB<br />
</syntaxhighlight><br />
The command shows a list of Docker images currently available on your system. The docker/welcome-to-docker has a total size of approximately 29.7MB.<br />
<syntaxhighlight lang="docker"><br />
Image size<br />
<br />
The image size represented here reflects the uncompressed size of the image, not the download size of the layers.<br />
</syntaxhighlight><br />
# List the image's layers using the <code>docker image history</code> command:<br />
<br />
<code>docker image history docker/welcome-to-docker</code><br />
You will see output like the following:<br />
<syntaxhighlight lang="docker"><br />
IMAGE CREATED CREATED BY SIZE COMMENT<br />
648f93a1ba7d 4 months ago COPY /app/build /usr/share/nginx/html # buil… 1.6MB buildkit.dockerfile.v0<br />
<missing> 5 months ago /bin/sh -c #(nop) CMD ["nginx" "-g" "daemon… 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) STOPSIGNAL SIGQUIT 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) EXPOSE 80 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) ENTRYPOINT ["/docker-entr… 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:9e3b2b63db9f8fc7… 4.62kB<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:57846632accc8975… 3.02kB<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:3b1b9915b7dd898a… 298B<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:caec368f5a54f70a… 2.12kB<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:01e75c6dd0ce317d… 1.62kB<br />
<missing> 5 months ago /bin/sh -c set -x && addgroup -g 101 -S … 9.7MB<br />
<missing> 5 months ago /bin/sh -c #(nop) ENV PKG_RELEASE=1 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) ENV NGINX_VERSION=1.25.3 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) LABEL maintainer=NGINX Do… 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) CMD ["/bin/sh"] 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) ADD file:ff3112828967e8004… 7.66MB<br />
</syntaxhighlight><br />
This output shows you all of the layers, their sizes, and the command used to create the layer.<br />
<syntaxhighlight lang="docker"><br />
Viewing the full command<br />
<br />
If you add the --no-trunc flag to the command, you will see the full command. Note that, since the output is in a table-like format, longer commands will cause the output to be very difficult to navigate.<br />
</syntaxhighlight><br />
In this walkthrough, you searched and pulled a Docker image. In addition to pulling a Docker image, you also learned about the layers of a Docker Image.</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/image&diff=156基礎原理:容器技术/Docker/Concepts/image2026-05-08T09:04:10Z<p>Johnson：创建页面，内容为“== Explanation == Seeing as a container is an isolated process, where does it get its files and configuration? How do you share those environments? That's where container images come in. A container image is a standardized package that includes all of the files, binaries, libraries, and configurations to run a container. For a PostgreSQL image, that image will package the database binaries, config files, and other dependencies. For a Python web app, it'll inc…”</p>
<hr />
<div>== Explanation ==<br />
Seeing as a container is an isolated process, where does it get its files and configuration? How do you share those environments?<br />
<br />
That's where container images come in. A container image is a standardized package that includes all of the files, binaries, libraries, and configurations to run a container.<br />
<br />
For a PostgreSQL image, that image will package the database binaries, config files, and other dependencies. For a Python web app, it'll include the Python runtime, your app code, and all of its dependencies.<br />
<br />
There are two important principles of images:<br />
<br />
# Images are immutable. Once an image is created, it can't be modified. You can only make a new image or add changes on top of it.<br />
# Container images are composed of layers. Each layer represents a set of file system changes that add, remove, or modify files.<br />
<br />
These two principles let you to extend or add to existing images. For example, if you are building a Python app, you can start from the Python image and add additional layers to install your app's dependencies and add your code. This lets you focus on your app, rather than Python itself.<br />
<br />
=== Finding images ===<br />
Docker Hub is the default global marketplace for storing and distributing images. It has over 100,000 images created by developers that you can run locally. You can search for Docker Hub images and run them directly from Docker Desktop.<br />
<br />
Docker Hub provides a variety of Docker-supported and endorsed images known as Docker Trusted Content. These provide fully managed services or great starters for your own images. These include:<br />
<br />
* Docker Official Images - a curated set of Docker repositories, serve as the starting point for the majority of users, and are some of the most secure on Docker Hub<br />
* Docker Hardened Images - minimal, secure, production-ready images with near-zero CVEs, designed to reduce attack surface and simplify compliance. Free and open source under Apache 2.0<br />
* Docker Verified Publishers - high-quality images from commercial publishers verified by Docker<br />
* Docker-Sponsored Open Source - images published and maintained by open-source projects sponsored by Docker through Docker's open source program<br />
<br />
For example, Redis and Memcached are a few popular ready-to-go Docker Official Images. You can download these images and have these services up and running in a matter of seconds. There are also base images, like the Node.js Docker image, that you can use as a starting point and add your own files and configurations. For production workloads requiring enhanced security, Docker Hardened Images offer minimal variants of popular images like Node.js, Python, and Go.<br />
<br />
== Try it out ==<br />
Follow the instructions to search and pull a Docker image using CLI to view its layers.<br />
Search for and download an image<br />
# Open a terminal and search for images using the docker search command:<br />
<syntaxhighlight lang="docker"><br />
docker search docker/welcome-to-docker<br />
</syntaxhighlight><br />
You will see output like the following:<br />
<syntaxhighlight lang="docker"><br />
NAME DESCRIPTION STARS OFFICIAL<br />
docker/welcome-to-docker Docker image for new users getting started w⦠20<br />
</syntaxhighlight><br />
This output shows you information about relevant images available on Docker Hub.<br />
# Pull the image using the docker pull command.<br />
<syntaxhighlight lang="docker"><br />
docker pull docker/welcome-to-docker<br />
</syntaxhighlight><br />
You will see output like the following:<br />
<syntaxhighlight lang="docker"><br />
Using default tag: latest<br />
latest: Pulling from docker/welcome-to-docker<br />
579b34f0a95b: Download complete<br />
d11a451e6399: Download complete<br />
1c2214f9937c: Download complete<br />
b42a2f288f4d: Download complete<br />
54b19e12c655: Download complete<br />
1fb28e078240: Download complete<br />
94be7e780731: Download complete<br />
89578ce72c35: Download complete<br />
Digest: sha256:eedaff45e3c78538087bdd9dc7afafac7e110061bbdd836af4104b10f10ab693<br />
Status: Downloaded newer image for docker/welcome-to-docker:latest<br />
docker.io/docker/welcome-to-docker:latest<br />
</syntaxhighlight><br />
Each of line represents a different downloaded layer of the image. Remember that each layer is a set of filesystem changes and provides functionality of the image.<br />
<br />
=== Learn about the image ===<br />
<br />
# List your downloaded images using the <code>docker image ls</code> command:<br />
<code>docker image ls</code><br />
You will see output like the following:<br />
<syntaxhighlight lang="docker"><br />
REPOSITORY TAG IMAGE ID CREATED SIZE<br />
docker/welcome-to-docker latest eedaff45e3c7 4 months ago 29.7MB<br />
</syntaxhighlight><br />
The command shows a list of Docker images currently available on your system. The docker/welcome-to-docker has a total size of approximately 29.7MB.<br />
<syntaxhighlight lang="docker"><br />
Image size<br />
<br />
The image size represented here reflects the uncompressed size of the image, not the download size of the layers.<br />
</syntaxhighlight><br />
# List the image's layers using the <code>docker image history</code> command:<br />
<br />
<code>docker image history docker/welcome-to-docker</code><br />
You will see output like the following:<br />
<syntaxhighlight lang="docker"><br />
IMAGE CREATED CREATED BY SIZE COMMENT<br />
648f93a1ba7d 4 months ago COPY /app/build /usr/share/nginx/html # buil… 1.6MB buildkit.dockerfile.v0<br />
<missing> 5 months ago /bin/sh -c #(nop) CMD ["nginx" "-g" "daemon… 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) STOPSIGNAL SIGQUIT 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) EXPOSE 80 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) ENTRYPOINT ["/docker-entr… 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:9e3b2b63db9f8fc7… 4.62kB<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:57846632accc8975… 3.02kB<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:3b1b9915b7dd898a… 298B<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:caec368f5a54f70a… 2.12kB<br />
<missing> 5 months ago /bin/sh -c #(nop) COPY file:01e75c6dd0ce317d… 1.62kB<br />
<missing> 5 months ago /bin/sh -c set -x && addgroup -g 101 -S … 9.7MB<br />
<missing> 5 months ago /bin/sh -c #(nop) ENV PKG_RELEASE=1 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) ENV NGINX_VERSION=1.25.3 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) LABEL maintainer=NGINX Do… 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) CMD ["/bin/sh"] 0B<br />
<missing> 5 months ago /bin/sh -c #(nop) ADD file:ff3112828967e8004… 7.66MB<br />
</syntaxhighlight><br />
This output shows you all of the layers, their sizes, and the command used to create the layer.<br />
<syntaxhighlight lang="docker"><br />
Viewing the full command<br />
<br />
If you add the --no-trunc flag to the command, you will see the full command. Note that, since the output is in a table-like format, longer commands will cause the output to be very difficult to navigate.<br />
</syntaxhighlight><br />
In this walkthrough, you searched and pulled a Docker image. In addition to pulling a Docker image, you also learned about the layers of a Docker Image.</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts&diff=155基礎原理:容器技术/Docker/Concepts2026-05-08T08:53:00Z<p>Johnson：</p>
<hr />
<div>基础概念<br />
* [[基礎原理:容器技术/Docker/Concepts/container|什么是容器]]<br />
* [[基礎原理:容器技术/Docker/Concepts/image|什么是镜像]]<br />
* [[基礎原理:容器技术/Docker/Concepts/registry|什么是注册机构]]<br />
* [[基礎原理:容器技术/Docker/Concepts/compose|什么是Docker Compose]]<br />
<br />
创建镜像<br />
* 理解镜像的分层<br />
* 编写一个Dockerfile<br />
* 创建，标记，并发布一个镜像<br />
* 使用创建缓存<br />
* 多階段建置<br />
<br />
运行容器<br />
* 发布并暴露端口<br />
* 改写容器默认(配置或参数)<br />
* 持久化容器数据<br />
* 与容器分享本地文件<br />
* 多容器應用程式<br />
<br />
[[基礎原理:容器技术/Docker/Engine|返回Docker引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=154基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:49:30Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<syntaxhighlight lang="docker"><br />
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</syntaxhighlight><br />
<br />
此容器執行一個網頁伺服器，用以顯示一個簡單的網站。當處理較複雜的專案時，您會將不同的部分分別在不同的容器中執行。例如，為<code>frontend</code>,<code>backend</code>,和<code>database</code>.<br />
<br />
<code>提示:</code><br />
<code>docker ps命令将显示 ''仅仅'' 运行的容器. 为查看停止的容器,请添加a</code><code>-a标记去显示所有的容器:</code> <code>docker ps -a</code><br />
<br />
=== 访问前端 ===<br />
當您啟動容器時，您已將容器的一個埠對外公開至您的電腦。您可以將此視為建立了一項設定，讓您能夠透過容器的隔離環境進行連線.<br />
<br />
對於此容器，前端可透過端口 <code>8080</code>. 要開啟該網站，請點選 '''Port(s)''' 容器的欄位，或造訪 <nowiki>http://localhost:8080</nowiki> 在您的瀏覽器中.<br />
<br />
=== 停止您的容器 ===<br />
<code>docker/welcome-to-docker</code> 容器會持續執行，直到您停止它為止。您可以使用 <code>docker stop</code> 命令.<br />
<br />
# 运行 <code>docker ps</code> 取得容器的 ID<br />
# 請提供容器的ID或名稱至 <code>docker stop</code> 命令: <code>docker stop <容器 ID></code><br />
<br />
提示<br />
透過 ID 引用容器時，無需提供完整的 ID。只需提供足以確保其唯一性的部分 ID 即可。例如，可透過執行以下指令來停止前一個容器:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=153基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:47:46Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<syntaxhighlight lang="docker"><br />
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</syntaxhighlight><br />
<br />
此容器執行一個網頁伺服器，用以顯示一個簡單的網站。當處理較複雜的專案時，您會將不同的部分分別在不同的容器中執行。例如，為<code>frontend</code>,<code>backend</code>,和<code>database</code>.<br />
<br />
<syntaxhighlight lang="docker"><br />
<code>提示:</code><br />
<code>docker ps命令将显示 ''仅仅'' 运行的容器. 为查看停止的容器,请添加a</code><code>-a标记去显示所有的容器:</code> <code>docker ps -a</code><br />
</syntaxhighlight><br />
<br />
=== 访问前端 ===<br />
當您啟動容器時，您已將容器的一個埠對外公開至您的電腦。您可以將此視為建立了一項設定，讓您能夠透過容器的隔離環境進行連線.<br />
<br />
對於此容器，前端可透過端口 <code>8080</code>. 要開啟該網站，請點選 '''Port(s)''' 容器的欄位，或造訪 <nowiki>http://localhost:8080</nowiki> 在您的瀏覽器中.<br />
<br />
=== 停止您的容器 ===<br />
<code>docker/welcome-to-docker</code> 容器會持續執行，直到您停止它為止。您可以使用 <code>docker stop</code> 命令.<br />
<br />
# 运行 <code>docker ps</code> 取得容器的 ID<br />
# 請提供容器的ID或名稱至 <code>docker stop</code> 命令: <code>docker stop <容器 ID></code><br />
<br />
提示<br />
透過 ID 引用容器時，無需提供完整的 ID。只需提供足以確保其唯一性的部分 ID 即可。例如，可透過執行以下指令來停止前一個容器:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=152基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:45:29Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<code><div><br />
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</div></code><br />
<br />
此容器執行一個網頁伺服器，用以顯示一個簡單的網站。當處理較複雜的專案時，您會將不同的部分分別在不同的容器中執行。例如，為<code>frontend</code>,<code>backend</code>,和<code>database</code>.<br />
<br />
<div><code>提示:</code><br />
<code>docker ps命令将显示 ''仅仅'' 运行的容器. 为查看停止的容器,请添加a</code><code>-a标记去显示所有的容器:</code> <code>docker ps -a</code></div><br />
<br />
=== 访问前端 ===<br />
當您啟動容器時，您已將容器的一個埠對外公開至您的電腦。您可以將此視為建立了一項設定，讓您能夠透過容器的隔離環境進行連線.<br />
<br />
對於此容器，前端可透過端口 <code>8080</code>. 要開啟該網站，請點選 '''Port(s)''' 容器的欄位，或造訪 <nowiki>http://localhost:8080</nowiki> 在您的瀏覽器中.<br />
<br />
=== 停止您的容器 ===<br />
<code>docker/welcome-to-docker</code> 容器會持續執行，直到您停止它為止。您可以使用 <code>docker stop</code> 命令.<br />
<br />
# 运行 <code>docker ps</code> 取得容器的 ID<br />
# 請提供容器的ID或名稱至 <code>docker stop</code> 命令: <code>docker stop <容器 ID></code><br />
<br />
提示<br />
透過 ID 引用容器時，無需提供完整的 ID。只需提供足以確保其唯一性的部分 ID 即可。例如，可透過執行以下指令來停止前一個容器:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=151基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:43:36Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<code><div><br />
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</div></code><br />
<br />
此容器執行一個網頁伺服器，用以顯示一個簡單的網站。當處理較複雜的專案時，您會將不同的部分分別在不同的容器中執行。例如，為<code>frontend</code>,<code>backend</code>,和<code>database</code>.<br />
<br />
<div>提示<br />
<code>docker ps</code>命令将显示 ''仅仅'' 运行的容器. 为查看停止的容器,请添加a<code>-a</code>标记去显示所有的容器: <code>docker ps -a</code></div><br />
<br />
=== 访问前端 ===<br />
當您啟動容器時，您已將容器的一個埠對外公開至您的電腦。您可以將此視為建立了一項設定，讓您能夠透過容器的隔離環境進行連線.<br />
<br />
對於此容器，前端可透過端口 <code>8080</code>. 要開啟該網站，請點選 '''Port(s)''' 容器的欄位，或造訪 <nowiki>http://localhost:8080</nowiki> 在您的瀏覽器中.<br />
<br />
=== 停止您的容器 ===<br />
<code>docker/welcome-to-docker</code> 容器會持續執行，直到您停止它為止。您可以使用 <code>docker stop</code> 命令.<br />
<br />
# 运行 <code>docker ps</code> 取得容器的 ID<br />
# 請提供容器的ID或名稱至 <code>docker stop</code> 命令: <code>docker stop <容器 ID></code><br />
<br />
提示<br />
透過 ID 引用容器時，無需提供完整的 ID。只需提供足以確保其唯一性的部分 ID 即可。例如，可透過執行以下指令來停止前一個容器:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=150基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:42:18Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<code><div><br />
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</div></code><br />
<br />
此容器執行一個網頁伺服器，用以顯示一個簡單的網站。當處理較複雜的專案時，您會將不同的部分分別在不同的容器中執行。例如，為<code>frontend</code>,<code>backend</code>,和<code>database</code>.<br />
<br />
<code>提示<br />
<code>docker ps</code>命令将显示 ''仅仅'' 运行的容器. 为查看停止的容器,请添加a<code>-a</code>标记去显示所有的容器: <code>docker ps -a</code></code><br />
<br />
=== 访问前端 ===<br />
當您啟動容器時，您已將容器的一個埠對外公開至您的電腦。您可以將此視為建立了一項設定，讓您能夠透過容器的隔離環境進行連線.<br />
<br />
對於此容器，前端可透過端口 <code>8080</code>. 要開啟該網站，請點選 '''Port(s)''' 容器的欄位，或造訪 <nowiki>http://localhost:8080</nowiki> 在您的瀏覽器中.<br />
<br />
=== 停止您的容器 ===<br />
<code>docker/welcome-to-docker</code> 容器會持續執行，直到您停止它為止。您可以使用 <code>docker stop</code> 命令.<br />
<br />
# 运行 <code>docker ps</code> 取得容器的 ID<br />
# 請提供容器的ID或名稱至 <code>docker stop</code> 命令: <code>docker stop <容器 ID></code><br />
<br />
提示<br />
透過 ID 引用容器時，無需提供完整的 ID。只需提供足以確保其唯一性的部分 ID 即可。例如，可透過執行以下指令來停止前一個容器:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=149基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:41:04Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<code><div><br />
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</div></code><br />
<br />
此容器執行一個網頁伺服器，用以顯示一個簡單的網站。當處理較複雜的專案時，您會將不同的部分分別在不同的容器中執行。例如，為<code>frontend</code>,<code>backend</code>,和<code>database</code>.<br />
<br />
<code>提示<br />
<code>docker ps</code>命令将显示 ''仅仅'' 运行的容器. 为查看停止的容器,请添加a<code>-a</code>标记去显示所有的容器: <code>docker ps -a</code></code><br />
<br />
=== 访问前端 ===<br />
當您啟動容器時，您已將容器的一個埠對外公開至您的電腦。您可以將此視為建立了一項設定，讓您能夠透過容器的隔離環境進行連線.<br />
<br />
對於此容器，前端可透過端口 <code>8080</code>. 要開啟該網站，請點選 '''Port(s)''' 容器的欄位，或造訪 <nowiki>http://localhost:8080</nowiki> 在您的瀏覽器中.<br />
<br />
=== 停止您的容器 ===<br />
<code>docker/welcome-to-docker</code> 容器會持續執行，直到您停止它為止。您可以使用 <code>docker stop</code> 命令.<br />
<br />
# 运行 <code>docker ps</code> 取得容器的 ID<br />
# 請提供容器的ID或名稱至 <code>docker stop</code> 命令: <code>docker stop <容器 ID></code><br />
<br />
提示<br />
透過 ID 引用容器時，無需提供完整的 ID。只需提供足以確保其唯一性的部分 ID 即可。例如，可透過執行以下指令來停止前一個容器:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=148基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:40:10Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<code><div><br />
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</div></code><br />
<br />
<br />
此容器執行一個網頁伺服器，用以顯示一個簡單的網站。當處理較複雜的專案時，您會將不同的部分分別在不同的容器中執行。例如，為<code>frontend</code>,<code>backend</code>,和<code>database</code>.<br />
<br />
<code>提示<br />
<code>docker ps</code>命令将显示 ''仅仅'' 运行的容器. 为查看停止的容器,请添加a<code>-a</code>标记去显示所有的容器: <code>docker ps -a</code></code><br />
<br />
=== 访问前端 ===<br />
當您啟動容器時，您已將容器的一個埠對外公開至您的電腦。您可以將此視為建立了一項設定，讓您能夠透過容器的隔離環境進行連線.<br />
<br />
對於此容器，前端可透過端口 <code>8080</code>. 要開啟該網站，請點選 '''Port(s)''' 容器的欄位，或造訪 <nowiki>http://localhost:8080</nowiki> 在您的瀏覽器中.<br />
<br />
=== 停止您的容器 ===<br />
<code>docker/welcome-to-docker</code> 容器會持續執行，直到您停止它為止。您可以使用 <code>docker stop</code> 命令.<br />
<br />
# 运行 <code>docker ps</code> 取得容器的 ID<br />
# 請提供容器的ID或名稱至 <code>docker stop</code> 命令: <code>docker stop <容器 ID></code><br />
<br />
提示<br />
透過 ID 引用容器時，無需提供完整的 ID。只需提供足以確保其唯一性的部分 ID 即可。例如，可透過執行以下指令來停止前一個容器:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=147基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:32:30Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<code>CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</code><br />
<br />
此容器執行一個網頁伺服器，用以顯示一個簡單的網站。當處理較複雜的專案時，您會將不同的部分分別在不同的容器中執行。例如，為<code>frontend</code>,<code>backend</code>,和<code>database</code>.<br />
<br />
<code>提示<br />
<code>docker ps</code>命令将显示 ''仅仅'' 运行的容器. 为查看停止的容器,请添加a<code>-a</code>标记去显示所有的容器: <code>docker ps -a</code></code><br />
<br />
=== 访问前端 ===<br />
當您啟動容器時，您已將容器的一個埠對外公開至您的電腦。您可以將此視為建立了一項設定，讓您能夠透過容器的隔離環境進行連線.<br />
<br />
對於此容器，前端可透過端口 <code>8080</code>. 要開啟該網站，請點選 '''Port(s)''' 容器的欄位，或造訪 <nowiki>http://localhost:8080</nowiki> 在您的瀏覽器中.<br />
<br />
=== 停止您的容器 ===<br />
<code>docker/welcome-to-docker</code> 容器會持續執行，直到您停止它為止。您可以使用 <code>docker stop</code> 命令.<br />
<br />
# 运行 <code>docker ps</code> 取得容器的 ID<br />
# 請提供容器的ID或名稱至 <code>docker stop</code> 命令: <code>docker stop <容器 ID></code><br />
<br />
提示<br />
透過 ID 引用容器時，無需提供完整的 ID。只需提供足以確保其唯一性的部分 ID 即可。例如，可透過執行以下指令來停止前一個容器:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=146基礎原理:容器技术/Docker/Concepts/container2026-05-08T08:20:37Z<p>Johnson：</p>
<hr />
<div>== 說明 ==<br />
假設你正在開發一款功能強大的網頁應用程式，它包含三個主要組件 - 一個 React 前端、一個 Python API 以及一個 PostgreSQL 資料庫。若您想參與此專案，必須安裝 Node、Python 和 PostgreSQL.<br />
<br />
您如何確保自己使用的版本與團隊中其他開發人員、CI/CD 系統，或是生產環境中使用的版本一致？<br />
<br />
您如何確保應用程式所需的 Python（或 Node、資料庫）版本不會受到電腦上現有軟體的影響？您如何處理潛在的衝突？?<br />
<br />
容器登場！<br />
<br />
什麼是容器？簡單來說，容器就是為應用程式的每個元件所建立的隔離進程。每個元件——無論是前端的 React 應用程式、Python API 引擎，還是資料庫——都在各自的隔離環境中運行，與機器上的其他一切完全隔離。<br />
<br />
以下就是它們如此出色的原因。容器是:<br />
<br />
* 自包含。每個容器都具備運作所需的一切，無需依賴主機上預先安裝的任何依賴項.<br />
* 隔離。由於容器在隔離環境中運行，因此對主機和其他容器的影響極小，從而提升了應用程式的安全性.<br />
* 獨立運作。每個容器皆獨立管理。刪除其中一個容器不會影響其他容器.<br />
* 可攜式。容器可在任何地方運行！在您的開發機器上運行的容器，在資料中心或雲端任何地方都能以相同方式運作!<br />
<br />
=== 容器與虛擬機器的比較 (VMs) ===<br />
不深入探討細節的話，虛擬機器（VM）是一個完整的作業系統，擁有自己的核心、硬體驅動程式、程式及應用程式。僅為了隔離單一應用程式而啟動虛擬機器，會造成相當大的系統負擔.<br />
<br />
容器本質上是一個獨立的進程，其中包含其運行所需的所有檔案。若同時執行多個容器，它們將共用同一個核心，讓您能在更少的基礎設施上運行更多應用程式.<blockquote>'''同時使用虛擬機器與容器'''<br />
<br />
在許多情況下，您會看到容器與虛擬機器（VM）被併用。舉例來說，在雲端環境中，所配置的機器通常是虛擬機器。然而，與其為運行單一應用程式而配置一台機器，配備容器執行環境的虛擬機器可以同時運行多個容器化應用程式，從而提高資源利用率並降低成本.</blockquote><br />
<br />
== 試試看 ==<br />
在這項實作中，您將了解如何透過 Docker CLI介面執行Docker容器.<br />
請依照指示，使用命令列介面 (CLI) 執行容器:<br />
# 開啟您的 CLI 終端機，並使用 <code>docker run</code> 命令:<br />
<code>$docker run -d -p 8080:80 docker/welcome-to-docker</code><br />
此命令的輸出結果是完整的容器 ID.<br />
恭喜！您剛啟動了第一個容器! 🎉<br />
<br />
=== 檢視正在執行的容器 ===<br />
您可以透過以下方式確認容器是否已啟動並正在運行： <code>docker ps</code> 命令:<br />
<code>docker ps</code><br />
您將看到類似以下的輸出:<br />
<code>CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES<br />
a1f7a4bb3a27 docker/welcome-to-docker "/docker-entrypoint.…" 11 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp gracious_keldysh</code><br />
<br />
This container runs a web server that displays a simple website. When working with more complex projects, you'll run different parts in different containers. For example, a different container for the <code>frontend</code>, <code>backend</code>, and <code>database</code>.<br />
<br />
Tip<br />
<br />
The <code>docker ps</code> command will show you ''only'' running containers. To view stopped containers, add the <code>-a</code> flag to list all containers: <code>docker ps -a</code><br />
<br />
=== Access the frontend ===<br />
When you launched the container, you exposed one of the container's ports onto your machine. Think of this as creating configuration to let you to connect through the isolated environment of the container.<br />
<br />
For this container, the frontend is accessible on port <code>8080</code>. To open the website, select the link in the '''Port(s)''' column of your container or visit <nowiki>http://localhost:8080</nowiki> in your browser.<br />
<br />
=== Stop your container ===<br />
The <code>docker/welcome-to-docker</code> container continues to run until you stop it. You can stop a container using the <code>docker stop</code> command.<br />
<br />
# Run <code>docker ps</code> to get the ID of the container<br />
# Provide the container ID or name to the <code>docker stop</code> command: <code>docker stop <the-container-id></code><br />
<br />
Tip<br />
When referencing containers by ID, you don't need to provide the full ID. You only need to provide enough of the ID to make it unique. As an example, the previous container could be stopped by running the following command:<br />
<code>docker stop a1f</code></div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E9%96%8B%E6%BA%90%E5%8D%94%E8%AD%B0&diff=145基礎原理:開源協議2026-05-06T14:36:44Z<p>Johnson：创建页面，内容为“📖 開源協議：數位時代的契約基石 一、 什麼是開源協議？ 開源協議是一種法律許可合同。它定義了軟體著作權人與使用者之間的權利與義務。本質上，它並非放棄版權，而是透過預先授權的方式，允許他人進行複製、修改及分發。如果沒有這些協議，根據傳統著作權法，任何未經明確授權的代碼使用皆屬違法，這將極大地阻礙技術協作。 開源協…”</p>
<hr />
<div>📖 開源協議：數位時代的契約基石<br />
<br />
一、 什麼是開源協議？<br />
<br />
開源協議是一種法律許可合同。它定義了軟體著作權人與使用者之間的權利與義務。本質上，它並非放棄版權，而是透過預先授權的方式，允許他人進行複製、修改及分發。如果沒有這些協議，根據傳統著作權法，任何未經明確授權的代碼使用皆屬違法，這將極大地阻礙技術協作。<br />
<br />
開源協議是基於著作權法（Copyright）的一種預先授權許可。它並非放棄版權，而是版權持有人（Contributor）明確告知公眾：在遵守特定條款的前提下，任何人皆可自由使用、修改及分發該軟體。如果沒有協議，代碼在法律上默認是「保留所有權利」的私有財產。<br />
<br />
二、 為什麼會出現開源協議？<br />
<br />
在軟體發展早期，代碼通常隨硬體附贈且自由流通。但隨著作權意識抬頭，廠商開始隱藏原始碼以建立商業堡壘。開源協議的出現旨在解決兩大核心問題：<br />
<br />
* 消除法律風險：讓開發者在合作時不必逐一簽署授權書。<br />
* 防止私有化：確保共享的成果不會被第三方惡意佔有或用於法律訴訟，保護開發者的勞動尊嚴。<br />
* 技術共建需求：解決跨組織、跨國界協作中的法律障礙。<br />
* 防止公地悲劇：防止個人或企業將社群共創的成果私有化而不回饋。<br />
* 法律避險：明確條款（如「免責聲明」）保護開發者免受軟體缺陷帶來的連帶法律責任。<br />
<br />
三、 歷史起源與演進<br />
<br />
* 1970年代：軟體專有化興起，黑客文化受挫。<br />
* 1980年代（關鍵期）：Richard Stallman 於 1985 年發起自由軟體運動，並於 1989 年撰寫了第一版 GPL (GNU 通用公共授權)，這標誌著現代開源法律框架的誕生。<br />
* 1990年代至今：隨互聯網爆發，BSD、MIT 等更靈活的協議相繼成熟。1998 年「開源軟體」（Open Source）概念被正式提出，將重點從「自由」轉向「開發效率」。<br />
* 萌芽期 (1970s)：早期軟體代碼隨硬件附贈，開發者之間自由交換磁帶，存在契約雛形。<br />
* 法制化 (1980s)：1985 年 Richard Stallman 創立自由軟體基金會（FSF）。1989 年 GPL v1.0 問世，正式確立了「Copyleft」法律概念。<br />
* 商業化與多樣化 (1990s-2000s)：1998 年「開源」（Open Source）概念提出，強調開發模式的效率。此後 MIT、Apache 等更符合商業利益的協議開始盛行。<br />
<br />
四、 主要協議類型與邏輯區分<br />
<br />
1. 寬鬆型授權 (Permissive) —— 商業友好<br />
<br />
這類協議限制極少，不要求衍生作品開源，是目前最受商業公司歡迎的類型。<br />
<br />
* MIT License：極度簡潔，僅要求保留版權聲明。適用於追求最大化傳播的專案。<br />
* BSD (Berkeley Software Distribution)：分為二句版與三句版。要求保留版權聲明，且禁止利用原作者名義背書。<br />
* Apache License 2.0：提供明確的專利授權（Patent Grant），若原作者持有相關專利，使用代碼時自動獲得許可，安全性極高。<br />
<br />
2. 強傳染型授權 (Strong Copyleft) —— 社群優先<br />
<br />
要求任何使用了該代碼的衍生作品，必須以「相同的協議」分發，確保軟體永遠自由。<br />
<br />
* GNU GPL (v2/v3)：最強大的保護協議。若你的軟體使用了 GPL 代碼，你的整個專案都必須開源。v3 版增加了反 Tivoization（防止硬體鎖定開源軟體）條款。<br />
* GNU AGPL (Affero GPL)：補足了雲端漏洞。規定即使不分發安裝包，僅透過網路（SaaS）提供服務，也必須向用戶公開原始碼。<br />
<br />
3. 弱傳染型授權 (Weak Copyleft) —— 靈活折衷<br />
<br />
介於兩者之間，通常以「模組/檔案」為界限進行約束。<br />
<br />
* GNU LGPL：專為函數庫設計。允許閉源程式碼「動態連結」此庫。只有當你修改庫本身時，才需要開源修改部分。<br />
* MPL (Mozilla Public License)：以「檔案」為單位。修改了受 MPL 保護的文件需開源，但同一專案中其他新增的私有文件可以不開源。<br />
<br />
4. 特殊領域授權 (Specialized)<br />
<br />
* EPL (Eclipse Public License)：對企業友好，提供專利許可，且允許將開源代碼與私有代碼組合。<br />
* Unlicense / CC0：放棄所有權利，將作品直接貢獻給公共領域 (Public Domain)。<br />
<br />
5. 內容創作專用 (Creative Commons)<br />
<br />
雖然主要用於文件、圖片或 Wiki 內容（而非程式碼），但在 MediaWiki 中非常常見。<br />
<br />
* CC BY-SA (姓名標示-相同方式分享)：這是 Wikipedia 採用的協議。它要求使用者標明原作者，且修改後的內容必須以同樣的 CC 協議發布。<br />
<br />
五、 如何選擇？ (快速指南)<br />
<br />
* 如果您希望被廣泛採用且不介意他人閉源：選擇 MIT。<br />
* 如果您在乎專利保護與企業合規：選擇 Apache 2.0。<br />
* 如果您希望修改者必須回饋社群：選擇 GPL v3。<br />
* 如果您開發的是網絡服務後端：選擇 AGPL。</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=144基礎原理:容器技术/Docker/Architecture2026-05-06T14:10:07Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個基本分離的被稱爲容器的環境進行打包和運行應用程式的能力。這種隔離及安全性可以讓你在同一臺主機上同時運行多個容器。容器是輕量的，並具備運行應用所需的所有依賴，因此，您無需依賴主機上已安裝的軟體。您可以在工作時分享容器，並確保所有接收者都能獲得運作方式完全相同的容器。<br />
<br />
Docker 提供了一套工具和平台，用於管理容器的生命週期:<br />
* 使用容器開發您的應用程式及其相關元件<br />
* 容器成為部署和測試您應用程式的基本單位<br />
* 準備就緒後，請將您的應用程式部署至生產環境，形式可以是容器或經協調的服務. 無論您的生產環境是本地資料中心、雲端服務供應商，還是兩者的混合部署，此方法皆適用.<br />
<br />
== Docker可以用於做什麼？ ==<br />
=== 快速且穩定地交付您的應用程式 ===<br />
Docker透過讓開發人員在標準化環境中使用本地容器來執行應用程式與服務，從而簡化開發生命週期。容器非常適合用於持續整合與持續交付（CI/CD）工作流程。<br />
<br />
請考慮以下範例情境:<br />
<br />
* 您的開發人員在本地編寫程式碼，並透過Docker容器與同事分享工作成果.<br />
* 他們使用Docker將應用程式部署到測試環境中，並執行自動化與手動測試.<br />
* 當開發人員發現錯誤時，他們可以在開發環境中進行修正，並將其重新部署至測試環境進行測試與驗證.<br />
* 測試完成後，只需將更新的映像檔推送至生產環境，即可輕鬆將修正程式交付給客戶.<br />
<br />
=== 響應式部署與擴展 ===<br />
Docker基於容器的平台能實現高度可移植的工作負載。Docker容器可在開發者的本地筆記型電腦、資料中心的實體或虛擬機器、雲端服務供應商的環境，或是混合環境中運行.<br />
<br />
Docker 的可移植性與輕量級特性，也使其能輕鬆地動態管理工作負載，並能根據業務需求，近乎即時地擴展或終止應用程式與服務。<br />
<br />
=== 在相同的硬件上運行更多的工作載荷 ===<br />
Docker 輕量且快速。它為基於虛擬管理程式的虛擬機器提供了可行且具成本效益的替代方案，讓您能更充分地利用伺服器容量來達成業務目標。Docker 非常適合高密度環境，以及需要以更少的資源完成更多任務的中小型部署。.<br />
<br />
== Docker 架構 ==<br />
Docker 採用客戶端-伺服器架構。Docker 客戶端與 Docker 守護程式進行通訊，後者負責執行建置、運行及分發 Docker 容器的繁重工作。Docker 客戶端與守護程式可以運行在同一系統上，您也可以將 Docker 客戶端連接到遠端的 Docker 守護程式。Docker 客戶端與守護程式透過 REST API、UNIX 套接字或網路介面進行通訊。另一種 Docker 客戶端是 Docker Compose，它讓您能夠管理由一組容器組成的應用程式.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== Docker 守護進程(daemon) ===<br />
Docker的守護進程 (<code>dockerd</code>) 監聽 Docker API 請求，並管理 Docker 物件，例如映像檔、容器、網路和儲存卷。守護程式亦可與其他守護程式通訊，以管理 Docker 服務.<br />
<br />
=== Docker 客戶端 ===<br />
Docker的客戶端(<code>docker</code>)這是許多Docker使用者與Docker互動的主要方式.當你使用命令如 <code>docker run</code>,客戶端將這些指令傳送至<code>dockerd</code>,它負責執行這些命令.該<code>docker</code>命令使用Docker API跟守護進程通信，Docker客戶端可以與多個守護程式進行通訊。<br />
<br />
=== Docker 桌面版 ===<br />
Docker Desktop是一款適用於Mac、Windows或Linux環境的易於安裝的應用程式，可讓您建立並分享容器化應用程式與微服務。Docker Desktop內建Docker守護程式 (<code>dockerd</code>),Docker客戶端(<code>docker</code>),Docker Compose, Docker Content Trust, Kubernetes, 以及憑證助手。更多詳細的內容請參看Docker Desktop.<br />
<br />
=== Docker registries(註冊) ===<br />
Docker registry用於存放Docker鏡像. Docker Hub是一個開放的註冊服務任何人都可以使用,Docker默認在Docker Hub上尋找鏡像.你甚至可以運行自己的私有註冊服務。<br />
<br />
當你使用<code>docker pull</code>或<code>docker run</code>命令, Docker從您配置的註冊機構拉取所需的鏡像。當您使用<code>docker push</code>命令,Docker推送您的鏡像到您配置的註冊機構。<br />
<br />
=== Docker 對象 ===<br />
當你使用Docker,您就會創建並使用鏡像,容器,網絡,卷,插件,和其他的對象。本節將簡要概述其中部分物件。<br />
<br />
==== 鏡像(映像檔) ====<br />
映像檔是一種只讀範本，其中包含建立Docker容器的指示。通常，映像檔是基於另一個映像檔所建構，並進行了一些額外的客製化。例如，您可以建立一個基於 Ubuntu 映像檔的映像檔，其中包含 Apache 網頁伺服器與您的應用程式，以及讓應用程式正常運作所需的配置細節。<br />
<br />
您可以自行建立映像檔，也可以僅使用他人建立並發佈至註冊機構中的映像檔。若要建立自己的映像檔，您需撰寫一份 Dockerfile，透過簡單的語法定義建立映像檔及執行所需的步驟。Dockerfile 中的每條指令都會在映像中建立一個層。當您修改 Dockerfile 並重新建立映像時，系統只會重新建立那些已變更的層。這正是映像相較於其他虛擬化技術，之所以如此輕量、小巧且快速的原因之一。<br />
<br />
==== 容器 ====<br />
容器是映像的可執行實例。您可以透過 Docker API 或 CLI 來建立、啟動、停止、移動或刪除容器。您可以將容器連接到一個或多個網路、為其掛載儲存空間，甚至可以根據其當前狀態建立新的映像。<br />
<br />
預設情況下，容器與其他容器及其主機之間的隔離程度相當高。您可以控制容器的網路、儲存或其他底層子系統與其他容器或主機之間的隔離程度。<br />
<br />
容器的定義取決於其映像檔，以及您在建立或啟動容器時所提供的任何設定選項。當容器被移除時，任何未儲存於持久儲存裝置中的狀態變更都會消失。<br />
<br />
===== 範例 <code>docker run</code> 命令 =====<br />
如下的命令運行一個<code>ubuntu</code>容器,並交互式的附加到你的本地命令行會話，並運行<code>/bin/bash</code>命令：<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
執行此指令時，將會發生以下情況(假設您使用的是預設的註冊機構設定):<br />
<br />
# 如果您本地沒有<code>ubuntu</code>鏡像,Docker從配置的默認註冊機構拉取該鏡像, 就像您手工運行過<code>docker pull ubuntu</code>命令一樣。<br />
# Docker創建一個新容器,就好像您手工運行過<code>docker container create</code>命令一樣。<br />
# Docker會為容器分配一個可讀寫的檔案系統，作為其最外層。這使得正在運行的容器能夠在其本機檔案系統中建立或修改檔案與目錄。<br />
# Docker會建立一個網路介面，將容器連接到預設網路，由於您未指定任何網路選項。這包括為容器指派一個 IP 位址。預設情況下，容器可透過主機的網路連線連接到外部網路。<br />
# Docker啟動容器並執行<code>/bin/bash</code>。因為該容器是以互動模式執行，並已連接到您的終端會話 (由於使用了 <code>-i</code> 和 <code>-t</code> 標記),您可以透過鍵盤輸入指令，同時Docker會將輸出記錄到您的終端會話上。<br />
# 當您運行<code>exit</code>終止該<code>/bin/bash</code>命令,容器將停止運作，但尚未移除。您可以重新啟動它，或將其移除.<br />
<br />
== 底層技術 ==<br />
Docker 是以 Go 程式語言編寫的，並利用 Linux 核心的多項功能來實現其運作。Docker 採用了一種稱為 <code>namespaces</code> 提供稱為「容器」的隔離工作空間。當您執行一個容器時，Docker會為該容器建立一組命名空間。<br />
<br />
這些命名空間提供了一層隔離機制。容器的每個部分都在獨立的名稱空間中運行，且其存取範圍僅限於該名稱空間。<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|Docker引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts&diff=143基礎原理:容器技术/Docker/Concepts2026-05-06T14:08:40Z<p>Johnson：</p>
<hr />
<div>基础概念<br />
* [[基礎原理:容器技术/Docker/Concepts/container|什么是容器]]<br />
* 什么是镜像<br />
* 什么是注册机构<br />
* 什么是Docker Compose<br />
<br />
创建镜像<br />
* 理解镜像的分层<br />
* 编写一个Dockerfile<br />
* 创建，标记，并发布一个镜像<br />
* 使用创建缓存<br />
* 多階段建置<br />
<br />
运行容器<br />
* 发布并暴露端口<br />
* 改写容器默认(配置或参数)<br />
* 持久化容器数据<br />
* 与容器分享本地文件<br />
* 多容器應用程式<br />
<br />
[[基礎原理:容器技术/Docker/Engine|返回Docker引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Engine&diff=142基礎原理:容器技术/Docker/Engine2026-05-06T14:06:47Z<p>Johnson：</p>
<hr />
<div>= Docker Engine =<br />
Docker Engine （Docker引擎）是一个用于创建并容器化你的应用程序的开源的集装箱化技术。Docker引擎作为一个客户端-服务器端的应用模式包含如下组件： <br />
<br />
* 一个长时间在后台运行的进程(daemon process)作为服务器端 <code>dockerd</code>.<br />
* 定義了程式可與Docker守護進程通信及控制的APIs接口.<br />
* 一个命令行形式交互接口(CLI)的客户端 <code>docker</code>.<br />
<br />
命令行控制接口(CLI)使用Docker APIs通過編寫腳本或直接輸入命令的方式去控制Docker守護進程及與之交互. 許多其他 Docker 應用程式都使用底層的 API 和 CLI. 該守護程式負責建立和管理Docker物件(對象)，例如映像檔、容器、網路和儲存卷.<br />
<br />
更多細節參看[[基礎原理:容器技术/Docker/Architecture|Docker架構]]及[[基礎原理:容器技术/Docker/Concepts|Docker概念]]<br />
<br />
<div style="display: flex; flex-wrap: wrap;"><br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Install |title=Install Docker Engine |desc=爲您的分發版本安裝Docker引擎.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Storage |title=Storage |desc=在Docker容器中使用持久化數據.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Networking |title=Networking |desc=管理容器之間的網路連線.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Logs |title=Container Logs |desc=瞭解如何檢視和閱讀容器日誌.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Prune |title=Prune |desc=清理未使用的資源.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/daemoncfg |title=Configure the daemon |desc=深入了解 Docker 守護程式的設定選項.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/rootless |title=Rootless mode |desc=以非root權限執行Docker.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/deprecated |title=Deprecated features |desc=了解您應該停止使用Docker Engine的哪些功能.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/release |title=Release notes |desc=最新版本的發行說明.}}<br />
</div><br />
<br />
== Licensing ==<br />
Commercial use of Docker Engine obtained via Docker Desktop within larger enterprises (exceeding 250 employees OR with annual revenue surpassing $10 million USD), requires a paid subscription. Apache License, Version 2.0. See LICENSE for the full license.<br />
[[Category:Docker]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts/container&diff=141基礎原理:容器技术/Docker/Concepts/container2026-05-06T13:59:33Z<p>Johnson：创建页面，内容为“== Explanation == Imagine you're developing a killer web app that has three main components - a React frontend, a Python API, and a PostgreSQL database. If you wanted to work on this project, you'd have to install Node, Python, and PostgreSQL. How do you make sure you have the same versions as the other developers on your team? Or your CI/CD system? Or what's used in production? How do you ensure the version of Python (or Node or the database) your app needs…”</p>
<hr />
<div>== Explanation ==<br />
Imagine you're developing a killer web app that has three main components - a React frontend, a Python API, and a PostgreSQL database. If you wanted to work on this project, you'd have to install Node, Python, and PostgreSQL.<br />
<br />
How do you make sure you have the same versions as the other developers on your team? Or your CI/CD system? Or what's used in production?<br />
<br />
How do you ensure the version of Python (or Node or the database) your app needs isn't affected by what's already on your machine? How do you manage potential conflicts?<br />
<br />
Enter containers!<br />
<br />
What is a container? Simply put, containers are isolated processes for each of your app's components. Each component - the frontend React app, the Python API engine, and the database - runs in its own isolated environment, completely isolated from everything else on your machine.<br />
<br />
Here's what makes them awesome. Containers are:<br />
<br />
* Self-contained. Each container has everything it needs to function with no reliance on any pre-installed dependencies on the host machine.<br />
* Isolated. Since containers run in isolation, they have minimal influence on the host and other containers, increasing the security of your applications.<br />
* Independent. Each container is independently managed. Deleting one container won't affect any others.<br />
* Portable. Containers can run anywhere! The container that runs on your development machine will work the same way in a data center or anywhere in the cloud!<br />
<br />
=== Containers versus virtual machines (VMs) ===<br />
Without getting too deep, a VM is an entire operating system with its own kernel, hardware drivers, programs, and applications. Spinning up a VM only to isolate a single application is a lot of overhead.<br />
<br />
A container is simply an isolated process with all of the files it needs to run. If you run multiple containers, they all share the same kernel, allowing you to run more applications on less infrastructure.<blockquote>'''Using VMs and containers together'''<br />
<br />
Quite often, you will see containers and VMs used together. As an example, in a cloud environment, the provisioned machines are typically VMs. However, instead of provisioning one machine to run one application, a VM with a container runtime can run multiple containerized applications, increasing resource utilization and reducing costs.</blockquote><br />
<br />
== Try it out ==<br />
In this hands-on, you will see how to run a Docker container using the Docker Desktop GUI.</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts&diff=140基礎原理:容器技术/Docker/Concepts2026-05-06T13:53:15Z<p>Johnson：</p>
<hr />
<div>基础概念<br />
* [[基礎原理:容器技术/Docker/Concepts/container|什么是容器]]<br />
* 什么是镜像<br />
* 什么是注册机构<br />
* 什么是Docker Compose<br />
<br />
创建镜像<br />
* 理解镜像的分层<br />
* 编写一个Dockerfile<br />
* 创建，标记，并发布一个镜像<br />
* 使用创建缓存<br />
* 多階段建置<br />
<br />
运行容器<br />
* 发布并暴露端口<br />
* 改写容器默认(配置或参数)<br />
* 持久化容器数据<br />
* 与容器分享本地文件<br />
* 多容器應用程式</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts&diff=139基礎原理:容器技术/Docker/Concepts2026-05-06T13:45:13Z<p>Johnson：</p>
<hr />
<div>基础概念<br />
* 什么是容器<br />
* 什么是镜像<br />
* 什么是注册机构<br />
* 什么是Docker Compose<br />
<br />
创建镜像<br />
* 理解镜像的分层<br />
* 编写一个Dockerfile<br />
* 创建，标记，并发布一个镜像<br />
* 使用创建缓存<br />
* 多階段建置<br />
<br />
运行容器<br />
* 发布并暴露端口<br />
* 改写容器默认(配置或参数)<br />
* 持久化容器数据<br />
* 与容器分享本地文件<br />
* 多容器應用程式</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts&diff=138基礎原理:容器技术/Docker/Concepts2026-05-06T13:38:13Z<p>Johnson：</p>
<hr />
<div>基础概念<br />
* 什么是容器<br />
* 什么是镜像<br />
* 什么是注册机构<br />
* 什么是Docker Compose<br />
<br />
创建镜像<br />
<br />
运行容器</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Concepts&diff=137基礎原理:容器技术/Docker/Concepts2026-05-06T13:37:55Z<p>Johnson：创建页面，内容为“基础概念 * 什么是容器 * 什么是镜像 * 什么是注册机构 * 什么是Docker Compose 创建镜像 运行容器”</p>
<hr />
<div>基础概念<br />
* 什么是容器<br />
* 什么是镜像<br />
* 什么是注册机构<br />
* 什么是Docker Compose<br />
<br />
创建镜像<br />
运行容器</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=136基礎原理:容器技术/Docker/Architecture2026-05-06T13:26:31Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個基本分離的被稱爲容器的環境進行打包和運行應用程式的能力。這種隔離及安全性可以讓你在同一臺主機上同時運行多個容器。容器是輕量的，並具備運行應用所需的所有依賴，因此，您無需依賴主機上已安裝的軟體。您可以在工作時分享容器，並確保所有接收者都能獲得運作方式完全相同的容器。<br />
<br />
Docker 提供了一套工具和平台，用於管理容器的生命週期:<br />
* 使用容器開發您的應用程式及其相關元件<br />
* 容器成為部署和測試您應用程式的基本單位<br />
* 準備就緒後，請將您的應用程式部署至生產環境，形式可以是容器或經協調的服務. 無論您的生產環境是本地資料中心、雲端服務供應商，還是兩者的混合部署，此方法皆適用.<br />
<br />
== Docker可以用於做什麼？ ==<br />
=== 快速且穩定地交付您的應用程式 ===<br />
Docker透過讓開發人員在標準化環境中使用本地容器來執行應用程式與服務，從而簡化開發生命週期。容器非常適合用於持續整合與持續交付（CI/CD）工作流程。<br />
<br />
請考慮以下範例情境:<br />
<br />
* 您的開發人員在本地編寫程式碼，並透過Docker容器與同事分享工作成果.<br />
* 他們使用Docker將應用程式部署到測試環境中，並執行自動化與手動測試.<br />
* 當開發人員發現錯誤時，他們可以在開發環境中進行修正，並將其重新部署至測試環境進行測試與驗證.<br />
* 測試完成後，只需將更新的映像檔推送至生產環境，即可輕鬆將修正程式交付給客戶.<br />
<br />
=== 響應式部署與擴展 ===<br />
Docker基於容器的平台能實現高度可移植的工作負載。Docker容器可在開發者的本地筆記型電腦、資料中心的實體或虛擬機器、雲端服務供應商的環境，或是混合環境中運行.<br />
<br />
Docker 的可移植性與輕量級特性，也使其能輕鬆地動態管理工作負載，並能根據業務需求，近乎即時地擴展或終止應用程式與服務。<br />
<br />
=== 在相同的硬件上運行更多的工作載荷 ===<br />
Docker 輕量且快速。它為基於虛擬管理程式的虛擬機器提供了可行且具成本效益的替代方案，讓您能更充分地利用伺服器容量來達成業務目標。Docker 非常適合高密度環境，以及需要以更少的資源完成更多任務的中小型部署。.<br />
<br />
== Docker 架構 ==<br />
Docker 採用客戶端-伺服器架構。Docker 客戶端與 Docker 守護程式進行通訊，後者負責執行建置、運行及分發 Docker 容器的繁重工作。Docker 客戶端與守護程式可以運行在同一系統上，您也可以將 Docker 客戶端連接到遠端的 Docker 守護程式。Docker 客戶端與守護程式透過 REST API、UNIX 套接字或網路介面進行通訊。另一種 Docker 客戶端是 Docker Compose，它讓您能夠管理由一組容器組成的應用程式.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== Docker 守護進程(daemon) ===<br />
Docker的守護進程 (<code>dockerd</code>) 監聽 Docker API 請求，並管理 Docker 物件，例如映像檔、容器、網路和儲存卷。守護程式亦可與其他守護程式通訊，以管理 Docker 服務.<br />
<br />
=== Docker 客戶端 ===<br />
Docker的客戶端(<code>docker</code>)這是許多Docker使用者與Docker互動的主要方式.當你使用命令如 <code>docker run</code>,客戶端將這些指令傳送至<code>dockerd</code>,它負責執行這些命令.該<code>docker</code>命令使用Docker API跟守護進程通信，Docker客戶端可以與多個守護程式進行通訊。<br />
<br />
=== Docker 桌面版 ===<br />
Docker Desktop是一款適用於Mac、Windows或Linux環境的易於安裝的應用程式，可讓您建立並分享容器化應用程式與微服務。Docker Desktop內建Docker守護程式 (<code>dockerd</code>),Docker客戶端(<code>docker</code>),Docker Compose, Docker Content Trust, Kubernetes, 以及憑證助手。更多詳細的內容請參看Docker Desktop.<br />
<br />
=== Docker registries(註冊) ===<br />
Docker registry用於存放Docker鏡像. Docker Hub是一個開放的註冊服務任何人都可以使用,Docker默認在Docker Hub上尋找鏡像.你甚至可以運行自己的私有註冊服務。<br />
<br />
當你使用<code>docker pull</code>或<code>docker run</code>命令, Docker從您配置的註冊機構拉取所需的鏡像。當您使用<code>docker push</code>命令,Docker推送您的鏡像到您配置的註冊機構。<br />
<br />
=== Docker 對象 ===<br />
當你使用Docker,您就會創建並使用鏡像,容器,網絡,卷,插件,和其他的對象。本節將簡要概述其中部分物件。<br />
<br />
==== 鏡像(映像檔) ====<br />
映像檔是一種只讀範本，其中包含建立Docker容器的指示。通常，映像檔是基於另一個映像檔所建構，並進行了一些額外的客製化。例如，您可以建立一個基於 Ubuntu 映像檔的映像檔，其中包含 Apache 網頁伺服器與您的應用程式，以及讓應用程式正常運作所需的配置細節。<br />
<br />
您可以自行建立映像檔，也可以僅使用他人建立並發佈至註冊機構中的映像檔。若要建立自己的映像檔，您需撰寫一份 Dockerfile，透過簡單的語法定義建立映像檔及執行所需的步驟。Dockerfile 中的每條指令都會在映像中建立一個層。當您修改 Dockerfile 並重新建立映像時，系統只會重新建立那些已變更的層。這正是映像相較於其他虛擬化技術，之所以如此輕量、小巧且快速的原因之一。<br />
<br />
==== 容器 ====<br />
容器是映像的可執行實例。您可以透過 Docker API 或 CLI 來建立、啟動、停止、移動或刪除容器。您可以將容器連接到一個或多個網路、為其掛載儲存空間，甚至可以根據其當前狀態建立新的映像。<br />
<br />
預設情況下，容器與其他容器及其主機之間的隔離程度相當高。您可以控制容器的網路、儲存或其他底層子系統與其他容器或主機之間的隔離程度。<br />
<br />
容器的定義取決於其映像檔，以及您在建立或啟動容器時所提供的任何設定選項。當容器被移除時，任何未儲存於持久儲存裝置中的狀態變更都會消失。<br />
<br />
===== 範例 <code>docker run</code> 命令 =====<br />
如下的命令運行一個<code>ubuntu</code>容器,並交互式的附加到你的本地命令行會話，並運行<code>/bin/bash</code>命令：<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
執行此指令時，將會發生以下情況(假設您使用的是預設的註冊機構設定):<br />
<br />
# 如果您本地沒有<code>ubuntu</code>鏡像,Docker從配置的默認註冊機構拉取該鏡像, 就像您手工運行過<code>docker pull ubuntu</code>命令一樣。<br />
# Docker創建一個新容器,就好像您手工運行過<code>docker container create</code>命令一樣。<br />
# Docker會為容器分配一個可讀寫的檔案系統，作為其最外層。這使得正在運行的容器能夠在其本機檔案系統中建立或修改檔案與目錄。<br />
# Docker會建立一個網路介面，將容器連接到預設網路，由於您未指定任何網路選項。這包括為容器指派一個 IP 位址。預設情況下，容器可透過主機的網路連線連接到外部網路。<br />
# Docker啟動容器並執行<code>/bin/bash</code>。因為該容器是以互動模式執行，並已連接到您的終端會話 (由於使用了 <code>-i</code> 和 <code>-t</code> 標記),您可以透過鍵盤輸入指令，同時Docker會將輸出記錄到您的終端會話上。<br />
# 當您運行<code>exit</code>終止該<code>/bin/bash</code>命令,容器將停止運作，但尚未移除。您可以重新啟動它，或將其移除.<br />
<br />
== 底層技術 ==<br />
Docker 是以 Go 程式語言編寫的，並利用 Linux 核心的多項功能來實現其運作。Docker 採用了一種稱為 <code>namespaces</code> 提供稱為「容器」的隔離工作空間。當您執行一個容器時，Docker會為該容器建立一組命名空間。<br />
<br />
這些命名空間提供了一層隔離機制。容器的每個部分都在獨立的名稱空間中運行，且其存取範圍僅限於該名稱空間。<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=135基礎原理:容器技术/Docker/Architecture2026-05-06T12:25:31Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個基本分離的被稱爲容器的環境進行打包和運行應用程式的能力。這種隔離及安全性可以讓你在同一臺主機上同時運行多個容器。容器是輕量的，並具備運行應用所需的所有依賴，因此，您無需依賴主機上已安裝的軟體。您可以在工作時分享容器，並確保所有接收者都能獲得運作方式完全相同的容器。<br />
<br />
Docker 提供了一套工具和平台，用於管理容器的生命週期:<br />
* 使用容器開發您的應用程式及其相關元件<br />
* 容器成為部署和測試您應用程式的基本單位<br />
* 準備就緒後，請將您的應用程式部署至生產環境，形式可以是容器或經協調的服務. 無論您的生產環境是本地資料中心、雲端服務供應商，還是兩者的混合部署，此方法皆適用.<br />
<br />
== Docker可以用於做什麼？ ==<br />
=== 快速且穩定地交付您的應用程式 ===<br />
Docker透過讓開發人員在標準化環境中使用本地容器來執行應用程式與服務，從而簡化開發生命週期。容器非常適合用於持續整合與持續交付（CI/CD）工作流程。<br />
<br />
請考慮以下範例情境:<br />
<br />
* 您的開發人員在本地編寫程式碼，並透過Docker容器與同事分享工作成果.<br />
* 他們使用Docker將應用程式部署到測試環境中，並執行自動化與手動測試.<br />
* 當開發人員發現錯誤時，他們可以在開發環境中進行修正，並將其重新部署至測試環境進行測試與驗證.<br />
* 測試完成後，只需將更新的映像檔推送至生產環境，即可輕鬆將修正程式交付給客戶.<br />
<br />
=== 響應式部署與擴展 ===<br />
Docker基於容器的平台能實現高度可移植的工作負載。Docker容器可在開發者的本地筆記型電腦、資料中心的實體或虛擬機器、雲端服務供應商的環境，或是混合環境中運行.<br />
<br />
Docker 的可移植性與輕量級特性，也使其能輕鬆地動態管理工作負載，並能根據業務需求，近乎即時地擴展或終止應用程式與服務。<br />
<br />
=== 在相同的硬件上運行更多的工作載荷 ===<br />
Docker 輕量且快速。它為基於虛擬管理程式的虛擬機器提供了可行且具成本效益的替代方案，讓您能更充分地利用伺服器容量來達成業務目標。Docker 非常適合高密度環境，以及需要以更少的資源完成更多任務的中小型部署。.<br />
<br />
== Docker 架構 ==<br />
Docker 採用客戶端-伺服器架構。Docker 客戶端與 Docker 守護程式進行通訊，後者負責執行建置、運行及分發 Docker 容器的繁重工作。Docker 客戶端與守護程式可以運行在同一系統上，您也可以將 Docker 客戶端連接到遠端的 Docker 守護程式。Docker 客戶端與守護程式透過 REST API、UNIX 套接字或網路介面進行通訊。另一種 Docker 客戶端是 Docker Compose，它讓您能夠管理由一組容器組成的應用程式.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== Docker 守護進程(daemon) ===<br />
Docker的守護進程 (<code>dockerd</code>) 監聽 Docker API 請求，並管理 Docker 物件，例如映像檔、容器、網路和儲存卷。守護程式亦可與其他守護程式通訊，以管理 Docker 服務.<br />
<br />
=== Docker 客戶端 ===<br />
Docker的客戶端(<code>docker</code>)這是許多Docker使用者與Docker互動的主要方式.當你使用命令如 <code>docker run</code>,客戶端將這些指令傳送至<code>dockerd</code>,它負責執行這些命令.該<code>docker</code>命令使用Docker API跟守護進程通信，Docker客戶端可以與多個守護程式進行通訊。<br />
<br />
=== Docker 桌面版 ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker 對象 ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== 鏡像 ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== 容器 ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== 底層技術 ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=134基礎原理:容器技术/Docker/Architecture2026-05-05T15:49:40Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個基本分離的被稱爲容器的環境進行打包和運行應用程式的能力。這種隔離及安全性可以讓你在同一臺主機上同時運行多個容器。容器是輕量的，並具備運行應用所需的所有依賴，因此，您無需依賴主機上已安裝的軟體。您可以在工作時分享容器，並確保所有接收者都能獲得運作方式完全相同的容器。<br />
<br />
Docker 提供了一套工具和平台，用於管理容器的生命週期:<br />
* 使用容器開發您的應用程式及其相關元件<br />
* 容器成為部署和測試您應用程式的基本單位<br />
* 準備就緒後，請將您的應用程式部署至生產環境，形式可以是容器或經協調的服務. 無論您的生產環境是本地資料中心、雲端服務供應商，還是兩者的混合部署，此方法皆適用.<br />
<br />
== Docker可以用於做什麼？ ==<br />
=== 快速且穩定地交付您的應用程式 ===<br />
Docker透過讓開發人員在標準化環境中使用本地容器來執行應用程式與服務，從而簡化開發生命週期。容器非常適合用於持續整合與持續交付（CI/CD）工作流程。<br />
<br />
請考慮以下範例情境:<br />
<br />
* 您的開發人員在本地編寫程式碼，並透過Docker容器與同事分享工作成果.<br />
* 他們使用Docker將應用程式部署到測試環境中，並執行自動化與手動測試.<br />
* 當開發人員發現錯誤時，他們可以在開發環境中進行修正，並將其重新部署至測試環境進行測試與驗證.<br />
* 測試完成後，只需將更新的映像檔推送至生產環境，即可輕鬆將修正程式交付給客戶.<br />
<br />
=== 響應式部署與擴展 ===<br />
Docker基於容器的平台能實現高度可移植的工作負載。Docker容器可在開發者的本地筆記型電腦、資料中心的實體或虛擬機器、雲端服務供應商的環境，或是混合環境中運行.<br />
<br />
Docker 的可移植性與輕量級特性，也使其能輕鬆地動態管理工作負載，並能根據業務需求，近乎即時地擴展或終止應用程式與服務。<br />
<br />
=== 在相同的硬件上運行更多的工作載荷 ===<br />
Docker 輕量且快速。它為基於虛擬管理程式的虛擬機器提供了可行且具成本效益的替代方案，讓您能更充分地利用伺服器容量來達成業務目標。Docker 非常適合高密度環境，以及需要以更少的資源完成更多任務的中小型部署。.<br />
<br />
== Docker 架構 ==<br />
Docker 採用客戶端-伺服器架構。Docker 客戶端與 Docker 守護程式進行通訊，後者負責執行建置、運行及分發 Docker 容器的繁重工作。Docker 客戶端與守護程式可以運行在同一系統上，您也可以將 Docker 客戶端連接到遠端的 Docker 守護程式。Docker 客戶端與守護程式透過 REST API、UNIX 套接字或網路介面進行通訊。另一種 Docker 客戶端是 Docker Compose，它讓您能夠管理由一組容器組成的應用程式.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== Docker 守護進程(daemon) ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
<br />
=== Docker 客戶端 ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker 桌面版 ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker 對象 ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== 鏡像 ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== 容器 ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== 底層技術 ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=133基礎原理:容器技术/Docker/Architecture2026-05-05T11:25:22Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個基本分離的被稱爲容器的環境進行打包和運行應用程式的能力。這種隔離及安全性可以讓你在同一臺主機上同時運行多個容器。容器是輕量的，並具備運行應用所需的所有依賴，因此，您無需依賴主機上已安裝的軟體。您可以在工作時分享容器，並確保所有接收者都能獲得運作方式完全相同的容器。<br />
<br />
Docker 提供了一套工具和平台，用於管理容器的生命週期:<br />
* 使用容器開發您的應用程式及其相關元件<br />
* 容器成為部署和測試您應用程式的基本單位<br />
* 準備就緒後，請將您的應用程式部署至生產環境，形式可以是容器或經協調的服務. 無論您的生產環境是本地資料中心、雲端服務供應商，還是兩者的混合部署，此方法皆適用.<br />
<br />
== Docker可以用於做什麼？ ==<br />
=== 快速且穩定地交付您的應用程式 ===<br />
Docker透過讓開發人員在標準化環境中使用本地容器來執行應用程式與服務，從而簡化開發生命週期。容器非常適合用於持續整合與持續交付（CI/CD）工作流程。<br />
<br />
請考慮以下範例情境:<br />
<br />
* 您的開發人員在本地編寫程式碼，並透過Docker容器與同事分享工作成果.<br />
* 他們使用Docker將應用程式部署到測試環境中，並執行自動化與手動測試.<br />
* 當開發人員發現錯誤時，他們可以在開發環境中進行修正，並將其重新部署至測試環境進行測試與驗證.<br />
* 測試完成後，只需將更新的映像檔推送至生產環境，即可輕鬆將修正程式交付給客戶.<br />
<br />
=== 響應式部署與擴展 ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== 在相同的硬件上運行更多的工作載荷 ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker 架構 ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== Docker 守護進程(daemon) ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
<br />
=== Docker 客戶端 ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker 桌面版 ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker 對象 ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== 鏡像 ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== 容器 ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== 底層技術 ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=132基礎原理:容器技术/Docker/Architecture2026-05-05T11:00:09Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個基本分離的被稱爲容器的環境進行打包和運行應用程式的能力。這種隔離及安全性可以讓你在同一臺主機上同時運行多個容器。容器是輕量的，並具備運行應用所需的所有依賴，因此，您無需依賴主機上已安裝的軟體。您可以在工作時分享容器，並確保所有接收者都能獲得運作方式完全相同的容器。<br />
<br />
Docker 提供了一套工具和平台，用於管理容器的生命週期:<br />
* 使用容器開發您的應用程式及其相關元件<br />
* 容器成為部署和測試您應用程式的基本單位<br />
* 準備就緒後，請將您的應用程式部署至生產環境，形式可以是容器或經協調的服務. 無論您的生產環境是本地資料中心、雲端服務供應商，還是兩者的混合部署，此方法皆適用.<br />
<br />
== Docker可以用於做什麼？ ==<br />
<br />
=== 快速且穩定地交付您的應用程式 ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== 響應式部署與擴展 ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== 在相同的硬件上運行更多的工作載荷 ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker 架構 ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== Docker 守護進程(daemon) ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
<br />
=== Docker 客戶端 ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker 桌面版 ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker 對象 ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== 鏡像 ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== 容器 ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== 底層技術 ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=131基礎原理:容器技术/Docker/Architecture2026-05-05T10:59:35Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個基本分離的被稱爲容器的環境進行打包和運行應用程式的能力。這種隔離及安全性可以讓你在同一臺主機上同時運行多個容器。容器是輕量的，並具備運行應用所需的所有依賴，因此，您無需依賴主機上已安裝的軟體。您可以在工作時分享容器，並確保所有接收者都能獲得運作方式完全相同的容器。<br />
<br />
Docker 提供了一套工具和平台，用於管理容器的生命週期:<br />
<br />
* 使用容器開發您的應用程式及其相關元件<br />
* 容器成為部署和測試您應用程式的基本單位<br />
* 準備就緒後，請將您的應用程式部署至生產環境，形式可以是容器或經協調的服務. 無論您的生產環境是本地資料中心、雲端服務供應商，還是兩者的混合部署，此方法皆適用.<br />
<br />
== Docker可以用於做什麼？ ==<br />
<br />
=== 快速且穩定地交付您的應用程式 ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== 響應式部署與擴展 ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== 在相同的硬件上運行更多的工作載荷 ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker 架構 ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== Docker 守護進程(daemon) ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
<br />
=== Docker 客戶端 ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker 桌面版 ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker 對象 ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== 鏡像 ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== 容器 ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== 底層技術 ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=MediaWiki:Common.js&diff=130MediaWiki:Common.js2026-05-05T10:12:36Z<p>Johnson：</p>
<hr />
<div>/* 这里的任何JavaScript将为所有用户在每次页面加载时加载。 */<br />
/*<br />
$(function() {<br />
// 檢查是否為 Timeless 面板且存在目錄和右側欄<br />
var $toc = $('#toc');<br />
var $rightColumn = $('#mw-related-navigation');<br />
<br />
if ($toc.length && $rightColumn.length) {<br />
// 建立一個符合 Timeless 風格的包裝層<br />
var $tocWrapper = $('<div id="p-toc-sidebar" class="sidebar-chunk"></div>');<br />
var $tocTitle = $('<h3>').text($toc.find('.toctitle h2').text() || '目錄');<br />
var $tocInner = $('<div class="sidebar-inner"></div>');<br />
<br />
// 搬移目錄內容<br />
$tocInner.append($toc.find('ul'));<br />
$tocWrapper.append($tocTitle).append($tocInner);<br />
<br />
// 插入到右側欄的最頂端<br />
$rightColumn.prepend($tocWrapper);<br />
<br />
// 隱藏原本在文章頭部的目錄<br />
$toc.remove();<br />
}<br />
});<br />
*/</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=129基礎原理:容器技术/Docker/Architecture2026-05-05T10:09:44Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個大概分離的被稱爲容器的環境打包和運行應用程式的能力<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== Docker可以用於做什麼？ ==<br />
<br />
=== 快速且穩定地交付您的應用程式 ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== 響應式部署與擴展 ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== 在相同的硬件上運行更多的工作載荷 ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker 架構 ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== Docker 守護進程(daemon) ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
<br />
=== Docker 客戶端 ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker 桌面版 ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker 對象 ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== 鏡像 ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== 容器 ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== 底層技術 ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=128基礎原理:容器技术/Docker/Architecture2026-05-05T05:32:18Z<p>Johnson：</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker是一個開發、交付、運行程序的開放的平臺。Docker讓你可以從你的架構中將你的應用分隔(分離)開,讓你可以快速的進行交付。通過Docker,您可以用您平時管理單個應用相同的方式管理您的整個架構。透過運用Docker在程式碼發布、測試及部署方面的方法論，您可以大幅縮短從編寫程式碼到在生產環境中執行之間的延遲。<br />
<br />
== Docker 平臺 ==<br />
Docker提供在一個大概分離的被稱爲容器的環境打包和運行應用程式的能力<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== Docker可以用於做什麼？ ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=127基礎原理:容器技术/Docker/Architecture2026-05-04T17:07:43Z<p>Johnson：/* What is Docker? */</p>
<hr />
<div>= 什麼是Docker？=<br />
Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running it in production.<br />
<br />
== Docker 平臺 ==<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== Docker可以用於做什麼？ ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=126基礎原理:容器技术/Docker/Architecture2026-05-04T17:00:28Z<p>Johnson：</p>
<hr />
<div>= What is Docker? =<br />
Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running it in production.<br />
<br />
== The Docker platform ==<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== What can I use Docker for? ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回：[[基礎原理:容器技术/Docker/Engine|容器引擎]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=125基礎原理:容器技术/Docker/Architecture2026-05-04T16:59:20Z<p>Johnson：</p>
<hr />
<div>= What is Docker? =<br />
Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running it in production.<br />
<br />
== The Docker platform ==<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== What can I use Docker for? ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.<br />
<br />
返回上一级：[[軟件:容器技術|容器技術主頁]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=124基礎原理:容器技术/Docker/Architecture2026-05-04T16:55:55Z<p>Johnson：</p>
<hr />
<div>= What is Docker? =<br />
Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running it in production.<br />
<br />
== The Docker platform ==<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== What can I use Docker for? ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
[[文件:Docker-architecture.png|缩略图|819x819px|docker架構]]<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=123基礎原理:容器技术/Docker/Architecture2026-05-04T16:55:20Z<p>Johnson：/* The Docker daemon */</p>
<hr />
<div>= What is Docker? =<br />
Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running it in production.<br />
<br />
== The Docker platform ==<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== What can I use Docker for? ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
[[文件:Docker-architecture.png|缩略图|838x838px|docker架構]]<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=122基礎原理:容器技术/Docker/Architecture2026-05-04T16:55:00Z<p>Johnson：</p>
<hr />
<div>= What is Docker? =<br />
Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running it in production.<br />
<br />
== The Docker platform ==<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== What can I use Docker for? ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
[[文件:Docker-architecture.png|缩略图|814x814px|docker架構]]<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=121基礎原理:容器技术/Docker/Architecture2026-05-04T16:54:13Z<p>Johnson：</p>
<hr />
<div>= What is Docker? =<br />
Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running it in production.<br />
<br />
== The Docker platform ==<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== What can I use Docker for? ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
[[文件:Docker-architecture.png|缩略图|810x810像素|docker架構]]<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.</div>Johnsonhttps://www.opseas.net/index.php?title=%E6%96%87%E4%BB%B6:Docker-architecture.png&diff=120文件:Docker-architecture.png2026-05-04T16:53:09Z<p>Johnson：</p>
<hr />
<div>docker-architecture</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Architecture&diff=119基礎原理:容器技术/Docker/Architecture2026-05-04T16:47:49Z<p>Johnson：创建页面，内容为“= What is Docker? = Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running…”</p>
<hr />
<div>= What is Docker? =<br />
Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker's methodologies for shipping, testing, and deploying code, you can significantly reduce the delay between writing code and running it in production.<br />
<br />
== The Docker platform ==<br />
Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security let you run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host. You can share containers while you work, and be sure that everyone you share with gets the same container that works in the same way.<br />
<br />
Docker provides tooling and a platform to manage the lifecycle of your containers:<br />
<br />
* Develop your application and its supporting components using containers.<br />
* The container becomes the unit for distributing and testing your application.<br />
* When you're ready, deploy your application into your production environment, as a container or an orchestrated service. This works the same whether your production environment is a local data center, a cloud provider, or a hybrid of the two.<br />
<br />
== What can I use Docker for? ==<br />
<br />
=== Fast, consistent delivery of your applications ===<br />
Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.<br />
<br />
Consider the following example scenario:<br />
<br />
* Your developers write code locally and share their work with their colleagues using Docker containers.<br />
* They use Docker to push their applications into a test environment and run automated and manual tests.<br />
* When developers find bugs, they can fix them in the development environment and redeploy them to the test environment for testing and validation.<br />
* When testing is complete, getting the fix to the customer is as simple as pushing the updated image to the production environment.<br />
<br />
=== Responsive deployment and scaling ===<br />
Docker's container-based platform allows for highly portable workloads. Docker containers can run on a developer's local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.<br />
<br />
Docker's portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.<br />
<br />
=== Running more workloads on the same hardware ===<br />
Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your server capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.<br />
<br />
== Docker architecture ==<br />
Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.<br />
<br />
=== The Docker daemon ===<br />
The Docker daemon (<code>dockerd</code>) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.<br />
<br />
=== The Docker client ===<br />
The Docker client (<code>docker</code>) is the primary way that many Docker users interact with Docker. When you use commands such as <code>docker run</code>, the client sends these commands to <code>dockerd</code>, which carries them out. The <code>docker</code> command uses the Docker API. The Docker client can communicate with more than one daemon.<br />
<br />
=== Docker Desktop ===<br />
Docker Desktop is an easy-to-install application for your Mac, Windows, or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (<code>dockerd</code>), the Docker client (<code>docker</code>), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.<br />
<br />
=== Docker registries ===<br />
A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker looks for images on Docker Hub by default. You can even run your own private registry.<br />
<br />
When you use the <code>docker pull</code> or <code>docker run</code> commands, Docker pulls the required images from your configured registry. When you use the <code>docker push</code> command, Docker pushes your image to your configured registry.<br />
<br />
=== Docker objects ===<br />
When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.<br />
<br />
==== Images ====<br />
An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the Ubuntu image but includes the Apache web server and your application, as well as the configuration details needed to make your application run.<br />
<br />
You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.<br />
<br />
==== Containers ====<br />
A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.<br />
<br />
By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container's network, storage, or other underlying subsystems are from other containers or from the host machine.<br />
<br />
A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that aren't stored in persistent storage disappear.<br />
<br />
===== Example <code>docker run</code> command =====<br />
The following command runs an <code>ubuntu</code> container, attaches interactively to your local command-line session, and runs <code>/bin/bash</code>.<br />
<code>docker run -i -t ubuntu /bin/bash</code><br />
When you run this command, the following happens (assuming you are using the default registry configuration):<br />
<br />
# If you don't have the <code>ubuntu</code> image locally, Docker pulls it from your configured registry, as though you had run <code>docker pull ubuntu</code> manually.<br />
# Docker creates a new container, as though you had run a <code>docker container create</code> command manually.<br />
# Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.<br />
# Docker creates a network interface to connect the container to the default network, since you didn't specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine's network connection.<br />
# Docker starts the container and executes <code>/bin/bash</code>. Because the container is running interactively and attached to your terminal (due to the <code>-i</code> and <code>-t</code> flags), you can provide input using your keyboard while Docker logs the output to your terminal.<br />
# When you run <code>exit</code> to terminate the <code>/bin/bash</code> command, the container stops but isn't removed. You can start it again or remove it.<br />
<br />
== The underlying technology ==<br />
Docker is written in the Go programming language and takes advantage of several features of the Linux kernel to deliver its functionality. Docker uses a technology called <code>namespaces</code> to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.<br />
<br />
These namespaces provide a layer of isolation. Each aspect of a container runs in a separate namespace and its access is limited to that namespace.</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Engine&diff=117基礎原理:容器技术/Docker/Engine2026-05-04T16:42:41Z<p>Johnson：</p>
<hr />
<div>= Docker Engine =<br />
Docker Engine （Docker引擎）是一个用于创建并容器化你的应用程序的开源的集装箱化技术。Docker引擎作为一个客户端-服务器端的应用模式包含如下组件： <br />
<br />
* 一个长时间在后台运行的进程(daemon process)作为服务器端 <code>dockerd</code>.<br />
* 定義了程式可與Docker守護進程通信及控制的APIs接口.<br />
* 一个命令行形式交互接口(CLI)的客户端 <code>docker</code>.<br />
<br />
命令行控制接口(CLI)使用Docker APIs通過編寫腳本或直接輸入命令的方式去控制Docker守護進程及與之交互. 許多其他 Docker 應用程式都使用底層的 API 和 CLI. 該守護程式負責建立和管理Docker物件(對象)，例如映像檔、容器、網路和儲存卷.<br />
<br />
更多細節參看[[基礎原理:容器技术/Docker/Architecture|Docker架構]].<br />
<br />
<div style="display: flex; flex-wrap: wrap;"><br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Install |title=Install Docker Engine |desc=爲您的分發版本安裝Docker引擎.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Storage |title=Storage |desc=在Docker容器中使用持久化數據.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Networking |title=Networking |desc=管理容器之間的網路連線.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Logs |title=Container Logs |desc=瞭解如何檢視和閱讀容器日誌.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Prune |title=Prune |desc=清理未使用的資源.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/daemoncfg |title=Configure the daemon |desc=深入了解 Docker 守護程式的設定選項.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/rootless |title=Rootless mode |desc=以非root權限執行Docker.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/deprecated |title=Deprecated features |desc=了解您應該停止使用Docker Engine的哪些功能.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/release |title=Release notes |desc=最新版本的發行說明.}}<br />
</div><br />
<br />
== Licensing ==<br />
Commercial use of Docker Engine obtained via Docker Desktop within larger enterprises (exceeding 250 employees OR with annual revenue surpassing $10 million USD), requires a paid subscription. Apache License, Version 2.0. See LICENSE for the full license.<br />
[[Category:Docker]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Engine&diff=116基礎原理:容器技术/Docker/Engine2026-05-04T16:35:15Z<p>Johnson：</p>
<hr />
<div>= Docker Engine =<br />
Docker Engine （Docker引擎）是一个用于创建并容器化你的应用程序的开源的集装箱化技术。Docker引擎作为一个客户端-服务器端的应用模式包含如下组件： <br />
<br />
* 一个长时间在后台运行的进程(daemon process)作为服务器端 <code>dockerd</code>.<br />
* 定義了程式可與Docker守護進程通信及控制的APIs接口.<br />
* 一个命令行形式交互接口(CLI)的客户端 <code>docker</code>.<br />
<br />
命令行控制接口(CLI)使用Docker APIs通過編寫腳本或直接輸入命令的方式去控制Docker守護進程及與之交互. 許多其他 Docker 應用程式都使用底層的 API 和 CLI. 該守護程式負責建立和管理Docker物件(對象)，例如映像檔、容器、網路和儲存卷.<br />
<br />
更多細節參看 Docker Architecture.<br />
<br />
<div style="display: flex; flex-wrap: wrap;"><br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Install |title=Install Docker Engine |desc=爲您的分發版本安裝Docker引擎.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Storage |title=Storage |desc=在Docker容器中使用持久化數據.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Networking |title=Networking |desc=管理容器之間的網路連線.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Logs |title=Container Logs |desc=瞭解如何檢視和閱讀容器日誌.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Prune |title=Prune |desc=清理未使用的資源.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/daemoncfg |title=Configure the daemon |desc=深入了解 Docker 守護程式的設定選項.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/rootless |title=Rootless mode |desc=以非root權限執行Docker.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/deprecated |title=Deprecated features |desc=了解您應該停止使用Docker Engine的哪些功能.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/release |title=Release notes |desc=最新版本的發行說明.}}<br />
</div><br />
<br />
== Licensing ==<br />
Commercial use of Docker Engine obtained via Docker Desktop within larger enterprises (exceeding 250 employees OR with annual revenue surpassing $10 million USD), requires a paid subscription. Apache License, Version 2.0. See LICENSE for the full license.<br />
[[Category:Docker]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Engine&diff=115基礎原理:容器技术/Docker/Engine2026-05-04T16:16:21Z<p>Johnson：</p>
<hr />
<div>= Docker Engine =<br />
Docker Engine （Docker引擎）是一个用于创建并容器化你的应用程序的开源的集装箱化技术。Docker引擎作为一个客户端-服务器端的应用模式包含如下组件： <br />
<br />
* 一个长时间在后台运行的进程(daemon process)作为服务器端 <code>dockerd</code>.<br />
* APIs which specify interfaces that programs can use to talk to and instruct the Docker daemon.<br />
* A command line interface (CLI) client <code>docker</code>.<br />
<br />
The CLI uses Docker APIs to control or interact with the Docker daemon through scripting or direct CLI commands. Many other Docker applications use the underlying API and CLI. The daemon creates and manages Docker objects, such as images, containers, networks, and volumes.<br />
<br />
For more details, see Docker Architecture.<br />
<br />
<div style="display: flex; flex-wrap: wrap;"><br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Install |title=Install Docker Engine |desc=爲您的分發版本安裝Docker引擎.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Storage |title=Storage |desc=在Docker容器中使用持久化數據.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Networking |title=Networking |desc=管理容器之間的網路連線.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Logs |title=Container Logs |desc=瞭解如何檢視和閱讀容器日誌.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Prune |title=Prune |desc=清理未使用的資源.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/daemoncfg |title=Configure the daemon |desc=深入了解 Docker 守護程式的設定選項.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/rootless |title=Rootless mode |desc=以非root權限執行Docker.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/deprecated |title=Deprecated features |desc=了解您應該停止使用Docker Engine的哪些功能.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/release |title=Release notes |desc=最新版本的發行說明.}}<br />
</div><br />
<br />
== Licensing ==<br />
Commercial use of Docker Engine obtained via Docker Desktop within larger enterprises (exceeding 250 employees OR with annual revenue surpassing $10 million USD), requires a paid subscription. Apache License, Version 2.0. See LICENSE for the full license.<br />
[[Category:Docker]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Engine&diff=114基礎原理:容器技术/Docker/Engine2026-05-04T16:14:34Z<p>Johnson：</p>
<hr />
<div>= Docker Engine =<br />
Docker Engine （Docker引擎）是一个用于创建并容器化你的应用程序的开源的集装箱化技术。Docker引擎作为一个客户端-服务器端的应用模式包含如下组件： <br />
<br />
* 一个长时间在后台运行的进程(daemon process)作为服务器端 <code>dockerd</code>.<br />
* APIs which specify interfaces that programs can use to talk to and instruct the Docker daemon.<br />
* A command line interface (CLI) client <code>docker</code>.<br />
<br />
The CLI uses Docker APIs to control or interact with the Docker daemon through scripting or direct CLI commands. Many other Docker applications use the underlying API and CLI. The daemon creates and manages Docker objects, such as images, containers, networks, and volumes.<br />
<br />
For more details, see Docker Architecture.<br />
<br />
<br />
== Open source ==<br />
<div style="display: flex; flex-wrap: wrap;"><br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Install |title=Install Docker Engine |desc=爲您的分發版本安裝Docker引擎.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Storage |title=Storage |desc=在Docker容器中使用持久化數據.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Networking |title=Networking |desc=管理容器之間的網路連線.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Logs |title=Container Logs |desc=瞭解如何檢視和閱讀容器日誌.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/Prune |title=Prune |desc=清理未使用的資源.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/daemoncfg |title=Configure the daemon |desc=深入了解 Docker 守護程式的設定選項.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/rootless |title=Rootless mode |desc=以非root權限執行Docker.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/deprecated |title=Deprecated features |desc=了解您應該停止使用Docker Engine的哪些功能.}}<br />
{{NavBox |link=基礎原理:容器技术/Docker/Engine/release |title=Release notes |desc=最新版本的發行說明.}}<br />
</div><br />
<br />
<br />
== Licensing ==<br />
Commercial use of Docker Engine obtained via Docker Desktop within larger enterprises (exceeding 250 employees OR with annual revenue surpassing $10 million USD), requires a paid subscription. Apache License, Version 2.0. See LICENSE for the full license.<br />
[[Category:Docker]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker/Engine&diff=113基礎原理:容器技术/Docker/Engine2026-05-04T15:56:51Z<p>Johnson：</p>
<hr />
<div>= Docker Engine =<br />
Docker Engine （Docker引擎）是一个用于创建并容器化你的应用程序的开源的集装箱化技术。Docker引擎作为一个客户端-服务器端的应用模式包含如下组件： <br />
<br />
* 一个长时间在后台运行的进程(daemon process)作为服务器端 <code>dockerd</code>.<br />
* APIs which specify interfaces that programs can use to talk to and instruct the Docker daemon.<br />
* A command line interface (CLI) client <code>docker</code>.<br />
<br />
The CLI uses Docker APIs to control or interact with the Docker daemon through scripting or direct CLI commands. Many other Docker applications use the underlying API and CLI. The daemon creates and manages Docker objects, such as images, containers, networks, and volumes.<br />
<br />
For more details, see Docker Architecture.<br />
<br />
<br />
== Open source ==<br />
<div style="display: flex; flex-wrap: wrap;"><br />
{{NavBox |link=軟件:容器技術/Docker/Build |title=Docker Build |desc=Build and ship any application anywhere.}}<br />
{{NavBox |link=軟件:容器技術/Docker/Engine |title=Docker Engine |desc=The industry-leading container runtime.}}<br />
{{NavBox |link=軟件:容器技術/Docker/Compose |title=Docker Compose |desc=Define and run multi-container applications.}}<br />
</div><br />
<br />
== AI ==<br />
<div style="display: flex; flex-wrap: wrap;"><br />
{{NavBox |link=軟件:容器技術/AI/Gordon |title=Gordon |desc=Streamline your workflow with your personal AI assistant.}}<br />
{{NavBox |link=軟件:容器技術/AI/DMR |title=Docker Model Runner |desc=View and manage your local models.}}<br />
</div><br />
<br />
<br />
<br />
<br />
== Licensing ==<br />
Commercial use of Docker Engine obtained via Docker Desktop within larger enterprises (exceeding 250 employees OR with annual revenue surpassing $10 million USD), requires a paid subscription. Apache License, Version 2.0. See LICENSE for the full license.<br />
[[Category:Docker]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker&diff=112基礎原理:容器技术/Docker2026-05-04T15:49:52Z<p>Johnson：</p>
<hr />
<div>== 開源開發與容器化技術 ==<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Build |title=Docker Build |desc=在任意地方創建並交付任何軟件}} {{NavBox |link=基礎原理:容器技术/Docker/Engine |title=Docker Engine |desc=業界領先的容器運行時}} {{NavBox |link=軟件:容器技術/Docker/Compose |title=Docker Compose |desc=定義及運行多運行容器應用}} </div><br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Testcontainers |title=Testcontainers |desc=使用您偏好的程式語言，通過程式化方式執行容器.}} {{NavBox |link=軟件:容器技術/Docker/Agent |title=Docker Agent |desc=開源的多代理解決方案，能協助您完成各項任務.}} </div><br />
</div><br />
== Docker AI 工具 ==<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/AI/Gordon |title=Gordon |desc=透過您的個人 AI 助理，簡化您的工作流程.}} {{NavBox |link=軟件:容器技術/AI/DMR |title=Docker Model Runner |desc=檢視及管理您的本機模型.}} {{NavBox |link=軟件:容器技術/AI/MCP_C_T |title=MCP Catalog and Toolkit |desc=透過 MCP 伺服器強化您的 AI 工作流程.}}</div><br />
</div><br />
<!-- 建立隱藏分類，不顯示在正文但頁面被歸類 --> [[index.php?title=分类:容器技術]]<br />
=== 技术分类 ===<br />
* [[基礎原理:容器技术/Docker/Engine|Docker Engine]] (核心运行时)<br />
* [[基礎原理:容器技术/Docker/Build|Docker Build]] (镜像构建)<br />
* 返回上一级：[[軟件:容器技術|容器技術主頁]]<br />
[[index.php?title=分类:容器技术]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker&diff=111基礎原理:容器技术/Docker2026-05-04T15:48:12Z<p>Johnson：</p>
<hr />
<div>== 開源開發與容器化技術 ==<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Build |title=Docker Build |desc=在任意地方創建並交付任何軟件}} {{NavBox |link=基礎原理:容器技术/Docker/Engine |title=Docker Engine |desc=業界領先的容器運行時}} {{NavBox |link=軟件:容器技術/Docker/Compose |title=Docker Compose |desc=定義及運行多運行容器應用}} </div><br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Testcontainers |title=Testcontainers |desc=使用您偏好的程式語言，程式化方式執行容器.}} {{NavBox |link=軟件:容器技術/Docker/Agent |title=Docker Agent |desc=開源的多代理解決方案，能協助您完成各項任務.}} </div><br />
</div><br />
== Docker AI 工具 ==<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/AI/Gordon |title=Gordon |desc=透過您的個人 AI 助理，簡化您的工作流程.}} {{NavBox |link=軟件:容器技術/AI/DMR |title=Docker Model Runner |desc=檢視及管理您的本機模型.}} {{NavBox |link=軟件:容器技術/AI/MCP_C_T |title=MCP Catalog and Toolkit |desc=透過 MCP 伺服器強化您的 AI 工作流程.}}</div><br />
</div><br />
<!-- 建立隱藏分類，不顯示在正文但頁面被歸類 --> [[index.php?title=分类:容器技術]]<br />
=== 技术分类 ===<br />
* [[基礎原理:容器技术/Docker/Engine|Docker Engine]] (核心运行时)<br />
* [[基礎原理:容器技术/Docker/Build|Docker Build]] (镜像构建)<br />
* 返回上一级：[[軟件:容器技術|容器技術主頁]]<br />
[[index.php?title=分类:容器技术]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker&diff=110基礎原理:容器技术/Docker2026-05-04T15:46:45Z<p>Johnson：</p>
<hr />
<div>== 開源開發與容器化技術 ==<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Build |title=Docker Build |desc=在任意地方創建並交付任何軟件}} {{NavBox |link=軟件:容器技術/Docker/Engine |title=Docker Engine |desc=業界領先的容器運行時}} {{NavBox |link=軟件:容器技術/Docker/Compose |title=Docker Compose |desc=定義及運行多運行容器應用}} </div><br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Testcontainers |title=Testcontainers |desc=使用您偏好的程式語言，程式化方式執行容器.}} {{NavBox |link=軟件:容器技術/Docker/Agent |title=Docker Agent |desc=開源的多代理解決方案，能協助您完成各項任務.}} </div><br />
</div><br />
== Docker AI 工具 ==<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/AI/Gordon |title=Gordon |desc=透過您的個人 AI 助理，簡化您的工作流程.}} {{NavBox |link=軟件:容器技術/AI/DMR |title=Docker Model Runner |desc=檢視及管理您的本機模型.}} {{NavBox |link=軟件:容器技術/AI/MCP_C_T |title=MCP Catalog and Toolkit |desc=透過 MCP 伺服器強化您的 AI 工作流程.}}</div><br />
</div><br />
<!-- 建立隱藏分類，不顯示在正文但頁面被歸類 --> [[index.php?title=分类:容器技術]]<br />
=== 技术分类 ===<br />
* [[基礎原理:容器技术/Docker/Engine|Docker Engine]] (核心运行时)<br />
* [[基礎原理:容器技术/Docker/Build|Docker Build]] (镜像构建)<br />
* 返回上一级：[[軟件:容器技術|容器技術主頁]]<br />
[[index.php?title=分类:容器技术]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker&diff=109基礎原理:容器技术/Docker2026-05-04T15:46:02Z<p>Johnson：</p>
<hr />
<div>== Docker 技术文档 ==<br />
本项目致力于 Docker 官方文档的汉化。<br />
<br />
== 開源開發與容器化技術 ==<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Build |title=Docker Build |desc=在任意地方創建並交付任何軟件}} {{NavBox |link=軟件:容器技術/Docker/Engine |title=Docker Engine |desc=業界領先的容器運行時}} {{NavBox |link=軟件:容器技術/Docker/Compose |title=Docker Compose |desc=定義及運行多運行容器應用}} </div><br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Testcontainers |title=Testcontainers |desc=使用您偏好的程式語言，程式化方式執行容器.}} {{NavBox |link=軟件:容器技術/Docker/Agent |title=Docker Agent |desc=開源的多代理解決方案，能協助您完成各項任務.}} </div><br />
</div><br />
== Docker AI 工具 ==<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/AI/Gordon |title=Gordon |desc=透過您的個人 AI 助理，簡化您的工作流程.}} {{NavBox |link=軟件:容器技術/AI/DMR |title=Docker Model Runner |desc=檢視及管理您的本機模型.}} {{NavBox |link=軟件:容器技術/AI/MCP_C_T |title=MCP Catalog and Toolkit |desc=透過 MCP 伺服器強化您的 AI 工作流程.}}</div><br />
</div><br />
<!-- 建立隱藏分類，不顯示在正文但頁面被歸類 --> [[index.php?title=分类:容器技術]]<br />
=== 技术分类 ===<br />
* [[基礎原理:容器技术/Docker/Engine|Docker Engine]] (核心运行时)<br />
* [[基礎原理:容器技术/Docker/Build|Docker Build]] (镜像构建)<br />
* 返回上一级：[[軟件:容器技術|容器技術主頁]]<br />
[[index.php?title=分类:容器技术]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker&diff=108基礎原理:容器技术/Docker2026-05-04T15:44:24Z<p>Johnson：</p>
<hr />
<div>== Docker 技术文档 ==<br />
本项目致力于 Docker 官方文档的汉化。<br />
<br />
== Open source ==<br />
===開源開發與容器化技術===<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Build |title=Docker Build |desc=在任意地方創建並交付任何軟件}} {{NavBox |link=軟件:容器技術/Docker/Engine |title=Docker Engine |desc=業界領先的容器運行時}} {{NavBox |link=軟件:容器技術/Docker/Compose |title=Docker Compose |desc=定義及運行多運行容器應用}} </div><br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Testcontainers |title=Testcontainers |desc=使用您偏好的程式語言，程式化方式執行容器.}} {{NavBox |link=軟件:容器技術/Docker/Agent |title=Docker Agent |desc=開源的多代理解決方案，能協助您完成各項任務.}} </div><br />
</div><br />
== AI == <br />
===所有 Docker AI 工具皆匯集於此，輕鬆取用。===<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/AI/Gordon |title=Gordon |desc=透過您的個人 AI 助理，簡化您的工作流程.}} {{NavBox |link=軟件:容器技術/AI/DMR |title=Docker Model Runner |desc=檢視及管理您的本機模型.}} {{NavBox |link=軟件:容器技術/AI/MCP_C_T |title=MCP Catalog and Toolkit |desc=透過 MCP 伺服器強化您的 AI 工作流程.}}</div><br />
</div><br />
<!-- 建立隱藏分類，不顯示在正文但頁面被歸類 --> [[index.php?title=分类:容器技術]]<br />
=== 技术分类 ===<br />
* [[基礎原理:容器技术/Docker/Engine|Docker Engine]] (核心运行时)<br />
* [[基礎原理:容器技术/Docker/Build|Docker Build]] (镜像构建)<br />
* 返回上一级：[[軟件:容器技術|容器技術主頁]]<br />
[[index.php?title=分类:容器技术]]</div>Johnsonhttps://www.opseas.net/index.php?title=%E5%9F%BA%E7%A4%8E%E5%8E%9F%E7%90%86:%E5%AE%B9%E5%99%A8%E6%8A%80%E6%9C%AF/Docker&diff=107基礎原理:容器技术/Docker2026-05-04T15:42:26Z<p>Johnson：</p>
<hr />
<div>== Docker 技术文档 ==<br />
本项目致力于 Docker 官方文档的汉化。<br />
<div style="display: flex; flex-wrap: wrap; gap: 20px; font-family: sans-serif;"> <br />
== Open source ==<br />
===開源開發與容器化技術===<br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Build |title=Docker Build |desc=在任意地方創建並交付任何軟件}} {{NavBox |link=軟件:容器技術/Docker/Engine |title=Docker Engine |desc=業界領先的容器運行時}} {{NavBox |link=軟件:容器技術/Docker/Compose |title=Docker Compose |desc=定義及運行多運行容器應用}} </div><br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/Docker/Testcontainers |title=Testcontainers |desc=使用您偏好的程式語言，程式化方式執行容器.}} {{NavBox |link=軟件:容器技術/Docker/Agent |title=Docker Agent |desc=開源的多代理解決方案，能協助您完成各項任務.}} </div><br />
== AI == <br />
===所有 Docker AI 工具皆匯集於此，輕鬆取用。===<br />
<div style="display: flex; flex-wrap: wrap;"> {{NavBox |link=軟件:容器技術/AI/Gordon |title=Gordon |desc=透過您的個人 AI 助理，簡化您的工作流程.}} {{NavBox |link=軟件:容器技術/AI/DMR |title=Docker Model Runner |desc=檢視及管理您的本機模型.}} {{NavBox |link=軟件:容器技術/AI/MCP_C_T |title=MCP Catalog and Toolkit |desc=透過 MCP 伺服器強化您的 AI 工作流程.}}</div><br />
<!-- 建立隱藏分類，不顯示在正文但頁面被歸類 --> [[index.php?title=分类:容器技術]]<br />
<br />
</div><br />
=== 技术分类 ===<br />
* [[基礎原理:容器技术/Docker/Engine|Docker Engine]] (核心运行时)<br />
* [[基礎原理:容器技术/Docker/Build|Docker Build]] (镜像构建)<br />
* 返回上一级：[[軟件:容器技術|容器技術主頁]]<br />
[[index.php?title=分类:容器技术]]</div>Johnson