Docker Container Nedir ve Proje Ortamı Nasıl Kurulur?

Docker container, bir uygulamayı çalışması için gereken dosyalar, kütüphaneler ve çalışma ayarlarıyla birlikte izole bir ortamda paketleyip çalıştırmaya yarar. Böylece Python veya Java projesinin yalnızca geliştiricinin bilgisayarında değil, farklı bilgisayarlarda da daha öngörülebilir biçimde çalışması hedeflenir.

Docker kullanmanın temel amacı “bende çalışıyor ama sende çalışmıyor” sorununu azaltmaktır. Farklı işletim sistemi davranışları, Python veya Java sürümleri, kütüphane bağımlılıkları ve eksik kurulumlar projeyi etkileyebilir; container ise bu çalışma ortamını proje ile birlikte tanımlı ve taşınabilir hâle getirir.

Docker Container Nedir? En Kısa ve Anlaşılır Tanım

Docker, bir uygulamanın çalışması için ihtiyaç duyduğu parçaları belirli bir düzen içinde paketlemeye ve çalıştırmaya yarayan bir platformdur. Bu parçalar yalnızca uygulamanın kaynak kodundan ibaret değildir. Kullanılan Python veya Java çalışma ortamı, üçüncü taraf kütüphaneler, ortam değişkenleri, sistem araçları ve uygulamanın nasıl başlatılacağı da bu çalışma düzeninin parçası olabilir.

Container ise bu paketlenmiş çalışma ortamının çalışan hâlidir. Başka bir ifadeyle container, uygulamanın dış dünyadan belirli ölçüde ayrılmış, kendi dosya ve süreç düzenine sahip çalışma birimidir. Uygulama container içinde çalışırken ana bilgisayarın tüm dosya sistemine veya diğer uygulamaların çalışma alanına doğrudan karışmadan görevini sürdürür.

Taşımacılıktaki konteyner benzetmesi ne anlatır?

Docker’daki “container” kelimesi, taşımacılıkta kullanılan standart konteynerlerden esinlenen anlaşılır bir benzetmeye dayanır. Bir ürün, standart bir taşıma konteynerine yerleştirildiğinde farklı gemilerde, kamyonlarda veya limanlarda daha düzenli biçimde taşınabilir. Ürünün her durakta yeniden paketlenmesi gerekmez; taşıma sistemi, konteynerin belirli kurallara göre hazırlanmış olmasına güvenir.

Yazılım container’ı da benzer bir fikir taşır. Uygulama; kaynak kodu, bağımlılıkları ve çalışması için gereken ayarlarla birlikte tanımlı bir ortama alınır. Bu ortam başka bir bilgisayarda çalıştırıldığında geliştiricinin bilgisayarındaki kurulumun birebir kopyası oluşturulmasa bile, projenin ihtiyaç duyduğu çalışma koşulları daha tutarlı biçimde sunulur.

Buradaki amaç, uygulamanın her bilgisayarda hiçbir ek koşul olmadan kesinlikle aynı davranacağını garanti etmek değildir. Ana işletim sistemi, işlemci mimarisi, dosya erişimleri, ağ ayarları ve dış servisler gibi etkenler yine önem taşıyabilir. Ancak proje ortamının elle ve farklı kişiler tarafından ayrı ayrı kurulmasından doğan belirsizlik önemli ölçüde azaltılabilir.

“Bende çalışıyor ama sende çalışmıyor” sorunu nasıl oluşur?

Yeni başlayan geliştiricilerin sık karşılaştığı sorunlardan biri, aynı kodun iki bilgisayarda farklı sonuç vermesidir. Örneğin bir Python projesi geliştiricinin bilgisayarında belirli bir kütüphane sürümüyle çalışırken, başka bir bilgisayarda aynı kütüphanenin farklı bir sürümü kurulmuş olabilir. Bir fonksiyonun davranışı değişebilir, bazı özellikler bulunmayabilir veya beklenmeyen bir hata ortaya çıkabilir.

Benzer durum Java projelerinde de görülebilir. Projenin beklediği Java çalışma ortamı ile bilgisayarda kurulu olan ortam farklıysa derleme veya çalıştırma aşamasında sorun yaşanabilir. İşletim sistemlerinin dosya yollarını ele alma biçimi, büyük-küçük harfe duyarlılık, sistem değişkenleri ve kurulu araçlar da bu farklara eklenebilir.

Bir projenin çalışmasını etkileyebilecek yaygın farklılıklar şunlardır:

• Python, Java veya ilgili çalışma ortamının farklı sürüm ve yapılandırmalara sahip olması,
• Gerekli kütüphanelerden birinin kurulu olmaması,
• Kurulu kütüphanenin projenin beklediğinden farklı bir sürümünün kullanılması,
• İşletim sistemlerindeki dosya yolu ve izin davranışlarının değişmesi,
• Ortam değişkenlerinin geliştiricinin bilgisayarında bulunup başka bilgisayarda bulunmaması,
• Projenin ihtiyaç duyduğu sistem araçlarının veya komut satırı programlarının eksik olması.

Docker bu sorunları tek başına sihirli biçimde çözmez. Bunun yerine geliştiricinin “bu proje hangi ortamda çalışmalı?” sorusunu açıkça tanımlamasını sağlar. Bu tanım daha sonra bir Dockerfile içinde yazılır ve aynı kurallar kullanılarak proje ortamı oluşturulur.

Container tamamen ayrı bir bilgisayar mıdır?

Hayır. Container, sanal bir bilgisayar gibi tam bir fiziksel makineyi taklit etmek zorunda değildir. İçinde uygulamanın çalışması için gerekli dosyalar ve süreçler bulunur; ancak geleneksel bir sanal makinenin yaptığı gibi baştan sona ayrı bir işletim sistemi kurma yaklaşımını kullanmaz.

Bu nedenle container’ı “uygulama için hazırlanmış izole çalışma alanı” şeklinde düşünmek başlangıç için daha doğrudur. Uygulama kendi çalışma alanında çalışır, fakat bu alanın ana sistemle ilişkisi tamamen kesilmiş değildir. Dosya paylaşımı, ağ bağlantısı, port kullanımı ve kaynak sınırları gibi konular ayrıca yapılandırılabilir.

Container ile Sanal Makine Arasındaki Fark Nedir?

Container ile sanal makine benzer bir ihtiyaca cevap verir: uygulamaları ana sistemden belirli ölçüde ayırmak. Ancak bu iki yaklaşımın çalışma biçimi aynı değildir. Günlük hayattan bir benzetmeyle anlatırsak, sanal makine ayrı bir ev gibidir; container ise aynı bina içindeki bağımsız bir daireye benzer.

Ayrı ev benzetmesinde evin kendi altyapısı, odaları ve bağımsız yaşam düzeni bulunur. Sanal makine de kendi işletim sistemiyle birlikte daha kapsamlı ve bağımsız bir ortam oluşturur. Bu yaklaşım farklı bir işletim sistemi çalıştırmak veya uygulamayı ana sistemden daha güçlü biçimde ayırmak gerektiğinde yararlı olabilir.

Aynı binadaki bağımsız daire benzetmesinde ise dairelerin kendi kullanım alanları vardır, fakat binanın ortak altyapısından yararlanırlar. Container da uygulamaya özel dosyaları ve çalışma süreçlerini izole ederken ana sistemin çekirdeğiyle ilişkili biçimde çalışır. Bu, container’ların genellikle daha hafif bir uygulama çalıştırma birimi olarak değerlendirilmesinin temel nedenlerinden biridir.

Container neden daha hafif kabul edilir?

Bir sanal makine çalışırken genellikle kendi işletim sistemi çekirdeğini, sistem servislerini ve sanal donanım katmanlarını da çalıştırır. Bu yapı daha geniş bir izolasyon alanı sunabilir; ancak işletim sisteminin tamamını başlatmak ve yönetmek gerekir.

Container ise çoğunlukla uygulamanın ihtiyaç duyduğu çalışma alanına odaklanır. Örneğin bir Python uygulaması için Python çalışma ortamı, proje dosyaları, bağımlılık listesi ve başlatma komutu tanımlanabilir. Uygulamanın çalışması için gerekmeyen tam bir masaüstü işletim sistemi kurmak zorunlu değildir.

Bu fark, container’ın her durumda sanal makineden daha iyi olduğu anlamına gelmez. Seçim, projenin ihtiyacına bağlıdır. Farklı bir işletim sistemiyle çalışmak, işletim sistemi seviyesinde güçlü bir ayrım oluşturmak veya belirli sistem servislerini birlikte yönetmek gerektiğinde sanal makine daha uygun olabilir. Yalnızca bir Python ya da Java uygulamasının bağımlılıklarını düzenlemek isteyen geliştirici içinse container yaklaşımı daha pratik olabilir.

Docker her projede gerekli midir?

Hayır. Docker, yazılım geliştirmenin zorunlu ilk adımı değildir ve her projeye eklenmesi gereken bir teknoloji gibi düşünülmemelidir. Küçük, tek kişilik ve bağımlılıkları kolay yönetilen bir projede Python sanal ortamı veya doğrudan yerel Java kurulumu yeterli olabilir.

Örneğin yalnızca birkaç dosyadan oluşan basit bir Python alıştırmasında Dockerfile yazmak, image oluşturmak ve container çalıştırmak öğrenme hedefinin önüne geçebilir. Bu durumda öğrencinin önce değişkenler, fonksiyonlar, dosya işlemleri ve hata ayıklama gibi temel konulara odaklanması daha anlamlıdır.

Docker kullanımı şu durumlarda daha mantıklı hâle gelir:

• Projeyi başka bir bilgisayara veya ekip arkadaşına aynı kurulum mantığıyla aktarmak gerektiğinde,
• Birden fazla projede farklı kütüphane veya çalışma ortamı bağımlılıkları bulunduğunda,
• Kurulum adımlarını yazılı ve tekrarlanabilir hâle getirmek istendiğinde,
• Yerel bilgisayara çok sayıda sistem aracı kurmadan kontrollü bir çalışma alanı oluşturmak gerektiğinde,
• Uygulamanın çalışacağı ortama yakın bir geliştirme düzeni hazırlamak istendiğinde.

Yeni başlayanlar için en sağlıklı yaklaşım, Docker’ı önce temel ihtiyaca bağlayarak öğrenmektir. Amaç komutları ezberlemek değil, projenin hangi dosyalara ve bağımlılıklara ihtiyaç duyduğunu düşünerek tanımlayabilmektir. Bu yaklaşım, Docker öğrenmenin yanında genel yazılım geliştirme alışkanlıklarını da güçlendirir.

Image, Container ve Dockerfile Birbirine Nasıl Bağlanır?

Docker’ın temel kavramlarını birbirinden ayırmanın en kolay yolu tarif, kutu ve çalışan ürün benzetmesidir. Dockerfile tarif gibidir: ortamın nasıl kurulacağını anlatır. Image bu tariften hazırlanmış paketlenmiş kutudur. Container ise kutunun açılıp içindeki uygulamanın çalıştırılmış hâlidir.

Bu üç kavram aynı şey değildir. Dockerfile yalnızca kurulum talimatlarını içerir. Image, bu talimatlar uygulanarak oluşturulan çalıştırılabilir kalıptır. Container ise image kullanılarak başlatılan belirli bir çalışma örneğidir.

Dockerfile: Ortamın tarifi

Dockerfile, düz metin biçiminde hazırlanan ve Docker’a ortamı nasıl oluşturacağını anlatan dosyadır. İçinde genellikle şu tür bilgiler bulunur:

• Hangi temel çalışma ortamının kullanılacağı,
• Proje dosyalarının container içine nereye kopyalanacağı,
• Bağımlılıkların hangi dosyadan kurulacağı,
• Uygulamanın hangi komutla başlatılacağı.

Python projesinde bu dosya, örneğin uygulamanın kaynak kodunun ve bağımlılık listesinin nasıl bir araya getirileceğini tarif eder. Java projesinde ise derleme araçları, proje dosyaları ve uygulamanın başlatılma biçimi benzer şekilde tanımlanabilir.

Image: Hazırlanmış çalışma kalıbı

Dockerfile içindeki talimatlar kullanılarak bir image oluşturulur. Image’ı uygulamanın çalışmaya hazır kalıbı olarak düşünebilirsiniz. Bu kalıpta işletim sistemi seviyesindeki gerekli dosyalar, çalışma ortamı, bağımlılıklar ve proje dosyaları için tanımlanmış düzen bulunabilir.

Image doğrudan çalışan bir uygulama değildir. Daha çok, uygulamanın hangi koşullarda çalışacağını taşıyan paketlenmiş bir temel oluşturur. Aynı image’dan birden fazla container başlatılabilir. Her container ayrı bir çalışma örneği olsa da başlangıç noktası aynı image’dır.

Container: Image’ın çalışan örneği

Image çalıştırıldığında container oluşur. Container içinde uygulamanın süreçleri başlar ve tanımlanan komut uygulanır. Örneğin image, bir Python uygulamasını başlatacak şekilde hazırlanmışsa container çalıştırıldığında Python programı yürütülür.

Bu ayrımı şu sorularla hatırlayabilirsiniz:

• Dockerfile nedir? Ortamın nasıl kurulacağını anlatan tarif.
• Image nedir? Dockerfile’dan oluşturulan paketlenmiş çalışma kalıbı.
• Container nedir? Image’ın çalıştırılmış örneği.

Python projesinde akış nasıl ilerler?

Basit bir Python projesini düşünelim. Proje klasöründe uygulama kodunu içeren app.py dosyası ve gerekli kütüphaneleri belirten requirements.txt dosyası bulunsun. Dockerfile ise bu iki dosyanın nasıl kullanılacağını tarif eder.

Öğrencinin izlemesi gereken temel akış şöyledir:

1. Python uygulama dosyası ve bağımlılık dosyası hazırlanır.
2. Dockerfile içine çalışma ortamının kurulma adımları yazılır.
3. Dockerfile kullanılarak bir image build edilir.
4. Oluşturulan image üzerinden bir container run edilir.
5. Uygulamanın çıktısı veya hata mesajları kontrol edilir.

Burada “build etmek”, Dockerfile’daki tarifi uygulayarak image oluşturmak anlamına gelir. “Run etmek” ise image’ı temel alan çalışan bir container başlatmaktır. Bu iki işlem birbirine bağlı olsa da aynı işlem değildir: build hazırlık aşamasıdır, run ise hazırlanan kalıbın çalıştırılmasıdır.

Bu zinciri öğrenirken proje dosyalarının ne yaptığını da anlamak gerekir. Dockerfile, eksik veya yanlış bir uygulamayı düzeltmez. Kodda hata varsa container içinde de hata alınabilir; eksik bağımlılık tanımlanmışsa image oluşturma veya uygulamayı başlatma sırasında sorun yaşanabilir.

Bu nedenle Docker öğrenmek, temel programlama bilgisinin yerine geçmez. Önce dosyaların, bağımlılıkların ve çalışma komutunun ne işe yaradığını anlamak; ardından bunları bir container ortamında düzenlemek daha sağlam bir öğrenme sırası oluşturur. Python temellerini yapılandırılmış biçimde çalışmak isteyenler için asenkron Python dersleri kapsamında proje dosyaları, bağımlılık mantığı ve çalışma adımları birlikte ele alınabilir.

Akış neden “Dockerfile → image → container” şeklindedir?

Bu sıralama, tarif ile ürün arasındaki ilişkiyi gösterir. Dockerfile değişirse aynı proje için yeni bir image oluşturulabilir. Image değişmeden yeniden container başlatılabilir. Container silinse bile image korunuyorsa aynı kalıptan yeni bir container üretmek mümkün olabilir.

Örneğin bir Python projesine yeni bir kütüphane eklendiğinde yalnızca container’ı yeniden çalıştırmak yeterli olmayabilir. Önce bağımlılık tanımının ve Dockerfile’ın projedeki değişikliği yansıtacak şekilde değerlendirilmesi, ardından yeni image oluşturulması gerekir. Sonraki container çalıştırma işlemi bu güncellenmiş image üzerinden yapılır.

Bu bakış açısı, Docker komutlarını rastgele denemek yerine aralarındaki mantığı kavramayı sağlar: Dockerfile ortamı tanımlar, image ortamı paketler, container ortamı çalıştırır.

Basit Bir Python Projesi İçin Dockerfile Nasıl Yazılır?

Dockerfile, bir projenin hangi temel ortamla başlayacağını, dosyaların container içine nereye kopyalanacağını ve container başlatıldığında hangi komutun çalışacağını tanımlayan metin dosyasıdır. Basit bir Python projesinde Dockerfile kullanmanın amacı, Python dosyasını farklı bilgisayarlarda benzer bir çalışma ortamı içinde başlatabilmektir.

Bu örnekte Dockerfile ile app.py dosyası aynı klasörde bulunur. app.py çalıştırıldığında terminale basit bir mesaj yazdırdığı varsayılır. Örneğin dosyanın içinde print("Merhaba, Docker!") satırı yer alabilir.

# Python temel imajını seçer
FROM python:3

# Container içindeki çalışma klasörünü belirler
WORKDIR /app

# Uygulama dosyasını image içine kopyalar
COPY app.py .

# Container başlayınca Python dosyasını çalıştırır
CMD ["python", "app.py"]

FROM python:3 satırı, Docker image oluşturulurken başlangıç noktası olarak Python içeren temel bir imaj seçer. Temel imaj, işletim sistemi bileşenleri ve Python çalıştırma ortamı gibi hazır parçaları içerir. Böylece Python’u container içinde ayrıca kurmak yerine mevcut temel ortamdan yararlanılır.

Buradaki python:3 ifadesi örnek bir etiket kullanır. Gerçek projelerde ekip, kullandığı Python sürümünü ve bağımlılıklarını açıkça belirleyerek daha öngörülebilir bir ortam oluşturabilir. Ancak yalnızca tek dosyalık bir başlangıç çalışması için temel imajı seçme fikrini anlamak yeterlidir.

WORKDIR /app satırı, container içindeki çalışma klasörünü /app olarak belirler. Bundan sonra yazılan göreli dosya yolları bu klasöre göre değerlendirilir. Çalışma klasörü belirlenmezse dosyaların container içinde hangi dizinde bulunduğunu takip etmek zorlaşabilir ve komutlar gereksiz biçimde uzun hâle gelebilir.

Bu satır, bilgisayarınızdaki proje klasörünü doğrudan değiştirmez. Sadece image oluşturulduktan ve container başlatıldıktan sonra container’ın kendi içindeki çalışma konumunu tanımlar. Host bilgisayar ile container dosya sistemi birbirinden ayrı düşünülebilir.

COPY app.py . komutu, bilgisayardaki app.py dosyasını image içine kopyalar. Komutun ilk bölümü kopyalanacak kaynak dosyayı, nokta ile gösterilen ikinci bölüm ise hedef konumu belirtir. Daha önce WORKDIR /app yazıldığı için dosya container içinde /app/app.py konumuna yerleşir.

Docker image oluşturulurken yalnızca temel Python ortamı hazır bulunmaz; uygulamanın çalışması için gerekli proje dosyaları da image içine eklenmelidir. COPY satırı olmazsa container içinde çalıştırılacak app.py dosyası bulunmayabilir.

CMD ["python", "app.py"] satırı, container başlatıldığında varsayılan olarak çalıştırılacak komutu tanımlar. Bu komut Python yorumlayıcısını kullanarak app.py dosyasını çalıştırır. Dosyada bir print() komutu varsa üretilen mesaj container’ın terminal çıktısında görünür.

CMD satırı image oluşturulurken uygulamayı çalıştırmaz. Image yalnızca hazırlanır. Uygulamanın çalışması, bu image kullanılarak bir container başlatıldığında gerçekleşir. Bu ayrım önemlidir: build aşaması image üretir, run aşaması ise bu image’dan çalışan container oluşturur.

Python’un dosya yapısı, değişkenleri, fonksiyonları ve bağımlılık yönetimi henüz netleşmediyse Dockerfile yazmak tek başına sorunu çözmez. Önce dilin ve projenin nasıl çalıştığını anlamak, ardından container yaklaşımını eklemek daha sağlıklı bir öğrenme sırası oluşturur. Bu temel için birebir Python dersleri kapsamında dosya yapısı ve uygulama çalıştırma mantığı üzerine ilerlemek yararlı olabilir.

Bu örnekte requirements.txt bulunmadığı için ayrıca paket kurulumu yapılmaz. Proje dış kütüphaneler kullanmaya başladığında Dockerfile’a bağımlılık dosyasını kopyalama ve paketleri kurma adımları eklenebilir. Örneğin Flask, requests veya başka bir kütüphane kullanılıyorsa, yalnızca app.py dosyasını kopyalamak uygulamanın çalışması için yeterli olmayabilir.

Docker Image Build Etme ve Container Çalıştırma Adımları

Dockerfile ile app.py dosyasını aynı proje klasörüne yerleştirdikten sonra image oluşturabilir ve bu image’dan container çalıştırabilirsiniz. Aşağıdaki örnekte terminalin proje klasöründe açıldığı varsayılır.

1. Terminalde Dockerfile ve app.py dosyalarının bulunduğu proje klasörüne geçin.
2. docker build -t basit-python-uygulamasi . komutuyla image oluşturun.
3. docker run --rm basit-python-uygulamasi komutuyla container’ı çalıştırın.

İlk adımda amaç, Docker komutunun gerekli dosyaları bulabileceği klasörde olmaktır. Terminalde kullanılan klasör, Docker’ın işlem bağlamı olarak değerlendirilir. Bu nedenle komutu başka bir dizinde çalıştırırsanız Dockerfile veya app.py bulunamayabilir.

İkinci adımda kullanılan docker build komutu Dockerfile’daki talimatları sırayla uygulayarak bir image üretir. -t seçeneği image’a okunabilir bir etiket vermek için kullanılır. Buradaki basit-python-uygulamasi adı yalnızca örnektir; kendi projenize daha açıklayıcı bir isim verebilirsiniz.

Komutun sonundaki nokta, Dockerfile’ın ve image oluşturma sırasında kullanılacak dosyaların mevcut klasörde bulunduğunu belirtir. Nokta yazılmadığında Docker hangi klasördeki dosyaları işlem bağlamı olarak kullanacağını bilemeyebilir. Build işlemi başarılı olduğunda terminalde image’ın oluşturulduğunu belirten bir çıktı görürsünüz.

Üçüncü adımda docker run komutu, belirtilen image’ı kullanarak yeni bir container başlatır. basit-python-uygulamasi burada çalıştırılacak image etiketidir. Container başladığında Dockerfile içindeki CMD komutu devreye girer ve python app.py çalışır.

--rm seçeneği, container durduktan sonra bu geçici container kaydının otomatik olarak kaldırılmasını sağlar. Bu seçenek özellikle kısa denemelerde gereksiz durmuş container’ların birikmesini önler. Image silinmez; yalnızca o çalıştırma için oluşturulan container kaldırılır.

Terminalde Merhaba, Docker! gibi bir mesaj görmeniz, temel akışın doğru çalıştığını gösterir. Bu çıktı şu adımların tamamlandığı anlamına gelir:

• Image oluşturulmuştur.
• app.py image içine kopyalanmıştır.
• Container başlatılmıştır.
• CMD komutu Python dosyasını çalıştırmıştır.
• Python programı terminale çıktı üretmiştir.

Image oluşturma sırasında hata alırsanız önce Dockerfile dosyasının adını ve konumunu, ardından app.py dosyasının aynı klasörde bulunup bulunmadığını kontrol edin. Container başladıktan sonra hata alırsanız CMD satırını, Python dosyasındaki yazım hatalarını ve uygulamanın ihtiyaç duyduğu ek paketleri inceleyin.

Docker Kullanmak Ne Zaman Mantıklı, Ne Zaman Gereksizdir?

Docker, her Python veya Java projesinde ilk günden kullanılması gereken zorunlu bir katman değildir. Değeri, çoğunlukla projenin çalışma ortamını başka kişilerle paylaşma, bağımlılıkları birbirinden ayırma ve aynı uygulamayı farklı bilgisayarlarda daha tutarlı biçimde çalıştırma ihtiyacı ortaya çıktığında anlaşılır.

Docker kullanmanın anlamlı olduğu durumlar

Bir ekipte herkesin aynı Python, Java veya kütüphane ortamını kullanması gerekiyorsa Docker pratik bir çözüm sunabilir. Bir kişinin bilgisayarında çalışan projenin başka bir bilgisayarda çalışmaması çoğu zaman işletim sistemi, paket sürümü, ortam değişkeni veya eksik kurulum farklarından kaynaklanır. Container yaklaşımı bu farklılıkların bir bölümünü proje tanımının içine almayı sağlar.

• Birden fazla bağımlılık varsa: Proje belirli paketlere, sistem araçlarına veya çalışma zamanı ayarlarına ihtiyaç duyuyorsa ortamın tanımlı olması kolaylık sağlar.
• Projeyi başka bilgisayarda çalıştırma ihtiyacı varsa: Yeni bir ekip üyesi, aynı yapılandırmayı takip ederek projeye daha hızlı yaklaşabilir.
• Projeler birbirinden ayrılmalıysa: Bir projedeki paket veya sürüm değişikliğinin başka bir projeyi etkilemesini azaltmak için ayrı container ortamları kullanılabilir.
• Kurulum adımları tekrarlanacaksa: Image oluşturma talimatları Dockerfile’da saklandığı için ortamın nasıl hazırlandığı yazılı hâle gelir.

Örneğin bir projede belirli Python paketleri, bir veritabanı bağlantısı ve işletim sistemine ait bazı araçlar birlikte gerekiyorsa, kurulumun yalnızca sözlü anlatılması yerine ortamın dosyalarla tanımlanması daha anlaşılır olabilir. Aynı durum Java projelerinde Maven veya Gradle yapılandırmasıyla çalışan uygulamalar için de geçerlidir; yine de container kullanımı projenin gereksinimine göre değerlendirilmelidir.

Docker kullanmanın gereksiz yük oluşturabileceği durumlar

Tek dosyalık bir Python alıştırmasında veya yalnızca değişken, koşul, döngü ve fonksiyon öğrenilen kısa çalışmalarda doğrudan yerel Python ortamını kullanmak daha anlaşılır olabilir. Bu aşamada öğrencinin asıl hedefi kodun nasıl çalıştığını kavramaktır. Dockerfile, image ve container kavramlarını aynı anda öğrenmek, temel konunun önüne geçebilir.

• Yalnızca kısa süreli bir sözdizimi alıştırması yapıyorsanız, yerel çalıştırma genellikle yeterlidir.
• Projenin dış bağımlılığı yoksa, container katmanı başlangıçta ek işlem oluşturabilir.
• Docker’ın kendisini öğrenmek mevcut öğrenme hedefinizi desteklemiyorsa, bu konuyu sonraki aşamaya bırakabilirsiniz.
• Henüz dosya yolları, terminal kullanımı ve paket kurulumu anlaşılmadıysa önce bu temelleri oturtmak daha verimlidir.

Karar vermek için kısa kontrol listesi

Aşağıdaki sorulara vereceğiniz cevap, Docker’ın projeniz için gerçekten gerekli olup olmadığını anlamanıza yardımcı olabilir:

• Projede birden fazla bağımlılık var mı?
• Aynı ortamı başka kişilerle paylaşacak mıyım?
• Kurulum hatasını tekrarlanabilir hâle getirmem gerekiyor mu?
• Proje farklı bilgisayarlarda veya farklı işletim sistemlerinde çalıştırılacak mı?
• Yerel ortamımda bir projeye yaptığım değişikliğin diğer projeleri etkilemesini önlemek istiyor muyum?
• Docker’ı öğrenmek şu anki hedefimi destekliyor mu?

İlk üç sorunun çoğuna “evet” yanıtı veriyorsanız Docker anlamlı bir seçenek olabilir. Tüm yanıtlar “hayır” ise doğrudan yerel ortamda çalışmaya devam etmek daha sade bir başlangıç sağlayabilir. Buradaki amaç Docker kullanmış olmak değil, projenin ihtiyaç duyduğu ortamı anlaşılır ve sürdürülebilir biçimde kurmaktır.

Python veya Java temeli zayıf olan bir öğrencinin önce dil bilgisi, dosya yapısı, terminal kullanımı ve bağımlılık yönetimini anlaması; daha sonra image ve container yaklaşımını öğrenmesi genellikle daha sağlıklı bir sıradır. Docker, temel programlama bilgisinin yerine geçmez. Yalnızca uygulamanın çalıştığı ortamı tanımlama ve ayırma konusunda yardımcı olur.

Docker’ın kapsamı büyüdükçe Kubernetes, çoklu servis mimarileri, microservice mesh veya CI/CD pipeline gibi ileri başlıklarla kesişebilir. Ancak basit bir Python dosyasını container içinde çalıştırmak için bu konulara girmeniz gerekmez. İlk aşamada Dockerfile yazmak, image oluşturmak, container çalıştırmak ve terminal çıktısını yorumlamak yeterli bir öğrenme hedefidir.

İlk Container Denemesi İçin Kontrol Listesi

İlk Docker denemesinde sorun yaşadığınızda her şeyi baştan değiştirmek yerine hatayı sırayla daraltın. En pratik teşhis akışı; önce dosyaların doğru klasörde olup olmadığını, ardından image içine kopyalanıp kopyalanmadığını, build işleminin tamamlanıp tamamlanmadığını ve son olarak container çıktısını kontrol etmektir.

1. Dockerfile ve proje dosyalarını kontrol edin

Öncelikle terminalde bulunduğunuz klasörün gerçekten proje klasörü olduğundan emin olun. Dockerfile, Python dosyanız ve varsa bağımlılık dosyanız genellikle aynı build bağlamında bulunmalıdır. Örneğin docker build komutunun sonunda kullanılan . işareti, mevcut klasörün Docker'a gönderilen çalışma alanı olduğunu belirtir.

Dockerfile farklı bir klasördeyse veya build komutunu yanlış dizinde çalıştırıyorsanız Docker dosyayı bulamayabilir. Dosya adının yanlışlıkla Dockerfile.txt olarak kaydedilmesi de özellikle yeni başlayanlarda görülen bir sorundur.

2. Uygulama dosyasının image içine kopyalandığını doğrulayın

Dockerfile içindeki COPY satırı, bilgisayarınızdaki dosyaların image oluşturulurken image dosya sistemine alınmasını sağlar. Python dosyanız örneğin app.py adını taşıyorsa, bu dosyanın Dockerfile'da kullanılan kaynak yoluyla gerçekten eşleştiğini kontrol edin.

Dosyanın adı main.py olduğu hâlde Dockerfile içinde COPY app.py . yazıyorsa build işlemi başarısız olabilir. Bazı durumlarda dosya image içine alınsa bile CMD veya ENTRYPOINT satırında farklı bir dosya çalıştırıldığı için container hemen kapanabilir.

3. Build sırasında oluşan hatayı en üstten değil, ilk hatadan itibaren okuyun

docker build sırasında hata aldıysanız çıktının yalnızca son satırına bakmayın. Asıl neden çoğu zaman daha yukarıdaki ilk hata mesajında görünür. Eksik dosya, hatalı paket adı, geçersiz Dockerfile komutu veya Python bağımlılığının kurulamadığına ilişkin mesajlar farklı çözüm gerektirir.

Build başarıyla tamamlanmadan container çalıştırmaya geçmeyin. Başarılı bir build işleminden sonra image'ın oluştuğunu docker images komutuyla kontrol edebilirsiniz. Bu aşamada kullandığınız image adının ve etiketinin, sonraki docker run komutuyla aynı olduğundan emin olun.

4. Run komutunda image adını ve başlangıç komutunu kontrol edin

Container çalıştırırken yazdığınız image adı, build sırasında verdiğiniz adla birebir aynı olmalıdır. Örneğin image'ı python-deneme adıyla oluşturduysanız docker run python-proje komutu farklı bir image arar.

Container başladıktan hemen sonra kapanıyorsa bu her zaman Docker'ın bozuk olduğu anlamına gelmez. Container'ın ana işlemi tamamlanmış olabilir. Basit bir Python programı ekrana bir sonuç yazıp sonlandığında container da doğal olarak durur. Böyle bir durumda son çıktıyı görmek için container loglarını inceleyebilir, örneğin docker logs <container_adı_veya_id> komutunu kullanabilirsiniz.

5. “Bende çalışıyordu” sorununu bağımlılıkları belgeleyerek azaltın

Docker çalışma ortamını daha tekrarlanabilir hâle getirmeye yardımcı olur; ancak hangi paketlerin gerektiğini kendiliğinden doğru biçimde tahmin etmez. Projeniz bir kütüphaneye ihtiyaç duyuyorsa bu bağımlılığı requirements.txt gibi bir dosyada açıkça belirtmeniz gerekir. Java projelerinde de benzer amaçla Maven veya Gradle yapılandırma dosyaları kullanılır.

Python sürümü, paket sürümleri, gerekli ortam değişkenleri ve uygulamanın nasıl başlatılacağı belgelenmediğinde aynı sorun container içinde de devam edebilir. Ayrıca Docker bozuk kodu düzeltmez. Sözdizimi hatası, yanlış dosya yolu, hatalı iş mantığı veya eksik yapılandırma container içinde de hatalı sonuç üretir. Docker'ın katkısı, bu kodun hangi temel ortamda çalıştırıldığını daha düzenli ve tekrar edilebilir biçimde tanımlamaktır.

Kubernetes, orkestrasyon ve çoklu servis mimarisi gibi konular daha büyük sistemlerde önem kazanabilir; ancak tek bir Python veya Java projesini ilk kez container içine alma rehberinin kapsamı dışındadır. İlk denemede bu başlıklara geçmeden dosya, image, container ve çıktı arasındaki temel akışı sağlamlaştırmak daha doğru bir başlangıçtır.

Bir sonraki deneme için 5 maddelik kontrol listesi

1. Doğru klasör: Dockerfile, uygulama dosyası ve bağımlılık dosyalarının build komutunda kullanılan klasörde veya doğru göreli yollarda bulunduğunu kontrol edin.
2. Doğru kopyalama: Dockerfile içindeki COPY satırlarının uygulama dosyalarını image içine aldığını ve çalıştırılan dosya adının doğru olduğunu doğrulayın.
3. Başarılı build: Build sırasında görülen ilk hata mesajını inceleyin; işlem tamamlanmadan docker run komutuna geçmeyin.
4. Doğru image adı: docker run komutunda, build sırasında oluşturduğunuz image adını ve gerekiyorsa etiketini eksiksiz kullanın.
5. Beklenen çıktı: Container başlatıldığında uygulamanın beklenen sonucu verip vermediğini kontrol edin; container kapanıyorsa logları inceleyerek ana işlemin neden sonlandığını bulun.

Sık Sorulan Sorular

Docker container ile sanal makine arasındaki temel fark nedir?

Container, uygulamayı ve ihtiyaç duyduğu dosyaları izole bir çalışma alanında çalıştırır; ancak işletim sisteminin çekirdeğini ana sistemle paylaşır. Sanal makine ise genellikle kendi işletim sistemiyle birlikte daha kapsamlı bir sanallaştırma katmanı üzerinde çalışır. Bu nedenle container'lar uygulama ortamını taşımak için pratik olabilirken sanal makineler farklı işletim sistemi ortamlarını daha bağımsız biçimde çalıştırmak için tercih edilebilir.

Docker kullanmak için Python veya Java bilmek gerekir mi?

Docker'ın temel komutlarını öğrenmek için ileri düzey Python veya Java bilgisi gerekmez. Ancak container içine alacağınız uygulamanın nasıl başlatıldığını, hangi dosyalara ve bağımlılıklara ihtiyaç duyduğunu anlamak gerekir. Bu yüzden Docker, programlama bilgisinin yerine geçmez; mevcut bir Python veya Java projesinin çalışma ortamını tanımlamaya yardımcı olur.

Dockerfile ile Docker image arasındaki fark nedir?

Dockerfile, image'ın nasıl oluşturulacağını anlatan talimat dosyasıdır. İçinde temel image seçimi, dosyaların kopyalanması, bağımlılıkların kurulması ve başlangıç komutu gibi bilgiler yer alır. Docker image ise bu talimatların uygulanması sonucunda oluşan, container başlatmak için kullanılan kalıptır. Kısaca Dockerfile tarif, image ise bu tariften üretilen çalışma paketidir.

Container çalışırken değişiklik yaptığımda image yeniden oluşturmalı mıyım?

Değişikliğin türüne bağlıdır. Kaynak kodunu bilgisayarınızdan container içine bağlanan bir geliştirme düzeniyle kullanıyorsanız bazı kod değişikliklerini image oluşturmadan test edebilirsiniz. Fakat Dockerfile'ı, Python veya Java sürümünü, bağımlılık listesini ya da image içine kopyalanan dosyaları değiştirdiyseniz yeni değişikliklerin image'a alınması için yeniden build yapmanız gerekir.

Özellikle paylaşılacak veya başka bir bilgisayarda tekrar çalıştırılacak bir image için yeniden build etmek daha güvenilir bir yaklaşımdır. Böylece çalıştırılan image'ın gerçekten güncel dosyaları ve bağımlılıkları içerdiğinden emin olabilirsiniz.

İlk container denemenizde amaç her ayrıntıyı ezberlemek değil, uygulamanın hangi dosyalara ve çalışma koşullarına ihtiyaç duyduğunu görünür hâle getirmektir.