도커 이미지와 컨테이너의 차이점은 무엇입니까?

도커 이미지와 컨테이너의 차이점은 무엇입니까?

도커를 사용할 때는 기본 이미지로 시작합니다.이를 부팅하고, 변경 사항을 생성하면 변경 사항이 다른 이미지를 형성하는 레이어에 저장됩니다.

그래서 결국 저는 제 Postgre에 대한 이미지를 갖게 되었습니다.SQL 인스턴스 및 웹 응용 프로그램의 이미지, 변경 사항이 계속 유지됩니다.

용기란 무엇입니까?

이미지의 인스턴스를 컨테이너라고 합니다.당신은 당신이 묘사한 것처럼 레이어의 집합인 이미지를 가지고 있습니다.이 이미지를 시작하면 이 이미지의 실행 중인 컨테이너가 있습니다.동일한 이미지의 실행 중인 컨테이너를 여러 개 가질 수 있습니다.

은 ▁with▁your▁images▁you로 모든 를 볼 수 .docker images실행 중인 컨테이너를 볼 수 있습니다.docker ps (그리고있당모볼수용다습니기를든신은▁(그▁contain▁withers다▁(▁all있니▁see▁you습▁can수볼)가 있는 모든 용기를 볼 수 있습니다.docker ps -a).

따라서 이미지의 실행 중인 인스턴스는 컨테이너입니다.

도커 배포 자동화(아카이브)에 대한 제 기사에서:

도커 이미지 대컨테이너

도커랜드에는 이미지와 컨테이너가 있습니다.그 둘은 밀접하게 관련되어 있지만, 별개입니다.저는 이 이분법을 이해하는 것이 도커를 매우 명확하게 만들었습니다.

이미지란?

이미지는 본질적으로 컨테이너의 스냅샷인 비활성, 불변의 파일입니다.이미지는 build 명령을 사용하여 생성되며, 실행으로 시작하면 컨테이너가 생성됩니다.이미지는 registry.hub.docker.com 과 같은 Docker 레지스트리에 저장됩니다.이미지는 상당히 커질 수 있기 때문에 네트워크를 통해 이미지를 전송할 때 최소한의 데이터를 전송할 수 있도록 다른 이미지의 레이어로 구성되도록 설계되었습니다.

로컬 이미지는 다음을 실행하여 나열할 수 있습니다.docker images:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu                    13.10               5e019ab7bf6d        2 months ago        180 MB
ubuntu                    14.04               99ec81b80c55        2 months ago        266 MB
ubuntu                    latest              99ec81b80c55        2 months ago        266 MB
ubuntu                    trusty              99ec81b80c55        2 months ago        266 MB
<none>                    <none>              4ab0d9120985        3 months ago        486.5 MB

주의할 사항:

1. IMAGE ID는 이미지의 실제 식별자의 처음 12자입니다.지정된 이미지의 태그를 여러 개 만들 수 있지만 ID는 모두 동일합니다(위 참조).
2. 가상 크기는 모든 개별 기본 계층의 크기를 합산하기 때문에 가상입니다.즉, 해당 열의 모든 값 합계가 해당 모든 이미지에 사용되는 디스크 공간보다 훨씬 클 수 있습니다.
3. 은 REPORITORY 열과같습다니에서 .-t의 docker build from 명령, 또에서에서docker tag-기존 이미지를 입력합니다.를 지정할 수 는 의미 ▁a▁▁as▁registry▁you의 레지스트리 합니다.docker push또는docker pull.
4. 는 태의전형태는입니다.[REGISTRYHOST/][USERNAME/]NAME[:TAG].위해서ubuntu는 REGISTERYHOST로 됩니다.registry.hub.docker.com이 그서래만당당신신이계면저라획이라는 이미지를 저장할 이라면,my-application에의 에.docker.example.com당신은 그 이미지에 태그를 붙여야 합니다.docker.example.com/my-application.
5. TAG 열은 [:TAG] 전체 태그의 일부입니다.이것은 유감스러운 용어입니다.
6. 그latest태그는 마법적이지 않습니다. 태그를 지정하지 않을 때 기본 태그일 뿐입니다.
7. 태그가 지정되지 않은 이미지는 이미지 ID로만 식별할 수 있습니다.이것들은 다음을 얻을 것입니다.<none>태그 및 리포지토리.그들에 대해 잊기 쉽습니다.

이미지에 대한 자세한 내용은 Docker 설명서 및 용어집을 참조하십시오.

용기가 뭐죠?

프로그래밍 은유를 사용하려면 이미지가 클래스인 경우 컨테이너는 클래스의 인스턴스인 런타임 개체입니다.컨테이너는 Docker를 사용하는 이유입니다. 컨테이너는 애플리케이션을 실행하는 환경의 가볍고 휴대하기 쉬운 캡슐화입니다.

으로 로컬 실행 docker ps:

CONTAINER ID        IMAGE                               COMMAND                CREATED             STATUS              PORTS                    NAMES
f2ff1af05450        samalba/docker-registry:latest      /bin/sh -c 'exec doc   4 months ago        Up 12 weeks         0.0.0.0:5000->5000/tcp   docker-registry

여기서는 도커화된 버전의 도커화된 레지스트리를 실행하여 이미지를 저장할 수 있습니다.다시 한 번 주의할 점:

1. 이미지 ID와 마찬가지로 컨테이너 ID는 컨테이너의 실제 식별자입니다.그것은 같은 형태를 가지고 있지만, 다른 종류의 물체를 식별합니다.
2. docker ps실행 중인 컨테이너만 출력합니다.모든 컨테이너(실행 중 또는 중지됨)를 볼 수 있습니다.docker ps -a.
3. 를 통해 시작된 컨테이너를 식별하는 데 사용할 수 .--name 깃발

이미지 및 용기 축적을 방지하는 방법

도커에 대한 초기의 불만 중 하나는 태그가 없는 이미지와 정지된 컨테이너의 지속적인 축적이었습니다.이러한 축적으로 인해 하드 드라이브가 최대 용량에 도달하면 노트북 속도가 느려지거나 자동화된 빌드 파이프라인이 중단되는 경우가 몇 번 있었습니다."어디에나 있는 용기"에 대해 말해보세요!

다음을 결합하여 태그가 지정되지 않은 모든 이미지를 제거할 수 있습니다.docker rmi의 근에최와 .dangling=true개요:

docker images -q --filter "dangling=true" | xargs docker rmi

는 기존 할 수해야 할 .docker rm 번째 번째첫:

docker rm `docker ps --no-trunc -aq`

이러한 문제는 Docker에서 알려진 문제점이며 향후 릴리스에서 해결될 수 있습니다.그러나 이미지와 용기를 명확하게 이해하면 다음과 같은 몇 가지 방법으로 이러한 상황을 피할 수 있습니다.

1. 항상 사용하지 않는 정지된 용기를 제거합니다.docker rm [CONTAINER_ID].
2. 항상 사용하지 않는 정지된 용기 뒤에 있는 이미지를 제거합니다.docker rmi [IMAGE_ID].

컨테이너를 실행 중인 이미지로 생각하는 것이 가장 간단하지만 정확하지는 않습니다.

이미지는 실제로 컨테이너로 변환될 수 있는 템플릿입니다.이미지를 컨테이너로 변환하기 위해 Docker 엔진은 이미지를 가져와 맨 위에 읽기-쓰기 파일 시스템을 추가하고 네트워크 포트, 컨테이너 이름, ID 및 리소스 제한을 포함한 다양한 설정을 초기화합니다.실행 중인 컨테이너에는 현재 실행 중인 프로세스가 있지만 컨테이너를 중지하거나 도커 용어로 종료할 수도 있습니다.종료된 컨테이너는 다시 시작할 수 있고 설정 및 파일 시스템 변경 사항을 유지하기 때문에 이미지와 다릅니다.

전체 워크플로우를 설명하는 것이 도움이 될 수 있습니다.

모든 것은 도커 파일로 시작합니다.도커 파일은 이미지의 소스 코드입니다.

도커 파일이 생성되면 이 파일을 빌드하여 컨테이너 이미지를 생성할 수 있습니다.이미지는 도커 파일인 "소스 코드"의 "컴파일된 버전"일 뿐입니다.

컨테이너 이미지가 있으면 레지스트리를 사용하여 컨테이너를 재배포해야 합니다.레지스트리는 Git 저장소와 같습니다. 이미지를 밀고 당길 수 있습니다.

그런 다음 이미지를 사용하여 컨테이너를 실행할 수 있습니다.실행 중인 컨테이너는 여러 측면에서 가상 머신과 매우 유사합니다(하이퍼바이저가 없음).

도커 파일 → (빌드) → 이미지 → (실행) → 컨테이너.

• 도커 파일: 운영 체제를 원하는 방식으로 프로비저닝하고 모든 소프트웨어를 설치/구성하는 도커 명령 집합이 포함되어 있습니다.

• 이미지: 컴파일된 도커 파일입니다.컨테이너를 실행해야 할 때마다 도커 파일을 재구성하는 데 걸리는 시간을 절약합니다.그리고 그것은 당신의 프로비저닝 코드를 숨기는 방법입니다.

• 컨테이너: 가상 운영 체제 자체입니다.실제 환경인 것처럼 SSH를 사용하여 원하는 명령을 실행할 수 있습니다.동일한 이미지에서 1000개 이상의 컨테이너를 실행할 수 있습니다.

워크플로우

다음은 다양한 명령과 관련 입력 및 출력을 보여주는 종단 간 워크플로우입니다.그러면 이미지와 컨테이너 간의 관계가 명확해질 것입니다.

+------------+  docker build   +--------------+  docker run -dt   +-----------+  docker exec -it   +------+
| Dockerfile | --------------> |    Image     | --------------->  | Container | -----------------> | Bash |
+------------+                 +--------------+                   +-----------+                    +------+
                                 ^
                                 | docker pull
                                 |
                               +--------------+
                               |   Registry   |
                               +--------------+

실행할 수 있는 영상을 나열하려면 다음을 실행합니다.

docker image ls

다음에서 명령을 실행할 수 있는 컨테이너를 나열하려면:

docker ps

여기 있는 모든 질문을 읽었음에도 불구하고 이미지와 레이어의 개념을 이해할 수 없었고 결국 도커(duh!)의 이 훌륭한 문서를 우연히 발견했습니다.

그 예는 전체 개념을 이해하는 열쇠입니다.긴 글이기 때문에, 명확성을 얻기 위해 정말로 파악해야 할 핵심 사항들을 정리하고 있습니다.

• 이미지: 도커 이미지는 일련의 읽기 전용 레이어로 구성됩니다.

• 레이어: 각 레이어는 이미지의 도커 파일에 있는 명령을 나타냅니다.

Example아래 도커 파일에는 네 개의 명령이 포함되어 있으며, 각 명령은 계층을 생성합니다.

시작 우분투:15.04

복사. /앱

실행 만들기/앱

CMD python /app/app.py

중요한 것은 각 계층은 이전 계층과의 차이점의 집합일 뿐입니다.

• 컨테이너.새 컨테이너를 생성할 때는 쓰기 가능한 새 계층을 기본 계층 위에 추가합니다.이 계층을 종종 "컨테이너 계층"이라고 합니다.새 파일 쓰기, 기존 파일 수정 및 파일 삭제와 같은 실행 중인 컨테이너의 모든 변경 내용은 이 쓰기 가능한 씬 컨테이너 계층에 기록됩니다.

따라서 컨테이너와 이미지의 주요 차이점은 쓰기 가능한 최상위 계층입니다.새 데이터를 추가하거나 기존 데이터를 수정하는 컨테이너에 대한 모든 쓰기가 이 쓰기 가능 계층에 저장됩니다.컨테이너가 삭제되면 쓰기 가능한 계층도 삭제됩니다.기본 이미지는 변경되지 않은 상태로 유지됩니다.

디스크 크기 관점에서 이미지 및 컨테이너 이해

중인 용기의 실중인용대략크보다사수있다용습니음할을 .docker ps -s지휘권당신은.size그리고.virtual size출력 중 두 개로 표시됩니다.

• 크기: 각 컨테이너의 쓰기 가능 계층에 사용되는 데이터 양(디스크)

• 가상 크기: 컨테이너에서 사용하는 읽기 전용 이미지 데이터에 사용되는 데이터의 양입니다.여러 컨테이너가 일부 또는 모든 읽기 전용 이미지 데이터를 공유할 수 있습니다.따라서 이것들은 첨가제가 아닙니다. 즉, 이미지에서 사용되는 디스크 크기를 계산하기 위해 모든 가상 크기를 추가할 수는 없습니다.

또 다른 중요한 개념은 쓰기 시 복사 전략입니다.

이미지 내 하위 계층에 파일 또는 디렉토리가 있고 다른 계층(쓰기 가능한 계층 포함)에서 해당 계층에 대한 읽기 액세스가 필요한 경우에는 기존 파일만 사용합니다.다른 계층에서 처음으로 파일을 수정해야 하는 경우(이미지를 빌드하거나 컨테이너를 실행할 때) 해당 계층에 파일이 복사되어 수정됩니다.

그것이 저 같은 다른 사람에게 도움이 되기를 바랍니다.

간단히 말해, 이미지가 클래스인 경우 컨테이너는 클래스의 인스턴스이며 런타임 개체입니다.

컨테이너는 호스트 OS에 적용할 제한 사항을 알려주는 방법을 알고 있는 애플리케이션(예: Docker)을 사용하여 미리 설정된 제한 사항 집합에서 호스트 OS에 의해 실행되는 실행 가능한 이진 파일입니다.

일반적인 제한 사항으로는 프로세스 격리 관련, 보안 관련(SELinux 보호 사용 등) 및 시스템 리소스 관련(메모리, 디스크, CPU 및 네트워킹)이 있습니다.

최근까지 유닉스 기반 시스템의 커널만이 엄격한 제한 하에서 실행 파일을 실행할 수 있는 기능을 지원했습니다.그것이 오늘날 대부분의 컨테이너 토크가 대부분 리눅스나 다른 유닉스 배포판과 관련된 이유입니다.

Docker는 실행 파일을 실행해야 하는 제한 사항을 OS(대부분 Linux)에 알려주는 방법을 알고 있는 응용 프로그램 중 하나입니다.실행 파일은 Tar 파일일 뿐인 Docker 이미지에 포함되어 있습니다.이 실행 파일은 일반적으로 하나 이상의 애플리케이션을 실행하도록 미리 구성된 Linux 배포판의 사용자 공간(Ubuntu, CentOS, Debian 등)을 분해한 버전입니다.

대부분의 사람들이 실행 파일로 Linux 기반을 사용하지만 호스트 OS의 커널이 실행할 수 있는 한 다른 이진 응용 프로그램이 될 수 있습니다(스크래치를 사용하여 간단한 기본 이미지 만들기 참조).도커 이미지의 바이너리가 OS 사용자 공간이든 단순히 애플리케이션이든 OS 호스트에게는 사전 설정된 OS 경계에 의해 지배되는 포함된 프로세스인 또 다른 프로세스일 뿐입니다.

Docker와 같이 프로세스가 실행되는 동안 프로세스에 적용할 경계를 호스트 OS에 알려줄 수 있는 다른 애플리케이션으로는 LXC, libvirt 및 systemd가 있습니다.도커는 리눅스 OS와 간접적으로 상호 작용하기 위해 이러한 응용 프로그램을 사용했지만, 현재 도커는 "libcontainer"라는 자체 라이브러리를 사용하여 리눅스와 직접 상호 작용합니다.

따라서 컨테이너는 제한된 모드에서 실행되는 프로세스일 뿐이며, chroot가 수행하던 작업과 비슷합니다.

IMO는 Docker를 다른 컨테이너 기술과 차별화하는 것은 컨테이너 작업을 매우 쉽게 하는 저장소(Docker Hub)와 관리 도구입니다.

도커(소프트웨어)를 참조하십시오.

Docker의 핵심 개념은 컨테이너로 간주될 수 있는 "기계"를 쉽게 만들 수 있도록 하는 것입니다.용기는 재사용이 용이하여 용기를 쉽게 만들고 폐기할 수 있습니다.

이미지는 모든 시점의 컨테이너 상태를 나타냅니다.기본 워크플로우는 다음과 같습니다.

1. 이미지 생성
2. 컨테이너의 시동을 걸다
3. 컨테이너를 변경합니다.
4. 컨테이너를 다시 이미지로 저장

많은 대답들이 이것을 지적했듯이, 당신은 이미지를 얻기 위해 도커 파일을 만들고 이미지를 실행하여 컨테이너를 얻습니다.

그러나 다음 단계를 통해 도커 이미지와 컨테이너가 무엇인지 더 잘 이해할 수 있었습니다.

빌드 도커 파일:

docker build -t my_image dir_with_dockerfile

를 미지저위치에 합니다..tar

docker save -o my_file.tar my_image_id

my_file.tar이미지를 저장합니다.로 엽니다.tar -xvf my_file.tar그러면 모든 층을 볼 수 있습니다.각 계층을 자세히 살펴보면 각 계층에 어떤 변경 사항이 추가되었는지 알 수 있습니다. (도커 파일의 명령과 상당히 가까울 것입니다.)

컨테이너 내부를 보려면 다음을 수행할 수 있습니다.

sudo docker run -it my_image bash

이것이 OS와 매우 유사하다는 것을 알 수 있습니다.

이미지를 컨테이너의 "스냅샷"으로 생각하는 것이 도움이 될 수 있습니다.

컨테이너에서 이미지를 만들 수 있으며(새 "스냅샷") 이미지에서 새 컨테이너를 시작할 수도 있습니다("스냅샷" 인스턴스).예를 들어, 기본 이미지에서 새 컨테이너를 인스턴스화하고, 컨테이너에서 일부 명령을 실행한 다음, 이를 새 이미지로 "스냅샷"할 수 있습니다.그런 다음 새 이미지에서 100개의 컨테이너를 인스턴스화할 수 있습니다.

기타 고려 사항:

• 이미지는 계층으로 구성되고 계층은 스냅샷 "diffs"입니다. 이미지를 푸시하면 "diff"만 레지스트리로 전송됩니다.
• 도커 파일은 기본 이미지 위에 새 레이어("diffs")를 생성하여 새 이미지("스냅샷")를 생성하는 일부 명령을 정의합니다.
• 컨테이너는 항상 이미지에서 인스턴스화됩니다.
• 이미지 태그는 단순한 태그가 아닙니다.이미지의 "전체 이름"("리포지토리:태그")입니다.동일한 이미지에 여러 개의 이름이 있는 경우 다음 작업을 수행할 때 여러 번 표시됩니다.docker images.

이미지는 OOP의 클래스 정의와 동일하며 레이어는 해당 클래스의 다른 메서드 및 속성입니다.

컨테이너는 객체가 인스턴스화 또는 클래스의 인스턴스인 경우와 마찬가지로 이미지의 실제 인스턴스화입니다.

Docker 이미지는 응용 프로그램이 실행하는 데 필요한 응용 프로그램 및 환경을 패키징하며 컨테이너는 이미지의 실행 인스턴스입니다.

이미지는 "소스 코드" 또는 "프로그램"과 유사한 도커의 패킹 부분입니다.컨테이너는 "프로세스"와 유사한 도커의 실행 부분입니다.

질문에서 "프로그램" 부분만 참조되고 이미지가 표시됩니다.도커의 "실행" 부분은 컨테이너입니다.컨테이너가 실행되고 변경되면 프로세스가 자체 소스 코드를 변경하여 새 이미지로 저장하는 것과 같습니다.

저는 처음에 설명하는 것이 더 좋다고 생각합니다.

해 보겠습니다.docker run hello-world어떻게 되는 거지?

도커 명령을 받고 도커 서버 명령을 호출하도록 변환하는 도커 CLI를 호출합니다.Docker 서버는 이미지를 실행하는 명령을 받자마자 이미지 캐시가 해당 이름의 이미지를 보유하고 있는지 확인합니다.

hello-world가 존재하지 않는다고 가정합니다.Docker 서버는 Docker Hub(Docker Hub는 이미지의 무료 저장소일 뿐)로 이동하고 Hub, 당신은 이미지가 있습니까?hello-world허브 응답 - 네, 있습니다.그럼 저에게 주세요.다운로드 프로세스가 시작됩니다.Docker 이미지가 다운로드되면 Docker 서버가 이미지 캐시에 저장합니다.

이제 Docker 이미지와 Docker 컨테이너가 무엇인지 설명하기 전에 컴퓨터의 운영 체제와 소프트웨어 실행 방법에 대한 소개부터 시작하겠습니다.

예를 들어 컴퓨터에서 크롬을 실행하면 운영 체제를 호출하고 운영 체제 자체가 커널을 호출하여 "이 프로그램을 실행하고 싶습니다."라고 묻습니다.커널은 하드 디스크에서 파일을 실행합니다.

이제 Chrome과 Node.js라는 두 가지 프로그램이 있다고 상상해 보십시오.Chrome을 실행하려면 Python 버전 2가 필요하고 Node.js를 실행하려면 Python 버전 3이 필요합니다.컴퓨터에 파이썬 v2만 설치한 경우 크롬만 실행됩니다.

두 가지 경우를 모두 사용하려면 네임스페이스라는 운영 체제 기능을 사용해야 합니다.네임스페이스는 프로세스, 하드 드라이브, 네트워크, 사용자, 호스트 이름 등을 분리할 수 있는 기능입니다.

이미지에 대해 이야기할 때 실제로 파일 시스템 스냅샷에 대해 이야기합니다.이미지는 특정 컨테이너를 구축하기 위한 방향과 메타데이터를 포함하는 물리적 파일입니다.컨테이너 자체는 이미지의 인스턴스이며, 이 컨테이너에만 사용할 수 있는 네임스페이스를 사용하여 하드 드라이브를 분리합니다.따라서 컨테이너는 할당된 서로 다른 리소스를 그룹화하는 프로세스 또는 프로세스 집합입니다.

프로그래밍 측면에서와 마찬가지로,

이미지는 소스 코드입니다.

소스 코드가 컴파일되고 빌드될 때, 그것은 애플리케이션이라고 불립니다.

"이미지에 대한 인스턴스가 생성될 때"와 유사하게 "컨테이너"라고 합니다.

이 사이에 빠진 부분을 채우고 싶습니다.docker images그리고.containersDocker는 컨테이너에 UFS(Union File System)를 사용하므로 여러 파일 시스템을 계층 구조로 마운트하고 단일 파일 시스템으로 표시할 수 있습니다.이미지의 파일 시스템이 다음과 같이 마운트되었습니다.read-only레이어, 그리고 실행 중인 컨테이너에 대한 모든 변경 사항은read-write이 위에 층이 장착되어 있습니다.이 때문에 Docker는 실행 중인 시스템에 대한 변경 사항을 찾기 위해 맨 위의 읽기-쓰기 계층만 보면 됩니다.

저는 다음과 같은 비유로 그것을 말할 것입니다.

+-----------------------------+-------+-----------+
|             Domain          | Meta  | Concrete  |
+-----------------------------+-------+-----------+
| Docker                      | Image | Container |
| Object oriented programming | Class | Object    |
+-----------------------------+-------+-----------+

Docker Client, Server, Machine, Images, Hub, Composes는 모두 컨테이너라고 불리는 것을 만들고 실행하는 생태계가 있는 플랫폼을 형성하기 위해 함께 모이는 프로젝트 도구 소프트웨어 조각입니다.이제 docker run redis 명령을 실행하면 docker CLI라는 것이 Docker Hub라는 것에 도달하여 이미지라는 단일 파일을 다운로드했습니다.

도커 이미지:

이미지는 모든 종속성과 매우 특정한 프로그램을 실행하는 데 필요한 모든 구성을 포함하는 단일 파일입니다. 예를 들어, redis는 방금 다운로드한 이미지(docker run redis 명령 실행을 통해 실행됨)입니다.

이 파일은 하드 드라이브에 저장되는 단일 파일로, 이 이미지를 사용하여 컨테이너라는 것을 만들 수 있습니다.

컨테이너는 이미지의 인스턴스입니다. 컨테이너 자체의 하드웨어 리소스 세트를 사용하여 실행 중인 프로그램과 같다고 생각할 수 있습니다. 따라서 컨테이너 자체의 작은 세트 또는 메모리의 작은 공간에는 네트워킹 기술의 작은 공간과 하드 드라이브의 작은 공간이 있습니다.

이제 다음 명령을 내릴 때 검토하겠습니다: sudo docker run hello-world

위의 명령은 도커 클라이언트 또는 도커 CLI를 시작하고, 도커 CLI는 사용자로부터 명령을 받아 약간의 처리를 한 다음 도커 서버라고 불리는 것으로 명령을 전달하는 것을 담당하며, 도커 서버는 도커 run hello-world, That me 명령을 실행했을 때 무거운 리프팅을 담당합니다우리가 hello world라는 이름을 가진 이미지를 사용하여 새로운 컨테이너를 시작하고 싶었던 개미, hello world 이미지는 그 안에 당신이 단말기에서 보는 메시지를 출력하는 유일한 목적 또는 유일한 일인 작은 프로그램을 가지고 있습니다.

우리가 그 명령을 실행하고 도커 서버로 명령이 전달되었을 때 일련의 작업이 백그라운드에서 매우 빠르게 수행되었습니다.도커 서버에서 hello world라는 이미지를 사용하여 새 컨테이너를 시작하려고 하는 것을 확인했습니다.

도커 서버가 한 첫 번째 작업은 개인 컴퓨터에 hello world 이미지의 복사본이나 hello world 파일과 같은 로컬 복사본이 이미 있는지 확인하는 것이었습니다.그래서 도커 서버는 이미지 캐시라는 것을 조사했습니다.

이제 귀하와 제가 이미지 캐시가 현재 비어 있는 개인 컴퓨터에 도커를 설치했기 때문에 이전에 이미 다운로드한 번 이미지가 없습니다.

그래서 이미지 캐시가 비어 있었기 때문에 도커 서버는 도커 허브라고 불리는 무료 서비스에 접근하기로 결정했습니다.도커 허브는 개인 컴퓨터에서 자유롭게 다운로드하고 실행할 수 있는 무료 공개 이미지 저장소입니다.그래서 도커 서버는 도커 허브에 연락해서 헬로 월드 파일을 다운로드하고 이미지 캐시에 저장했습니다. 이제 도커 허브에서 다시 다운로드하지 않고도 미래의 어느 시점에서 매우 빠르게 다시 실행할 수 있습니다.

그 후 도커 서버는 컨테이너의 인스턴스를 만드는 데 이를 사용하고 컨테이너가 이미지의 인스턴스라는 것을 알고 있습니다. 컨테이너의 유일한 목적은 하나의 매우 특정한 프로그램을 실행하는 것입니다.도커 서버는 기본적으로 이미지 캐시에서 이미지 파일을 가져와 메모리에 로드하여 컨테이너를 생성하고 그 안에서 단일 프로그램을 실행했습니다.그리고 그 단일 프로그램의 목적은 여러분이 보는 메시지를 출력하는 것이었습니다.

컨테이너란 무엇인가: 우선 이미지는 컨테이너를 생성하는 방법에 대한 청사진입니다.

컨테이너는 특별히 할당된 리소스 그룹이 있는 프로세스 또는 프로세스 집합입니다. 아래 다이어그램은 컨테이너에 대해 생각할 때마다 커널에 시스템 호출을 보내는 실행 중인 프로세스가 있을 때마다 커널이 수신되는 시스템 호출을 보고 매우 특정한 부분으로 유도합니다.하드 드라이브, RAM, CPU 또는 기타 필요한 것이 있다면 이러한 각 리소스의 일부를 해당 단일 프로세스에서 사용할 수 있습니다.

이미지는 클래스에 대한 컨테이너로 객체에 대한 것입니다.

컨테이너는 객체가 클래스의 인스턴스인 것처럼 이미지의 인스턴스입니다.

*도커에서 이미지는 도커 앱이 실행되는 데 필요한 소스 코드와 정보를 저장하는 불변 파일입니다.컨테이너와 독립적으로 존재할 수 있습니다.

*도커 컨테이너는 런타임 중에 생성된 가상화 환경이며 실행하려면 이미지가 필요합니다.도커 웹사이트에는 이러한 관계를 보여주는 이미지가 있습니다.

객체가 객체 지향 프로그래밍 언어에서 클래스의 인스턴스인 것처럼 Docker 컨테이너는 Docker 이미지의 인스턴스입니다.

더미 프로그래밍 비유를 들어보면, 도커에는 스토어에서 가져온 이미지 팩토리를 보관하는 추상 이미지 팩토리가 있다고 생각할 수 있습니다.

그런 다음 해당 ImageFactory에서 앱을 만들고자 하면 새 컨테이너가 생기고 원하는 대로 수정할 수 있습니다.DotNetImageFactory는 사용자가 원하는 인스턴스만 제공하는 추상 팩토리 클래스 역할을 하므로 변경되지 않습니다.

IContainer newDotNetApp = ImageFactory.DotNetImageFactory.CreateNew(appOptions);
newDotNetApp.ChangeDescription("I am making changes on this instance");
newDotNetApp.Run();

간단히 말해서:

컨테이너는 공통 OS를 공유하고 이미지(도커 이미지)를 실행하는 커널의 디비전(가상)입니다.

컨테이너는 코드를 실행하는 데 필요한 패키지와 모든 종속성을 함께 포함하는 자체 지속 가능한 응용 프로그램입니다.

도커 컨테이너가 이미지의 인스턴스를 실행하고 있습니다.이미지는 프로그램과, 컨테이너는 프로세스와 연관지을 수 있습니다 :)

Docker 파일은 Tarball(Docker 이미지)을 생성하는 Bash 스크립트와 같습니다.

도커 컨테이너는 타르볼의 추출된 버전과 같습니다.서로 다른 폴더(컨테이너)에 원하는 만큼의 복사본을 저장할 수 있습니다.

이미지는 컨테이너(실행 중인 인스턴스)가 빌드되는 Blueprint입니다.

간단히 말하자면.

도커 이미지:

컨테이너를 만드는 데 사용되는 파일 시스템 및 구성(읽기 전용) 응용 프로그램입니다.

도커 컨테이너:

컨테이너와 이미지의 주요 차이점은 쓰기 가능한 최상위 계층입니다.컨테이너는 쓰기 가능한 최상위 계층이 있는 도커 이미지의 인스턴스를 실행하고 있습니다.컨테이너는 실제 응용프로그램을 실행합니다.컨테이너에는 응용프로그램과 응용프로그램의 모든 종속성이 포함됩니다.컨테이너가 삭제되면 쓰기 가능한 계층도 삭제됩니다.기본 이미지는 변경되지 않은 상태로 유지됩니다.

---

주의해야 할 기타 중요 용어:

도커 데몬:

Docker 컨테이너의 빌드, 실행 및 배포를 관리하는 호스트에서 실행되는 백그라운드 서비스입니다.

도커 클라이언트:

사용자가 도커 데몬과 상호 작용할 수 있는 명령줄 도구입니다.

도커 스토어:

스토어는 무엇보다도 도커 이미지의 레지스트리입니다.레지스트리를 사용 가능한 모든 도커 이미지의 디렉토리로 생각할 수 있습니다.

이 블로그 게시물의 사진은 천 마디의 가치가 있습니다.

요약:.

• 도커 허브에서 이미지를 가져오거나 도커 파일에서 빌드 => 도커 이미지를 제공합니다(편집 불가능).
• 이미지 실행(캐스터 실행 image_name:tag_name) => 실행 중인 이미지, 즉 컨테이너(컨테이너)를 제공합니다.

이미지는 클래스와 같고 컨테이너는 클래스와 같은 개체이므로 이미지처럼 동작하는 컨테이너의 수가 무한합니다.수업은 스스로 아무것도 하지 않는 청사진입니다.프로그램에서 개체의 인스턴스를 만들어야 의미 있는 작업을 수행할 수 있습니다.이미지와 용기도 마찬가지입니다.이미지를 정의한 다음 해당 이미지를 실행하는 컨테이너를 만듭니다.개체가 클래스의 인스턴스이기 때문에 정확히 유사하지는 않지만 컨테이너는 비어 있는 빈 공간과 같아서 이미지를 사용하여 이미지가 말하는 대로 실행 중인 호스트를 구성합니다.

이미지 또는 컨테이너 이미지는 응용 프로그램 코드, 응용 프로그램 런타임, 구성, 종속 라이브러리를 포함하는 파일입니다.이미지는 기본적으로 이 모든 것을 하나의 안전한 불변 장치로 포장합니다.이미지를 빌드하는 데 적절한 도커 명령이 사용됩니다.이미지에 이미지 ID와 이미지 태그가 있습니다.태그는 일반적으로 <docker-user-name>/image-name:tag 형식입니다.

이미지를 사용하여 응용 프로그램 실행을 시작하면 실제로 컨테이너가 시작됩니다.따라서 컨테이너는 이미지를 실행하는 샌드박스입니다.도커 소프트웨어는 이미지와 컨테이너를 모두 관리하는 데 사용됩니다.

이미지는 응용 프로그램 아티팩트, 라이브러리, 구성 및 응용 프로그램 런타임을 포함하는 보안 패키지입니다.컨테이너는 이미지의 런타임 표현입니다.

언급URL : https://stackoverflow.com/questions/23735149/what-is-the-difference-between-a-docker-image-and-a-container