Docker'ı kullanırken temel bir görüntü ile başlıyoruz. Onu başlatırız, değişiklikler yaratırız ve bu değişiklikler başka bir görüntü oluşturan katmanlara kaydedilir.

Sonunda PostgreSQL örneğim için bir görüntü ve web uygulamam için bir görüntü var, değişiklikler devam ediyor.

Konteyner nedir?

Görüntünün bir örneğine kap adı verilir. Açıkladığınız gibi bir katman kümesi olan bir görüntünüz var. Bu görüntüyü başlatırsanız, bu görüntünün çalışan bir kapsayıcısı var. Aynı görüntünün çalışan birçok kapsayıcısı olabilir.

docker imagesÇalışan resimlerinizi ile görebilirsiniz docker ps(ve tüm kapları ile görebilirsiniz docker ps -a).

Yani görüntünün çalışan bir örneği bir kaptır.

Docker Dağıtımlarını Otomatikleştirme ile ilgili makalemden :

Docker Görüntüleri ve Konteynerler

Dockerland'da görüntüler ve konteynerler var . İkisi birbiriyle yakından ilişkili, ancak farklı. Benim için bu ikilemi anlamak Docker'ı son derece açıklığa kavuşturdu.

Görüntü nedir?

Bir görüntü, aslında bir kabın anlık görüntüsü olan inert, değişmez bir dosyadır. Resimler build komutuyla oluşturulur ve run ile başladığında bir kap oluştururlar . Görüntüler gibi bir Docker kayıt defterinde saklanır registry.hub.docker.com . Oldukça büyük olabildikleri için, görüntüler diğer görüntülerin katmanlarından oluşacak şekilde tasarlanır ve böylece ağ üzerinden görüntü aktarılırken minimum miktarda veri gönderilir.

Yerel görüntüler çalıştırılarak listelenebilir 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

Dikkat edilmesi gereken bazı noktalar:

1. IMAGE ID, bir görüntü için gerçek tanımlayıcının ilk 12 karakteridir. Belirli bir görüntünün birçok etiketini oluşturabilirsiniz, ancak kimliklerinin hepsi aynı olacaktır (yukarıdaki gibi).
2. SANAL BOYUT sanaldır, çünkü alttaki tüm katmanların boyutlarını toplar. Bu, bu sütundaki tüm değerlerin toplamının muhtemelen tüm bu görüntüler tarafından kullanılan disk alanından çok daha büyük olduğu anlamına gelir.
3. REPOSITORY sütunundaki değer -t, docker buildkomutun bayrağından veya docker tagvar olan bir görüntüyü -ing'den alır. Sizin için anlamlı bir adlandırma kullanarak görüntüleri etiketlemekte özgürsünüz, ancak docker'ın etiketi bir docker pushveya docker pull.
4. Bir etiketin tam biçimi [REGISTRYHOST/][USERNAME/]NAME[:TAG]. İçin ubuntuyukarıda, REGISTRYHOST olduğu anlaşılmaktadır registry.hub.docker.com. Bu nedenle, adlı my-applicationkayıt defterinde çağırılan resminizi saklamayı planlıyorsanız, docker.example.combu resmi etiketlemelisinizdocker.example.com/my-application .
5. TAG sütunu, tam etiketin yalnızca [: TAG] kısmıdır . Bu talihsiz bir terminolojidir.
6. latestEtiketi basitçe Bir etiket belirtmeyen varsayılan etiketi, büyülü değildir.
7. Etiketlenmemiş resimleriniz yalnızca IMAGE kimlikleriyle tanımlanabilir. Bunlar, <none>ETİKET ve TEKLİF ALACAKTIR. Onları unutmak kolaydır.

Görüntüler hakkında daha fazla bilgi Docker belgelerinden ve sözlüğünden edinilebilir .

Konteyner nedir?

Bir programlama metaforunu kullanmak için, eğer görüntü bir sınıfsa, bir kap bir sınıfın bir örneğidir - bir çalışma zamanı nesnesi. Kapsayıcılar Docker'ı neden kullandığınızdır; uygulamaları çalıştırabileceğiniz bir ortamın hafif ve taşınabilir kapsüllemeleri.

Çalışan yerel konteynerleri şununla görüntüleyin 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

Burada docker kayıt defterinin dockerized bir sürümünü çalıştırıyorum, böylece benim görüntüleri saklamak için özel bir yer var. Yine, dikkat edilmesi gereken bazı şeyler:

1. IMAGE ID gibi, CONTAINER ID de kapsayıcı için gerçek tanımlayıcıdır. Aynı forma sahiptir, ancak farklı bir nesne türünü tanımlar.
2. docker pssadece çalışan kapları çıkarır. İle tüm konteynerleri ( çalışıyor veya durdurulmuş ) görüntüleyebilirsinizdocker ps -a .
3. NAMES, başlatılan bir kapsayıcıyı --namebayrak yoluyla tanımlamak için kullanılabilir .

Görüntü ve kap oluşturmayı önleme

Docker ile ilgili ilk hayal kırıklığımdan biri, etiketsiz görüntülerin ve durdurulmuş kapların görünüşte sürekli birikmesiydi . Bir kaç kez bu birikim, dizüstü bilgisayarımı yavaşlatan veya otomatik inşa boru hattımı durduran maksimum sabit disklerle sonuçlandı. "Her yerde konteyner" hakkında konuşun!

Etiketlenmemiş tüm görüntüleri docker rmison dangling=truesorgu ile birleştirerek kaldırabiliriz :

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

Docker, mevcut kapsayıcıların arkasındaki görüntüleri kaldıramayacak, bu nedenle docker rmönce durdurulan kapsayıcıları kaldırmanız gerekebilir :

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

Bunlar Docker ile bilinen ağrı noktalarıdır ve gelecekteki sürümlerde ele alınabilir. Bununla birlikte, görüntüleri ve kapsayıcıları net bir şekilde anlayarak, bu durumlardan birkaç uygulama ile kaçınılabilir:

1. Daima yararsız, durmuş bir kabı çıkarın docker rm [CONTAINER_ID].
2. Her zaman ile gereksiz, durmuş bir kabın arkasındaki görüntüyü kaldırın docker rmi [IMAGE_ID].

Kolay sözlerle.

Görüntüler -

Kapsayıcı oluşturmak için kullanılan dosya sistemi ve yapılandırma (salt okunur) uygulaması. Daha fazla ayrıntı .

Konteynerler -

Bunlar Docker görüntülerinin çalışan örnekleridir. Kapsayıcılar gerçek uygulamaları çalıştırır. Kapsayıcı bir uygulama ve tüm bağımlılıklarını içerir. Çekirdeği diğer kaplarla paylaşır ve ana işletim sistemindeki kullanıcı alanında yalıtılmış bir işlem olarak çalışır. Daha fazla ayrıntı .

Dikkat edilmesi gereken diğer önemli terimler:

Docker arka plan programı -

Docker kapsayıcılarını oluşturmayı, çalıştırmayı ve dağıtmayı yöneten ana bilgisayarda çalışan arka plan hizmeti.

Docker istemcisi -

Kullanıcının Docker arka plan programı ile etkileşime girmesini sağlayan komut satırı aracı.

Docker Mağazası -

Mağaza, diğer şeylerin yanı sıra, Docker görüntülerinin bir kaydıdır. Kayıt defterini, kullanılabilir tüm Docker görüntülerinin bir dizini olarak düşünebilirsiniz.

Bu blog gönderisinden bir resim bin kelimeye bedeldir.

(Derin anlamak için okuyunuz bu .)

Özet:

• Çekme görüntü bir Dockerfile gelen Docker göbeğine veya Yapı '=> bir Docker resim (düzenlenemez) verir.
• Run image ( docker run image_name:tag_name) => Çalışan bir Image verir (ör. Konteyner (düzenlenebilir))

Bir kapsayıcıyı çalışan bir görüntü olarak düşünmek en basit yöntem olsa da, bu tam olarak doğru değildir .

Görüntü gerçekten bir kaba dönüştürülebilen bir şablondur. Görüntüyü bir konteynere dönüştürmek için Docker motoru görüntüyü alır, üstüne bir okuma-yazma dosya sistemi ekler ve ağ bağlantı noktaları, kapsayıcı adı, kimlik ve kaynak sınırları dahil çeşitli ayarları başlatır. Çalışan bir kapsayıcı şu anda yürütülen bir işleme sahiptir, ancak bir kap da durdurulabilir (veya Docker'ın terminolojisinde çıkılabilir). Çıkılan bir kapsayıcı, yeniden başlatılabileceğinden ve ayarlarını ve tüm dosya sistemi değişikliklerini koruyacağı için bir görüntü ile aynı değildir .

Belki de tüm iş akışını açıklamak yardımcı olabilir.

Her şey Dockerfile ile başlar . Dockerfile, görüntünün kaynak kodudur.

Dockerfile oluşturulduktan sonra, bunu oluşturmak için inşa görüntü . Resim, Dockerfile olan "kaynak kod" un sadece "derlenmiş versiyonu" dur.

Kapsayıcı görüntüsünü aldıktan sonra, kayıt defterini kullanarak yeniden dağıtmanız gerekir . Kayıt defteri Git deposu gibidir - görüntüleri itip çekebilirsiniz.

Ardından, kapsayıcıları çalıştırmak için görüntüyü kullanabilirsiniz . Çalışan bir konteyner birçok yönden sanal bir makineye çok benzer (ancak hipervizör olmadan ).

İş Akışı

Çeşitli komutları ve bunlarla ilişkili giriş ve çıkışları gösteren uçtan uca iş akışı. Bu, bir görüntü ile bir kap arasındaki ilişkiyi netleştirmelidir.

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

Çalıştırabileceğiniz görüntüleri listelemek için yürütün:

docker image ls

Kapsayıcıları listelemek için şu komutları yürütebilirsiniz:

docker ps

Görüntü ve katman kavramını anlayamadımBuradaki tüm soruları okumaya rağmen ve sonunda Docker'ın (duh!) Mükemmel belgelerine tökezledim .

Örnek, tüm konsepti anlamanın anahtarıdır. Uzun bir yazı, bu yüzden netlik elde etmek için gerçekten kavranması gereken anahtar noktaları özetliyorum.

• Resim : Docker görüntüsü bir dizi salt okunur katmandan oluşturulur

• Katman : Her katman, görüntünün Docker dosyasındaki bir talimatı temsil eder.

Example: Aşağıdaki Dockerfile, her biri bir katman oluşturan dört komut içerir.

BAŞLANGIÇ ubuntu: 15.04

KOPYA. / uygulama

RUN markası / uygulaması

CMD python /app/app.py

Önemli olarak , her katman, önceki katmandan yalnızca bir farklar kümesidir.

• Konteyner . Yeni bir kap oluşturduğunuzda , alttaki katmanların üstüne yeni bir yazılabilir katman eklersiniz . Bu katman genellikle “kap katmanı” olarak adlandırılır. Çalışan kapsayıcıda yeni dosyalar yazma, varolan dosyaları değiştirme ve dosyaları silme gibi tüm değişiklikler bu yazılabilir ince kapsayıcı katmanına yazılır.

Bu nedenle, bir kap ve bir görüntü arasındaki en büyük fark yazılabilir üst tabakadır . Kapsayıcıya yeni veriler ekleyen veya var olan verileri değiştiren tüm yazma işlemleri bu yazılabilir katmanda depolanır. Kap silindiğinde, yazılabilir katman da silinir. Altta yatan görüntü değişmeden kalır.

Diskteki boyut perspektifinden görüntüleri ve kapsayıcıları anlama

Çalışan bir kabın yaklaşık boyutunu görüntülemek için docker ps -skomutu kullanabilirsiniz . Sen almak sizeve virtual sizeçıkışların ikisi olarak:

• Boyut: her kabın yazılabilir katmanı için kullanılan veri miktarı (diskte)

• Sanal Boyut: kap tarafından kullanılan salt okunur görüntü verileri için kullanılan veri miktarı. Birden çok kapsayıcı salt okunur görüntü verilerinin bir kısmını veya tamamını paylaşabilir. Dolayısıyla bunlar katkı maddesi değildir. Yani görüntüde diskte ne kadar boyut kullanıldığını hesaplamak için tüm sanal boyutları ekleyemezsiniz

Bir başka önemli kavram da yazarken kopyalama stratejisidir

Bir dosya veya dizin görüntünün alt katmanında varsa ve başka bir katmanın (yazılabilir katman dahil) buna okuma erişimi gerektiriyorsa, yalnızca varolan dosyayı kullanır. Başka bir katmanın dosyayı ilk kez değiştirmesi gerektiğinde (görüntüyü oluştururken veya kapsayıcıyı çalıştırırken), dosya bu katmana kopyalanır ve değiştirilir.

Umarım bu benim gibi birisine yardımcı olur.

Dockerfile → (Derleme) → Görüntü → (Çalıştır) → Kapsayıcı .

• Dockerfile : işletim sisteminizi istediğiniz gibi sağlayan bir dizi Docker talimatı içerir ve tüm yazılımlarınızı yükler / yapılandırır.

• Görüntü : derlenmiş Dockerfile. Her konteyner çalıştırmanız gerektiğinde Dockerfile dosyasını yeniden oluştururken size zaman kazandırır. Bu da tedarik kodunuzu gizlemenin bir yoludur.

• Kapsayıcı : sanal işletim sisteminin kendisi. Buna ssh yazabilir ve gerçek bir ortammış gibi istediğiniz komutları çalıştırabilirsiniz. Aynı görüntüden 1000'den fazla kapsayıcı çalıştırabilirsiniz.

Basitçe söylemek gerekirse, bir görüntü bir sınıfsa , kapsayıcı bir sınıfın örneğidir, bir çalışma zamanı nesnesidir .

Kapsayıcı, yalnızca işletim sistemi OS tarafından hangi kısıtlamaların uygulanacağını bilen bir uygulama (ör. Docker) kullanılarak önceden ayarlanmış bir dizi kısıtlama altında çalıştırılacak yürütülebilir bir ikili dosyadır.

Tipik kısıtlamalar süreç izolasyonu, güvenlikle ilgili ( SELinux kullanımı gibi) korumasını ) ve sistem kaynağıyla ilgili (bellek, disk, CPU ve ağ )dır.

Yakın zamana kadar, yalnızca Unix tabanlı sistemlerde bulunan çekirdekler, yürütülebilir dosyaları katı kısıtlamalar altında çalıştırma yeteneğini destekliyordu. Bu nedenle günümüzde çoğu konteyner konuşması çoğunlukla Linux veya diğer Unix dağıtımlarını içermektedir.

Docker, işletim sistemine (çoğunlukla Linux) çalıştırılabilir bir dosyayı çalıştırmak için hangi kısıtlamaları nasıl söyleyeceğini bilen uygulamalardan biridir. Yürütülebilir dosya yalnızca tarfile olan Docker görüntüsünde bulunur. Bu yürütülebilir dosya genellikle içinde bir veya daha fazla uygulamayı çalıştıracak şekilde yapılandırılmış bir Linux dağıtımının (Ubuntu, CentOS, Debian, vb.) Soyulmuş bir sürümüdür.

Çoğu kişi çalıştırılabilir olarak bir Linux tabanı kullanıyor olsa da, ana bilgisayar işletim sistemi çalıştırabildiği sürece başka bir ikili uygulama olabilir ( çizik kullanarak basit bir temel görüntü oluşturma konusuna bakın ). Docker görüntüsündeki ikili dosya bir işletim sistemi veya sadece bir uygulama olsun, işletim sistemi ana bilgisayarına sadece başka bir işlemdir, önceden ayarlanmış işletim sistemi sınırları tarafından yönetilen bir süreçtir.

Docker gibi diğer uygulamalar, ana bilgisayar işletim sistemine çalışırken bir işleme hangi sınırların uygulanacağını söyleyebilir; bunlar arasında LXC , libvirt ve systemd bulunur . Docker, Linux OS ile dolaylı olarak etkileşim kurmak için bu uygulamaları kullanırdı, ancak şimdi Docker " libcontainer " adlı kendi kütüphanesini kullanarak doğrudan Linux ile etkileşime giriyor .

Konteynerler sadece ne benzer kısıtlı bir modda, yürüttüğü proses edilir Yani chroot'u yapardı.

Docker'ı diğer konteyner teknolojilerinden ayıran IMO, deposu (Docker Hub) ve konteynerlerle çalışmayı son derece kolay hale getiren yönetim araçlarıdır.

Bkz. Docker (yazılım) .

Docker'ın temel konsepti, bu durumda konteyner olarak kabul edilebilecek "makineler" oluşturmayı kolaylaştırmaktır. Kap, yeniden kullanılabilirliğe yardımcı olarak, kapları kolayca oluşturup bırakmanıza olanak tanır.

Görüntüler, zamanın her noktasında bir kabın durumunu gösterir. Temel iş akışı:

1. görüntü oluştur
2. bir konteyner başlat
3. kapta değişiklik yapma
4. kabı tekrar resim olarak kaydet

Birçok cevaplar bu out belirttiği gibi: Sen kurmak Dockerfile bir olsun görüntü ve çalıştırmak görüntüyü de zaten ona kabı .

Ancak, aşağıdaki adımlar Docker resminin ve kapsayıcısının ne olduğu hakkında daha iyi bir fikir edinmeme yardımcı oldu:

1) Dockerfile oluşturun:

docker build -t my_image dir_with_dockerfile

2) Resmi .tardosyaya kaydedin

docker save -o my_file.tar my_image_id

my_file.targörüntüyü saklar. Birlikte açın tar -xvf my_file.tarve tüm katmanları göreceksiniz. Her katmanın derinliklerine inerseniz, her katmanda hangi değişikliklerin eklendiğini görebilirsiniz. (Dockerfile'daki komutlara oldukça yakın olmalıdırlar).

3) Bir kabın içine bakmak için şunları yapabilirsiniz:

sudo docker run -it my_image bash

ve bunun bir işletim sistemi gibi olduğunu görebilirsiniz.

Görüntü OOP'deki bir sınıf tanımına eşdeğerdir ve katmanlar bu sınıfın farklı yöntemleri ve özellikleridir.

Kapsayıcı , bir nesnenin nasıl bir örnekleme veya bir sınıf örneği gibi görüntünün gerçek örneğidir.

Başlangıçta açıklamanın daha iyi olduğunu düşünüyorum.

Komutu çalıştırdığınızı varsayalım docker run hello-world. Ne oluyor?

Bu çağrıları Docker CLI çağırmak için Docker komutları alıp dönüştürmeye sorumlu olduğu Docker sunucu komutları. En kısa sürede Docker sunucu bir çalıştırmak için bir komut alır görüntüyü , bu çekleri hava görüntüleri önbellek bir tutan imajını böyle bir isimle.

Varsayalım ki, merhaba dünya yok. Docker sunucusu Docker Hub'a gider (Docker Hub sadece görüntülerin ücretsiz bir deposudur) ve sorar, hey Hub, adlı bir görüntünüz var hello-worldmı? Hub yanıtları - evet, biliyorum. O zaman bana ver lütfen. Ve indirme işlemi başlar. En kısa sürede Docker görüntü indirilir, Docker sunucu içinde koyar bunu görüntü önbelleği .

Docker görüntülerinin ve Docker kaplarının ne olduğunu açıklamadan önce, bilgisayarınızdaki işletim sistemi ve yazılımın nasıl çalıştırıldığı hakkında bir giriş ile başlayalım.

Örneğin, bilgisayarınızda Chrome'u çalıştırdığınızda, işletim sistemini çağırır, işletim sisteminin kendisi çekirdeği arar ve soruyor, hey ben bu programı çalıştırmak istiyorum. Çekirdek, dosyaları sabit diskinizden çalıştırmayı başarır.

Şimdi iki programınız olduğunu düşünün, Chrome ve Node.js. Chrome'un çalışması için Python sürüm 2 ve Node.js'nin çalışması için Python sürüm 3 gerekir. Bilgisayarınıza yalnızca Python v2 yüklediyseniz, yalnızca Chrome çalıştırılır.

Her iki durumu da çalıştırmak için, bir şekilde ad alanı olarak bilinen bir işletim sistemi özelliğini kullanmanız gerekir. Ad alanı, işlemleri, sabit sürücüyü, ağı, kullanıcıları, ana bilgisayar adlarını vb. İzole etme fırsatı veren bir özelliktir.

Dolayısıyla, bir görüntü hakkında konuştuğumuzda aslında bir dosya sistemi anlık görüntüsünden bahsediyoruz. Bir görüntü , belirli bir inşa etmeye yol tarifi ve meta verileri içeren fiziksel bir dosyadır kabı . Kap kendisi bir örneğidir görüntü ; sabit sürücüyü yalnızca bu kapsayıcı için kullanılabilen ad boşluğunu kullanarak yalıtır . Dolayısıyla kap , kendisine atanan farklı kaynakları gruplayan bir süreç veya süreçler kümesidir.

Docker görüntüsü, uygulamanın çalışması için gereken uygulamayı ve ortamı paketler ve kapsayıcı görüntünün çalışan bir örneğidir.

Resimler, Docker'ın "kaynak kodu" veya "program" ile benzer şekilde paketleme parçasıdır. Kapsayıcılar Docker'ın bir "sürece" benzer yürütme parçasıdır.

Soruda, sadece "program" kısmından bahsediliyor ve görüntü bu. Docker'ın "çalışan" kısmı kapsayıcıdır. Bir kapsayıcı çalıştırıldığında ve değişiklikler yapıldığında, işlem sanki kendi kaynak kodunda bir değişiklik yapar ve onu yeni görüntü olarak kaydeder.

Programlama yönünde olduğu gibi,

Resim kaynak kodudur.

Kaynak kodu ne zaman derlenmiş ve inşa edilir, bu bir uygulama denir.

"Görüntü için bir örnek oluşturulduğunda", buna " kapsayıcı " denir .

Bir görüntü , bir "anlık görüntüsü" olduğunu konteyner . Bir kapsayıcıdan görüntü oluşturabilirsiniz (yeni "anlık görüntüler") ve bir görüntüden yeni kapsayıcılar da başlatabilirsiniz ("anlık görüntüyü" başlatın).

Örneğin, temel bir görüntüden yeni bir kapsayıcı başlatabilir, kapsayıcıda bazı komutları çalıştırabilir ve sonra bunu yeni bir görüntü olarak anlık görüntü alabilirsiniz. Ardından, bu yeni görüntüden 100 konteyner çalıştırabilirsiniz.

Dikkate alınacak diğer şeyler:

• Bir görüntü katmanlardan oluşur ve katmanlar anlık görüntü "diffs" dir (bu nedenle bir görüntüyü ittiğinizde, yalnızca "diff" i kayıt defterine göndermeniz gerekir).
• Dockerfile, temel görüntünün üstünde yeni bir görüntü ("anlık görüntü") ile sonuçlanan yeni katmanlar ("diffs") oluşturan bazı komutları tanımlar.
• Resim etiketleri yalnızca etiket değildir. Görüntünün "tam adı" ("depo: etiketi"). Aynı görüntünün birden fazla adı varsa, bunu yaparken birden çok kez gösterilir docker images.

Buradaki eksik kısmı docker imagesve arasında doldurmak istiyorum containers. Docker , kapsayıcılar için, birden çok dosya sisteminin bir hiyerarşiye monte edilmesini ve tek bir dosya sistemi olarak görünmesini sağlayan bir birleşim dosya sistemi ( UFS ) kullanır . Görüntüdeki dosya sistemi bir read-onlykatman olarak bağlanmıştır ve çalışan kapsayıcıda yapılacak herhangi bir değişiklik bunun read-writeüstüne monte edilmiş bir katman üzerinde yapılır . Bu nedenle, Docker çalışan sistemde yapılan değişiklikleri bulmak için yalnızca en üstteki okuma-yazma katmanına bakmalıdır.

Bir kukla programlama benzetme için, Docker aklınıza gelebilecek geldikleri ImageFactories tutan bir soyut ImageFactory sahiptir mağazada .

Ardından, o ImageFactory'den bir uygulama oluşturmak istediğinizde, yeni bir kapsayıcıya sahip olacaksınız ve istediğiniz gibi değiştirebilirsiniz. DotNetImageFactory değişmez olacaktır, çünkü soyut bir fabrika sınıfı gibi davranır, burada sadece istediğiniz örnekleri sunar.

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

Kısacası:

Kapsayıcı, çekirdekte ortak bir işletim sistemini paylaşan ve bir görüntü (Docker görüntüsü) çalıştıran bir bölümdür (sanal).

Kapsayıcı, kodu çalıştırmak için gerekli tüm bağımlılıkları ve paketleri içeren kendi kendine sürdürülebilir bir uygulamadır.

Docker kapsayıcısı görüntünün bir örneğini çalıştırıyor. Bir görüntüyü bir programla ve bir kapsayıcıyı bir işlemle ilişkilendirebilirsiniz :)

Görüntü, bir nesneye kapsayıcı olarak bir sınıfa aittir.

Kapsayıcı görüntünün bir örneğidir, çünkü nesne bir sınıf örneğidir.

Dockerfile, bir tarball (Docker görüntüsü) üreten Bash betiğiniz gibidir.

Docker kapları tarball'ın çıkarılan versiyonu gibidir. Farklı klasörlerde (kapsayıcılar) istediğiniz kadar kopyaya sahip olabilirsiniz.