Özel Docker Görüntüsü Oluşturma ve Azure’da Dağıtma Rehberi

Modern uygulama geliştirme süreçlerinde konteynerizasyon, yazılımların dağıtımını, yönetimini ve ölçeklendirilmesini kolaylaştıran devrim niteliğinde bir teknolojidir. Peki, kendi özel Docker görüntünüzü oluşturup bunu Azure Container Registry’de güvenle depolayarak Azure Container Instances üzerinde nasıl hızlı ve maliyet etkin bir şekilde çalıştırabilirsiniz? Bu kapsamlı rehberde, bu soruların yanıtlarını adım adım keşfedecek, bulut tabanlı konteyner dağıtımının temel prensiplerini ve pratik uygulamalarını derinlemesine inceleyeceğiz.

Günümüzün rekabetçi teknoloji dünyasında, geliştiriciler ve operasyon ekipleri, uygulamaları daha hızlı bir şekilde pazara sunmak ve tutarlı bir ortamda çalıştırmak için sürekli yeni yollar arıyorlar. Geleneksel dağıtım yöntemleri, “ortam bağımlılıkları” ve “makinemde çalışıyor” gibi sorunlarla dolu olabilirken, Docker gibi konteyner teknolojileri bu zorlukların üstesinden gelmek için güçlü bir çözüm sunar. Microsoft Azure’ın sunduğu Container Registry (ACR) ve Container Instances (ACI) hizmetleri ise bu konteynerleştirilmiş uygulamaların bulut ortamında sorunsuz bir şekilde barındırılması ve yönetilmesi için ideal bir platform sağlar. Bu makalede, hem teorik bilgileri pekiştirecek hem de pratik örneklerle kendi özel Docker görüntünüzü Azure’a nasıl taşıyacağınızı öğreneceksiniz. Hadi başlayalım!

Kapsayıcılaştırma, modern yazılım geliştirme ve dağıtım süreçlerinin temel taşlarından biri haline gelmiştir. Bu teknoloji, bir uygulamanın tüm bağımlılıklarını (kod, çalışma zamanı, sistem araçları, kütüphaneler vb.) tek bir izole pakette toplamasını sağlar. Böylece, uygulamanın farklı ortamlarda (geliştirme, test, üretim) tutarlı bir şekilde çalışması garanti altına alınır. Bu sayede “Benim makinemde çalışıyor ama sunucuda çalışmıyor!” gibi klasik problemlerin önüne geçilir. Peki, kapsayıcılaştırmanın arkasındaki temel kavramlar nelerdir ve neden bu kadar yaygın bir şekilde benimsenmiştir?

Öncelikle, Docker kavramına odaklanalım. Docker, uygulamaları kapsayıcılar içinde geliştirme, dağıtma ve çalıştırma olanağı sunan açık kaynaklı bir platformdur. Bir Docker kapsayıcısı, hafif, taşınabilir ve kendi bağımsız ortamında çalışan bir yazılım birimidir. Sanal makinelerden farklı olarak, kapsayıcılar ana bilgisayarın işletim sistemi çekirdeğini paylaşır, bu da onları daha hafif ve daha hızlı başlatılabilir kılar. Bu durum, özellikle mikroservis mimarisiyle çalışan uygulamalar için büyük avantajlar sunar. Her mikroservis kendi kapsayıcısı içinde izole bir şekilde çalışabilir, bu da bağımsız ölçeklenebilirlik ve hata izolasyonu sağlar.

Kapsayıcılaştırmanın bir diğer önemli bileşeni ise Docker Görüntüsü (Docker Image)‘dir. Docker görüntüsü, bir uygulamanın çalışması için gereken her şeyi içeren, çalıştırılabilir, pasif bir şablondur. Bu görüntüler katmanlı bir yapıya sahiptir ve bu sayede verimli bir depolama ve dağıtım mekanizması sunarlar. Örneğin, bir temel işletim sistemi görüntüsü üzerinde bir Python çalışma zamanı, onun üzerinde de sizin uygulamanızın kodu katmanlar halinde inşa edilebilir. Bu sayede, sadece değişen katmanlar güncellenerek depolama alanı ve ağ bant genişliği tasarrufu sağlanır.

Görüntüler oluşturulduktan sonra, bunların depolanması ve paylaşılması için Kapsayıcı Kayıt Defterleri (Container Registries) kullanılır. Docker Hub gibi herkese açık kayıt defterleri veya Azure Container Registry (ACR) gibi özel, bulut tabanlı kayıt defterleri, Docker görüntülerinin güvenli bir şekilde saklandığı ve ekipler arasında kolayca paylaşılabildiği depolardır. ACR, özellikle Azure ekosistemi içinde çalışıyorsanız, diğer Azure hizmetleriyle entegrasyonu, gelişmiş güvenlik özellikleri ve özel depolama imkanları sayesinde kurumsal uygulamalar için mükemmel bir seçimdir. Son olarak, bu kapsayıcıları bulutta çalıştırmak için Azure Container Instances (ACI) gibi hizmetlere ihtiyaç duyarız. ACI, herhangi bir sanal makine veya Kubernetes kümesi yönetimi gerektirmeden kapsayıcıları anında çalıştırabilmenizi sağlayan sunucusuz bir PaaS (Platform as a Service) çözümüdür. Hızlı prototipleme, görev tabanlı iş yükleri veya burstable (patlayıcı) senaryolar için idealdir. Bu temel kavramlar, kendi özel Docker görüntünüzü Azure’da başarılı bir şekilde dağıtmanız için sağlam bir zemin oluşturur.

Özel Docker Görüntüsü Oluşturma: Adım Adım Dockerfile Hazırlığı

Kendi özel Docker görüntünüzü oluşturmanın kalbi, bir Dockerfile hazırlamaktır. Dockerfile, Docker’ın bir görüntüyü nasıl inşa edeceğini adım adım açıklayan bir metin dosyasıdır. Bu dosya, temel işletim sisteminden başlayarak, gerekli bağımlılıkları yükleme, uygulamanızın kodunu kopyalama, portları açma ve uygulamanızı başlatma komutlarına kadar her şeyi içerir. Bu bölümde, basit bir Python web uygulamasını örnek alarak bir Dockerfile’ı nasıl oluşturacağımızı ve görüntüyü yerel olarak nasıl test edeceğimizi öğreneceğiz.

Kendi Uygulamamızı Kapsayıcılaştıralım: Bir Örnek Uygulama

Örneğimiz için basit bir Flask tabanlı Python web uygulaması kullanacağız. Bu uygulama, ana dizine gelen isteklere “Merhaba, Azure Konteynerları!” mesajını döndürecek. Uygulama dosyamızın adı app.py olacak ve bağımlılıklarımız için bir requirements.txt dosyası kullanacağız.

Öncelikle, projemiz için bir dizin oluşturalım ve içine app.py ve requirements.txt dosyalarını ekleyelim:

# app.py içeriği
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Merhaba, Azure Konteynerları!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=80)

Ardından, uygulamamızın tek bağımlılığı olan Flask'i belirten requirements.txt dosyasını oluşturalım:

# requirements.txt içeriği
Flask==2.0.2

Bu basit yapı, Dockerfile'ımızın temelini oluşturacak. Uygulamanız daha karmaşık olsa da, kapsayıcılaştırma mantığı aynı kalacaktır: uygulamanın çalışması için gereken her şeyi pakete dahil etmek.

Dockerfile Nedir ve Nasıl Oluşturulur?

Şimdi, bu uygulamayı bir Docker görüntüsüne dönüştürecek Dockerfile dosyamızı oluşturalım. Bu dosyayı, app.py ve requirements.txt ile aynı dizine kaydetmelisiniz. Bir Dockerfile genellikle aşağıdaki ana komutları içerir:

• FROM: Görüntünüzün temelini oluşturacak ana görüntüyü belirtir (örneğin, bir işletim sistemi veya bir programlama dili çalışma zamanı).
• WORKDIR: Kapsayıcı içindeki çalışma dizinini ayarlar. Sonraki tüm komutlar bu dizin içinde yürütülür.
• COPY: Yerel sisteminizden kapsayıcıya dosya ve dizinleri kopyalar.
• RUN: Görüntü oluşturulurken çalıştırılacak komutları belirtir (örneğin, bağımlılıkları yükleme).
• EXPOSE: Kapsayıcının belirli bir port üzerinden dinleyeceğini belirtir. Bu sadece bir belgedir, harici erişim için port eşlemesi ayrıca yapılmalıdır.
• CMD: Kapsayıcı başlatıldığında çalıştırılacak varsayılan komutu belirtir. Bir Dockerfile'da genellikle sadece bir CMD komutu bulunur.

Uygulamamız için Dockerfile:

# Dockerfile içeriği
# 1. Adım: Temel Görüntüyü Seçme
# Python 3.9'un slim-buster sürümünü temel alıyoruz. Bu, daha küçük bir görüntü boyutu için optimize edilmiştir.
FROM python:3.9-slim-buster

# 2. Adım: Çalışma Dizinini Ayarlama
# Kapsayıcı içinde /app dizinini çalışma dizini olarak belirliyoruz.
WORKDIR /app

# 3. Adım: Bağımlılıkları Kopyalama ve Yükleme
# requirements.txt dosyasını çalışma dizinine kopyala.
COPY requirements.txt .

# Python bağımlılıklarını yükle. --no-cache-dir, önbellek dosyalarının görüntüye eklenmemesini sağlar.
RUN pip install --no-cache-dir -r requirements.txt

# 4. Adım: Uygulama Kodunu Kopyalama
# Mevcut dizindeki tüm dosyaları (app.py dahil) kapsayıcıdaki /app dizinine kopyala.
COPY . .

# 5. Adım: Portu Belirtme
# Uygulamamızın 80 numaralı portu dinleyeceğini bildiriyoruz.
EXPOSE 80

# 6. Adım: Uygulamayı Başlatma Komutu
# Kapsayıcı başlatıldığında bu komut çalışacak. Flask uygulamamızın 0.0.0.0 adresinde ve 80 portunda çalışmasını sağlıyoruz.
CMD ["python", "app.py"]

Docker Görüntüsünü Oluşturma ve Yerel Olarak Test Etme

Dockerfile'ı oluşturduktan sonra, sıra Docker görüntüsünü inşa etmeye gelir. Komut istemcinizi veya terminalinizi Dockerfile'ın bulunduğu dizine getirerek aşağıdaki komutu çalıştırın:

docker build -t my-custom-app:v1 .

Bu komutun anlamı şudur:

• docker build: Bir Docker görüntüsü oluşturma komutu.
• -t my-custom-app:v1: Oluşturulan görüntüye my-custom-app adını ve v1 etiketini (tag) atar. Etiketler, bir görüntünün farklı sürümlerini yönetmek için kullanılır.
• .: Dockerfile'ın ve uygulamanın kaynak dosyalarının mevcut dizinde olduğunu belirtir.

Bu işlem biraz zaman alabilir, Dockerfile'daki her RUN, COPY komutu yeni bir katman oluşturacaktır. Başarılı bir şekilde tamamlandığında, görüntünüzü yerel Docker deponuzda görebilirsiniz: docker images.

Şimdi bu görüntüyü yerel olarak bir kapsayıcıda çalıştırıp test edelim:

docker run -p 8080:80 my-custom-app:v1

Bu komut:

• docker run: Bir kapsayıcıyı başlatma komutu.
• -p 8080:80: Yerel makinenizin 8080 portunu kapsayıcının 80 portuna eşler. Böylece yerel makinenizden http://localhost:8080 adresine eriştiğinizde, kapsayıcının içindeki Flask uygulamasına ulaşabilirsiniz.
• my-custom-app:v1: Hangi görüntünün çalıştırılacağını belirtir.

Tarayıcınızda http://localhost:8080 adresine gidin. "Merhaba, Azure Konteynerları!" mesajını görmelisiniz. Bu, özel Docker görüntünüzün başarıyla oluşturulduğu ve yerel olarak çalıştığı anlamına gelir. Bu aşama, dağıtım sürecinin en kritik başlangıç noktasıdır, çünkü bir sonraki adımda bu görüntüyü Azure bulutuna taşıyacağız.

Azure Container Registry (ACR) ile Görüntü Depolama: Güvenli ve Ölçeklenebilir Çözümler

Yerel ortamınızda özel Docker görüntünüzü başarıyla oluşturdunuz ve test ettiniz. Şimdi sıra, bu görüntüyü güvenli bir şekilde depolamak ve Azure bulut hizmetlerinin erişimine sunmaktır. İşte tam bu noktada Azure Container Registry (ACR) devreye giriyor. ACR, Docker görüntülerini ve diğer OCI (Open Container Initiative) formatındaki yapıtları depolamak ve yönetmek için tasarlanmış, yönetilen, özel bir kayıt defteri hizmetidir. Docker Hub gibi herkese açık kayıt defterlerinin aksine, ACR size ait özel bir depo sunar, bu da kurumsal düzeyde güvenlik ve kontrol sağlar.

ACR Nedir ve Neden Kullanmalıyız?

Azure Container Registry, Azure ekosistemiyle derinlemesine entegre edilmiş bir PaaS hizmetidir. Temel amacı, Docker görüntülerinizi ve Helm grafiklerinizi (Kubernetes paket yöneticisi) depolamak, yönetmek ve dağıtmaktır. ACR'yi kullanmanın başlıca nedenleri şunlardır:

• Güvenlik ve İzolasyon: Görüntüleriniz tamamen size ait, özel bir depoda barındırılır. Azure Active Directory (AAD) tabanlı kimlik doğrulama, sanal ağ entegrasyonu ve görüntü taraması gibi özelliklerle gelişmiş güvenlik sunar.
• Azure Entegrasyonu: Azure Kubernetes Service (AKS), Azure Container Instances (ACI), Azure App Service ve Azure Functions gibi diğer Azure hizmetleriyle sorunsuz bir şekilde çalışır. Bu sayede, kapsayıcılı uygulamalarınızı Azure içinde kolayca dağıtabilir ve yönetebilirsiniz.
• Küresel Ölçeklenebilirlik: Coğrafi çoğaltma özelliği sayesinde görüntülerinizi farklı Azure bölgelerine dağıtarak gecikme süresini azaltabilir ve bölgesel felaketlere karşı dayanıklılığı artırabilirsiniz.
• Otomatik Oluşturma (ACR Tasks): Dockerfile'lardan otomatik olarak görüntü oluşturabilir, görüntüleri test edebilir ve yama uygulanmış temel görüntüler güncellendiğinde yeniden inşa edebilirsiniz. Bu, CI/CD (Sürekli Entegrasyon/Sürekli Teslimat) süreçlerinin önemli bir parçasıdır.
• Maliyet Yönetimi: Kullanım tabanlı ödeme modeli ve farklı SKU seçenekleri (Basic, Standard, Premium) ile ihtiyaçlarınıza uygun maliyet optimizasyonu sağlar.

Özetle, ACR, kurumsal düzeyde kapsayıcı iş yükleri için güçlü, güvenli ve ölçeklenebilir bir temel oluşturur.

Azure CLI ile ACR Kayıt Defteri Oluşturma

Bir ACR kayıt defteri oluşturmak için Azure CLI'yi kullanacağız. Öncelikle Azure hesabınıza giriş yaptığınızdan emin olun:

az login

Daha sonra bir kaynak grubu oluşturmanız gerekebilir veya mevcut birini kullanabilirsiniz:

az group create --name MyResourceGroup --location westeurope

Şimdi, yeni bir ACR kayıt defteri oluşturalım. Kayıt defteri adının Azure içinde genel olarak benzersiz olması gerektiğini unutmayın.

az acr create --resource-group MyResourceGroup --name mycustomacr --sku Basic --admin-enabled true

Bu komutun anlamı:

• az acr create: Yeni bir Azure Container Registry oluşturma komutu.
• --resource-group MyResourceGroup: Kayıt defterinin atanacağı kaynak grubu.
• --name mycustomacr: Kayıt defterinizin adı. Lütfen benzersiz bir ad seçin (örneğin, bengihantestacr2023 gibi).
• --sku Basic: Kayıt defteri için fiyatlandırma katmanını belirtir. Basic, başlangıç için yeterlidir. Standard ve Premium SKU'lar daha fazla özellik (örneğin, coğrafi çoğaltma) sunar.
• --admin-enabled true: Yönetici kullanıcıyı etkinleştirir. Bu, kullanıcı adı ve parola tabanlı erişim sağlar. Üretim ortamlarında genellikle AAD servis sorumlusu veya yönetilen kimlikler tercih edilir.

Kayıt defteri başarıyla oluşturulduğunda, çıktıda bir JSON nesnesi göreceksiniz. Bu, ACR'nizin artık kullanıma hazır olduğu anlamına gelir.

Yerel Docker Görüntüsünü ACR'ye Gönderme (Push)

ACR kayıt defteriniz hazır olduğuna göre, yerel olarak oluşturduğunuz my-custom-app:v1 Docker görüntüsünü ACR'ye gönderebiliriz. Bu işlem üç ana adımdan oluşur:

1. ACR'ye Giriş Yapma: Docker CLI'yı kullanarak ACR kayıt defterinize kimlik doğrulamanız gerekir. Yönetici kullanıcısını etkinleştirdiğimiz için, kullanıcı adınızı ve parolanızı kullanarak giriş yapacağız. Bu bilgileri aşağıdaki komutlarla alabilirsiniz:

az acr credential show --name mycustomacr --query "username" --output tsv
az acr credential show --name mycustomacr --query "passwords[0].value" --output tsv
  

Şimdi Docker CLI ile giriş yapın (mycustomacr.azurecr.io yerine kendi ACR adınızı kullanın):

docker login mycustomacr.azurecr.io
  

İstenen kullanıcı adı ve parolayı girin.

2. Görüntüyü Etiketleme (Tag): Docker görüntüleri, kayıt defteri URL'si ile etiketlenmelidir. Bu, Docker'a görüntüyü nereye göndereceğini söyler.

docker tag my-custom-app:v1 mycustomacr.azurecr.io/my-custom-app:v1
  

Bu komut, my-custom-app:v1 görüntüsüne ACR kayıt defterinizin tam URL'siyle yeni bir etiket ekler.

3. Görüntüyü Gönderme (Push): Etiketlenmiş görüntüyü ACR'ye gönderin.

docker push mycustomacr.azurecr.io/my-custom-app:v1
  

Bu komut, görüntüyü katman katman ACR'ye yükleyecektir. İşlem tamamlandığında, Azure portalında ACR hizmetinize giderek veya aşağıdaki CLI komutunu kullanarak görüntünün başarıyla yüklendiğini doğrulayabilirsiniz:

az acr repository show-tags --name mycustomacr --repository my-custom-app --output tsv

Artık özel Docker görüntünüz Azure Container Registry'de güvenli bir şekilde depolanmıştır ve Azure'daki diğer hizmetler tarafından erişilebilir durumdadır. Bu, uygulamanızın bulut tabanlı dağıtımının bir sonraki adımına geçmek için temel bir adımdır.

Azure Container Instances (ACI) ile Hızlı Dağıtım: Sunucusuz Kapsayıcı Çalıştırma

Azure Container Registry'de özel Docker görüntümüzü güvenli bir şekilde depoladıktan sonra, sıra bu görüntüyü bulutta çalıştırmaya gelir. Azure Container Instances (ACI), bu görevi basitleştiren ve sunucusuz bir model sunan güçlü bir hizmettir. ACI ile, sanal makineleri (VM'ler) veya Kubernetes gibi karmaşık kapsayıcı orkestrasyon platformlarını yönetme yükü olmadan tekil kapsayıcıları veya küçük kapsayıcı gruplarını anında çalıştırabilirsiniz. Bu, özellikle hızlı prototipleme, görev tabanlı iş yükleri, veri işleme boru hatları veya ara sıra çalışan işler için idealdir.

ACI Nedir ve Avantajları Nelerdir?

ACI, Azure'da bir kapsayıcı çalıştırmak için en hızlı ve en basit yollardan biridir. Tamamen yönetilen bir hizmet olarak, altyapı yönetimiyle uğraşmanıza gerek kalmaz. Sadece kapsayıcı görüntünüzü belirtin, gerekli kaynakları (CPU, bellek) tanımlayın ve ACI sizin için gerisini halleder. Başlıca avantajları şunlardır:

• Sunucusuz Yaklaşım: Altyapı provizyonu, yamalama veya yönetimi gibi görevlerle uğraşmak zorunda kalmazsınız. Kapsayıcılarınız doğrudan Azure'ın altyapısında çalışır.
• Hızlı Başlangıç: Kapsayıcı örnekleri saniyeler içinde başlatılabilir, bu da anlık iş yükleri veya hızlı dağıtım gerektiren senaryolar için mükemmeldir.
• İsteğe Bağlı Fiyatlandırma: Yalnızca kapsayıcılarınızın çalıştığı süre boyunca CPU, bellek ve ağ kullanımı için ödeme yaparsınız. Bu, özellikle aralıklı veya değişken iş yükleri için maliyet etkin bir çözüm sunar.
• Esneklik: Linux ve Windows kapsayıcılarını destekler, özel görüntülerden veya Docker Hub gibi herkese açık kayıt defterlerinden görüntüler çekebilir.
• Basitlik: Tekil kapsayıcılar veya kapsayıcı grupları çalıştırmak için idealdir. Kubernetes gibi gelişmiş orkestrasyon özelliklerine ihtiyaç duymayan senaryolar için mükemmeldir.
• Güvenli Ağ İzolasyonu: Kapsayıcılarınızı sanal ağlara dağıtarak daha gelişmiş ağ kontrolleri ve güvenlik sağlayabilirsiniz.

ACI'nin bu avantajları, özellikle belirli bir görevi yerine getirecek veya kısa ömürlü bir hizmet sunacak uygulamalar için onu cazip kılar.

ACR'deki Görüntüyü ACI'ye Dağıtma

Şimdi ACR'de depoladığımız mycustomacr.azurecr.io/my-custom-app:v1 görüntüsünü ACI'ye dağıtalım. Bu işlemi Azure CLI ile kolayca yapabiliriz. Dağıtım sırasında, kapsayıcımızın adını, kullanacağı görüntüyü, açacağı portları ve erişilebilir olacağı bir DNS adını belirtmemiz gerekecek. Ayrıca, ACI'nin özel kayıt defterimiz ACR'den görüntüyü çekebilmesi için kimlik doğrulama bilgilerini sağlamamız önemlidir.

# ACR kullanıcı adı ve şifresini alıyoruz
ACR_USERNAME=$(az acr credential show --name mycustomacr --query "username" --output tsv)
ACR_PASSWORD=$(az acr credential show --name mycustomacr --query "passwords[0].value" --output tsv)

# Azure Container Instance oluşturma
az container create --resource-group MyResourceGroup \
    --name mycontainerapp \
    --image mycustomacr.azurecr.io/my-custom-app:v1 \
    --dns-name-label mycontainerdns \
    --ports 80 \
    --registry-username $ACR_USERNAME \
    --registry-password $ACR_PASSWORD \
    --cpu 1 \
    --memory 1

Bu komutun detayları:

• az container create: Yeni bir Azure Container Instance oluşturma komutu.
• --resource-group MyResourceGroup: Kapsayıcı örneğinin oluşturulacağı kaynak grubu.
• --name mycontainerapp: Kapsayıcı örneğinizin adı.
• --image mycustomacr.azurecr.io/my-custom-app:v1: Çalıştırılacak Docker görüntüsünün tam yolu.
• --dns-name-label mycontainerdns: Kapsayıcınıza erişmek için kullanılacak genel DNS adının bir parçası. Bu, mycontainerdns.[bölge_adı].azurecontainer.io şeklinde bir URL oluşturur. Bu etiketin de genel olarak benzersiz olması gerekir.
• --ports 80: Kapsayıcının dışarıdan erişime açık olacak portu (Flask uygulamamız 80 numaralı portu dinliyor).
• --registry-username $ACR_USERNAME ve --registry-password $ACR_PASSWORD: ACI'nin özel ACR kayıt defterinizden görüntüyü çekmek için kullanacağı kimlik doğrulama bilgileri. Daha önce aldığımız değişkenleri kullanıyoruz.
• --cpu 1 --memory 1: Kapsayıcı örneğine atanacak CPU (çekirdek) ve bellek (GB) miktarı. İhtiyacınıza göre ayarlayabilirsiniz.

Komut başarıyla tamamlandığında, ACI örneğinizin durumu ve erişim URL'si dahil olmak üzere detaylı bir JSON çıktısı alacaksınız. Kapsayıcınızın tamamen başlatılması birkaç saniye sürebilir. Kapsayıcı örneğinin tam nitelikli etki alanı adını (FQDN) aşağıdaki komutla alabilirsiniz:

az container show --resource-group MyResourceGroup --name mycontainerapp --query "ipAddress.fqdn" --output tsv

Elde ettiğiniz FQDN'yi bir web tarayıcısına yapıştırarak uygulamanıza erişmeyi deneyin. "Merhaba, Azure Konteynerları!" mesajını görüyorsanız, özel Docker görüntünüzü Azure Container Registry'den Azure Container Instances'a başarıyla dağıtmışsınız demektir. Bu, bulutta kapsayıcı tabanlı uygulamaları çalıştırmanın en basit yollarından biridir ve uygulamanızın global ölçekte erişilebilir olmasını sağlar.

Gerçek Dünya Senaryosu: Sürekli Entegrasyon ve Teslimat (CI/CD) ile Otomatik Dağıtım

Şimdiye kadar özel Docker görüntümüzü oluşturduk, Azure Container Registry'de depoladık ve Azure Container Instances üzerinde manuel olarak dağıttık. Ancak modern yazılım geliştirme pratiklerinde bu süreçlerin otomatikleştirilmesi, yani Sürekli Entegrasyon (CI) ve Sürekli Teslimat/Dağıtım (CD) işlem hatlarının kurulması hayati öneme sahiptir. CI/CD, kod değişikliklerinin daha hızlı, daha güvenli ve daha tutarlı bir şekilde üretime alınmasını sağlar. Bu bölümde, basit bir CI/CD senaryosunu ele alarak, kod değişikliklerinin otomatik olarak bir Docker görüntüsüne dönüştürülmesini ve Azure'a dağıtılmasını nasıl sağlayacağımızı inceleyeceğiz. Bu, yazılım geliştirme döngüsünü hızlandırır ve insan hatalarını minimize eder.

DevOps Süreçlerinde Docker ve Azure Konteyner Hizmetleri

DevOps felsefesi, geliştirme ve operasyon ekipleri arasındaki işbirliğini ve otomasyonu vurgular. Konteyner teknolojileri, DevOps süreçlerinin temelini oluşturur çünkü uygulamaları ve bağımlılıklarını paketleyerek "bir kez inşa et, her yerde çalıştır" ilkesini destekler. Bu, özellikle CI/CD işlem hatlarında büyük fayda sağlar:

• Tutarlı Ortamlar: Geliştiricinin makinesindeki ortamdan üretim ortamına kadar her yerde aynı kapsayıcı görüntüsünün kullanılması, uyumsuzluk sorunlarını ortadan kaldırır.
• Hızlı Geri Bildirim: Otomatik testler ve dağıtımlar sayesinde geliştiriciler kod değişikliklerinin etkileri hakkında anında geri bildirim alırlar.
• Güvenilir Dağıtımlar: Otomatikleştirilmiş işlem hatları, manuel dağıtımlardan kaynaklanan insan hatalarını azaltır ve her dağıtımın aynı şekilde yapılmasını sağlar.
• Hızlı Kurtarma: Geri alma işlemleri, önceden başarılı olmuş bir görüntüye işaret edilerek kolayca yapılabilir.

Azure Container Registry (ACR), görüntüler için merkezi bir depo görevi görürken, Azure Container Instances (ACI) hızlı ve esnek dağıtım uç noktaları olarak işlev görür. CI/CD işlem hattımızı kurarken bu iki Azure hizmetini kullanacağız. Örneğimizde GitHub Actions'ı (Azure DevOps, GitLab CI/CD veya Jenkins gibi diğer araçlar da kullanılabilir) kullanarak basit bir CI/CD akışı oluşturalım.

Senaryomuz şöyle olacak: Uygulama kodumuz (app.py, requirements.txt, Dockerfile) bir GitHub deposunda bulunuyor. main dalına yapılan her push işlemi, aşağıdaki adımları otomatik olarak tetikleyecek:

1. GitHub deposundan kodu çek.
2. Docker görüntüsünü oluştur.
3. Oluşturulan görüntüyü Azure Container Registry'ye (ACR) gönder.
4. ACR'deki yeni görüntüyü kullanarak Azure Container Instances'a (ACI) dağıt.

Bu otomasyonu sağlamak için GitHub Actions kullanacağız. GitHub Actions, deponuzdaki .github/workflows dizini altına yerleştirilen YAML dosyalarıyla tanımlanan iş akışları (workflows) sağlar. Hassas bilgileri (ACR kullanıcı adı ve şifresi gibi) doğrudan YAML dosyasına yazmak yerine GitHub Secrets kullanacağız. GitHub deponuzda aşağıdaki sırları (secrets) tanımlamanız gerekecek:

• AZURE_ACR_USERNAME: ACR yönetici kullanıcı adınız.
• AZURE_ACR_PASSWORD: ACR yönetici şifreniz.

Bu bilgileri daha önce az acr credential show komutlarıyla almıştık.

Şimdi .github/workflows/deploy.yml adında bir dosya oluşturalım ve içeriğini aşağıdaki gibi dolduralım:

# .github/workflows/deploy.yml
name: CI/CD Pipeline for My Custom App

on:
  push:
    branches:
      - main # main dalına yapılan her push'ta bu iş akışını tetikle

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest # İş akışının çalışacağı sanal makine ortamı

    steps:
    - name: Kodu Dışarı Çek
      uses: actions/checkout@v3 # GitHub deposundaki kodu sanal makineye çeker

    - name: Docker Login to ACR
      uses: docker/login-action@v2 # Docker'ı Azure Container Registry'ye giriş yapmak için kullanır
      with:
        registry: mycustomacr.azurecr.io # Kendi ACR adınızı buraya yazın
        username: ${{ secrets.AZURE_ACR_USERNAME }} # GitHub Secret'tan ACR kullanıcı adını alır
        password: ${{ secrets.AZURE_ACR_PASSWORD }} # GitHub Secret'tan ACR şifresini alır

    - name: Docker Görüntüsünü Oluştur ve ACR'ye Gönder
      run: |
        # Görüntüyü oluştur. Etiket olarak GitHub'ın SHA'sını kullanmak benzersizlik sağlar.
        docker build . -t mycustomacr.azurecr.io/my-custom-app:${{ github.sha }}
        # Görüntüyü ACR'ye gönder
        docker push mycustomacr.azurecr.io/my-custom-app:${{ github.sha }}
      env:
        # Ortam değişkeni olarak ACR sunucu adını tanımla
        ACR_SERVER: mycustomacr.azurecr.io # Kendi ACR adınızı buraya yazın

    - name: ACI'ye Dağıt
      uses: azure/container-instances@v1 # ACI'ye dağıtım için Azure Container Instances aksiyonunu kullanır
      with:
        resource-group: MyResourceGroup # Kapsayıcının dağıtılacağı kaynak grubu
        name: mycontainerapp-ci-cd # Yeni ACI örneğinin adı
        image: mycustomacr.azurecr.io/my-custom-app:${{ github.sha }} # ACR'deki görüntümüzü kullan
        ports: 80 # Uygulamanın dinlediği port
        dns-name-label: mycicdcontainer-${{ github.run_id }} # Benzersiz bir DNS adı etiketi oluştur
        registry-username: ${{ secrets.AZURE_ACR_USERNAME }} # ACR kullanıcı adı
        registry-password: ${{ secrets.AZURE_ACR_PASSWORD }} # ACR şifresi
        location: westeurope # Kapsayıcının dağıtılacağı Azure bölgesi

Bu YAML dosyasını GitHub deponuza ekledikten sonra, main dalına bir kod değişikliği gönderdiğinizde, GitHub Actions otomatik olarak tetiklenecek ve uygulamanızı Azure Container Registry üzerinden Azure Container Instances'a dağıtacaktır. Dağıtımın DNS adı, her çalıştırmada benzersiz olacak şekilde mycicdcontainer-[run_id].[bölge].azurecontainer.io formatında oluşturulacaktır. Bu, sürekli ve güvenilir bir dağıtım süreci sağlar, böylece geliştirme ekibi daha çok kod yazmaya ve yenilikçi çözümler üretmeye odaklanabilir.

İleri Düzey İpuçları ve En İyi Uygulamalar

Artık özel Docker görüntümüzü Azure Container Registry'de depolayıp Azure Container Instances'a otomatik olarak dağıtabiliyoruz. Ancak, modern bulut tabanlı uygulamaları geliştirirken sadece işlevsellik değil, aynı zamanda performans, maliyet etkinliği ve güvenlik de büyük önem taşır. Bu bölümde, daha deneyimli kullanıcılar için bazı ileri düzey ipuçları ve en iyi uygulamaları ele alarak, konteyner tabanlı çözümlerinizi daha optimize ve güvenli hale getirmenize yardımcı olacağız.

Maliyet Optimizasyonu ve Performans İyileştirmeleri

Azure'da kapsayıcı iş yüklerini çalıştırırken maliyeti kontrol altında tutmak ve performansı en üst düzeye çıkarmak kritik öneme sahiptir:

• Dockerfile Optimizasyonu:
  • Küçük Temel Görüntüler Kullanın: alpine veya slim etiketli temel görüntüler, gereksiz bağımlılıkları içermediği için çok daha küçük son görüntüler elde etmenizi sağlar. Bu durum, hem depolama maliyetlerini düşürür hem de görüntü indirme sürelerini kısaltır.
  • Çok Aşamalı (Multi-stage) Derlemeler: Geliştirme/derleme araçlarını ve bağımlılıklarını nihai üretim görüntüsünden ayırın. İlk aşamada uygulamanızı derleyin, ikinci aşamada sadece derlenmiş ikili dosyaları veya çalışma zamanı bağımlılıklarını içeren minimal bir görüntüye kopyalayın. Bu, görüntü boyutunu önemli ölçüde küçültür.
  • Katman Önbellekleme: Dockerfile'ınızdaki komutların sırası önemlidir. Sık değişen komutları (örneğin, COPY . .) daha sonra, seyrek değişen komutları (örneğin, bağımlılık kurulumu RUN pip install) daha önce konumlandırarak Docker'ın katman önbelleklemesinden maksimum düzeyde yararlanın.
  • .dockerignore Dosyası Kullanımı: Git depolarında bulunan .git, .DS_Store, node_modules (eğer son görüntüye dahil edilmeyecekse) gibi gereksiz dosyaların bağlama kopyalanmasını engelleyerek derleme bağlamının boyutunu küçültün ve güvenlik açıklarını azaltın.
• ACI Kaynak Yönetimi: ACI'ye atadığınız CPU ve bellek kaynaklarını dikkatlice planlayın. Gereğinden fazla kaynak tahsis etmek maliyetleri artırırken, yetersiz kaynaklar performans sorunlarına yol açabilir. Uygulamanızın yük testi sonuçlarına göre optimal kaynakları belirleyin. Azure Portal veya Azure CLI üzerinden kapsayıcı örneklerinizin metriklerini izleyerek performans darboğazlarını tespit edebilirsiniz.
• Kapsayıcı Otomatik Durdurma: Görev tabanlı veya kısa ömürlü iş yükleri için, iş tamamlandığında kapsayıcıyı otomatik olarak durduracak mekanizmalar (örneğin, kodunuzun sonunda sys.exit(0)) kullanarak sadece çalışma süresi için ödeme yapmanızı sağlayın.

Güvenlik Konuları ve Kimlik Doğrulama

Bulutta güvenlik her zaman birinci öncelik olmalıdır. Konteyner tabanlı uygulamalar için dikkat edilmesi gereken önemli güvenlik noktaları:

• En Az Ayrıcalık Prensibi: Uygulamalarınıza ve CI/CD işlem hatlarınıza yalnızca ihtiyaç duydukları ayrıcalıkları verin. Örneğin, ACR'ye erişim için yönetici kullanıcı hesabı yerine, yalnızca görüntü çekme (pull) yetkisine sahip bir Hizmet Sorumlusu (Service Principal) kullanın. Bu, güvenlik ihlali durumunda potansiyel zararı sınırlar.
• Hassas Veri Yönetimi: API anahtarları, veritabanı kimlik bilgileri gibi hassas bilgileri Docker görüntülerine veya ortam değişkenlerine doğrudan gömmekten kaçının. Bunun yerine, Azure Key Vault gibi güvenli bir sır yönetimi çözümü kullanın ve bu sırları çalışma zamanında uygulamanıza enjekte edin. ACI, Key Vault'tan sırları almak için yönetilen kimlikleri kullanmayı destekler.
• Güvenlik Taraması: ACR'ye yüklediğiniz Docker görüntülerini güvenlik açıkları için düzenli olarak tarayın. Azure Security Center veya üçüncü taraf tarama araçları, bilinen güvenlik açıklarını ve zafiyetleri tespit etmeye yardımcı olabilir. Güvenlik açığı bulunan görüntülerin dağıtımını engelleyen politikalar uygulayın.
• Ağ Güvenliği: ACI örneklerinizi bir Azure Sanal Ağ'ına (VNet) dağıtarak özel IP adresleri atayabilir, ağ güvenlik grupları (NSG) ile gelen ve giden trafiği kontrol edebilir ve diğer Azure kaynaklarınıza (örneğin, veritabanları) güvenli bir şekilde erişmelerini sağlayabilirsiniz. Bu, kapsayıcılarınızın internete doğrudan açık olmasını engelleyerek saldırı yüzeyini küçültür.
• Temel Görüntü Güncelleme Politikası: Kullanılan temel Docker görüntülerinin düzenli olarak güncellendiğinden emin olun. Temel görüntülerde tespit edilen güvenlik açıkları, uygulamanızın da güvenliğini tehlikeye atabilir. ACR Tasks, temel görüntüler güncellendiğinde otomatik olarak yeni uygulama görüntüsü oluşturma yeteneği sunar.

Bu ileri düzey ipuçları ve en iyi uygulamalar, Azure'da konteynerleştirilmiş uygulamalarınızın daha sağlam, güvenli ve maliyet etkin olmasını sağlayarak uzun vadede başarılı olmanıza yardımcı olacaktır. Sürekli öğrenme ve güvenlik güncellemelerini takip etmek, bulut tabanlı çözümlerdeki başarının anahtarıdır.

Sonuç ve Sıkça Sorulan Sorular

Bu kapsamlı rehberde, modern uygulama geliştirme süreçlerinin temel taşlarından biri olan kapsayıcılaştırmayı, özel Docker görüntüleri oluşturmaktan Azure Container Registry'de güvenle depolamaya ve Azure Container Instances üzerinde hızla dağıtmaya kadar adım adım ele aldık. Kapsayıcılaştırmanın neden bu kadar kritik olduğunu, Dockerfile'ın nasıl hazırlandığını, yerel testlerin nasıl yapıldığını ve Azure'ın sunduğu ACR ve ACI hizmetlerinin avantajlarını derinlemesine inceledik. Ayrıca, gerçek dünya senaryolarına uygun bir CI/CD işlem hattının GitHub Actions ile nasıl kurulabileceğini göstererek, otomatik dağıtımın gücünü ortaya koyduk. Son olarak, maliyet optimizasyonu, performans iyileştirmeleri ve güvenlik gibi ileri düzey ipuçlarıyla bulut tabanlı konteyner uygulamalarınızı daha sağlam hale getirme yollarını öğrendik.

Özetle, Azure Container Registry ve Azure Container Instances ikilisi, geliştiricilere ve DevOps mühendislerine, Dockerize edilmiş uygulamalarını bulutta hızlı, güvenli ve ölçeklenebilir bir şekilde dağıtma yeteneği sunar. İster basit bir web uygulaması, ister görev tabanlı bir mikroservis olsun, bu hizmetler uygulama yaşam döngüsünü basitleştirir ve "bir kez inşa et, her yerde çalıştır" felsefesini tam anlamıyla hayata geçirir. Bu rehberin, kendi özel konteynerleştirilmiş çözümlerinizi Azure'da başarıyla hayata geçirmeniz için sağlam bir temel oluşturduğunu umuyoruz. Unutmayın, bulut teknolojileri sürekli gelişiyor, bu yüzden en güncel pratikleri takip etmek ve sürekli öğrenmek başarınız için anahtardır.

Sıkça Sorulan Sorular (SSS)

• Docker görüntüsünü yerel olarak nasıl test edebilirim?

  Docker görüntüsünü yerel olarak test etmek için docker build -t [görüntü_adı]:[tag] . komutu ile görüntüyü oluşturduktan sonra, docker run -p [yerel_port]:[konteyner_port] [görüntü_adı]:[tag] komutu ile çalıştırabilirsiniz. Örneğin, docker run -p 8080:80 my-custom-app:v1 komutu yerel makinenizin 8080 portunu kapsayıcının 80 portuna eşler. Ardından web tarayıcınızda veya cURL ile http://localhost:[yerel_port] adresine bağlanarak test edebilirsiniz.

• ACR ve Docker Hub arasındaki temel fark nedir?

  Docker Hub, genel ve özel Docker görüntüleri için popüler bir bulut tabanlı kayıt defteridir ve geniş bir topluluk tarafından kullanılır. Azure Container Registry (ACR) ise Microsoft Azure ekosistemine tamamen entegre edilmiş, özel bir Docker kayıt defteri hizmetidir. ACR, Azure'daki diğer hizmetlerle (AKS, ACI, Web Apps) daha sıkı entegrasyon, VNet desteği, gelişmiş güvenlik özellikleri (Azure Active Directory entegrasyonu gibi), coğrafi çoğaltma ve Azure'ın kurumsal yeteneklerinden faydalanma imkanı sunar. Özellikle hassas veya özel görüntüleri depolamak için ACR daha güvenli ve kurumsal bir çözümdür.

• ACI, AKS'e göre hangi durumlarda tercih edilmeli?

  Azure Container Instances (ACI), tekil kapsayıcıları veya küçük, bağımsız kapsayıcı gruplarını hızlıca ve orkestrasyon karmaşıklığı olmadan çalıştırmak istediğinizde idealdir. Sunucusuz bir modelde hızlı prototipleme, görev tabanlı iş yükleri (örneğin, bir defalık veri işleme işleri), burst iş yükleri veya basit web uygulamaları için uygundur. Azure Kubernetes Service (AKS) ise karmaşık mikroservis mimarileri, yüksek ölçekli ve sürekli çalışan uygulamalar, gelişmiş orkestrasyon, hizmet keşfi, otomatik hata toleransı, yük dengeleme ve sürekli dağıtım gerektiren senaryolar için tasarlanmıştır. AKS, ACI'ye göre daha fazla yönetim karmaşıklığı sunsa da, büyük ölçekli ve kritik iş yükleri için daha fazla kontrol ve esneklik sağlar.

• Dockerfile optimizasyonu için ne gibi ipuçları var?

  Dockerfile optimizasyonu için en iyi uygulamalar şunlardır: Azaltılmış temel görüntüler kullanın (örneğin, -slim veya -alpine etiketli görüntüler), her bir RUN komutunun ayrı bir katman oluşturduğunu unutun ve gereksiz katmanları birleştirmek için birden fazla komutu tek bir RUN içinde birleştirin, çok aşamalı (multi-stage) derlemeler kullanarak derleme bağımlılıklarını nihai üretim görüntüsünden ayırın ve böylece görüntü boyutunu küçültün, önbellekleme katmanlarını akıllıca kullanın (sık değişen şeyleri sona doğru koyun), ve .dockerignore dosyasını kullanarak gereksiz dosyaların derleme bağlamına kopyalanmasını engelleyin.

• Azure Container Instances'ı mobil uygulamalarla nasıl entegre edebilirim?

  Azure Container Instances doğrudan mobil uygulamalarla entegre edilmez, ancak mobil uygulamalarınızın arka uç hizmetlerini barındırmak için ACI'yi kullanabilirsiniz. Örneğin, mobil uygulamanızın API isteklerini işleyen bir mikroservisi ACI üzerinde çalıştırabilir ve bu mikroservise bir API Gateway (örneğin, Azure API Management) veya doğrudan genel bir DNS adı aracılığıyla erişim sağlayabilirsiniz. Mobil uygulamanız, bu API uç noktasına istek göndererek ACI'deki hizmetinizle iletişim kurabilir. Bu şekilde, mobil uygulamanızın ihtiyacı olan sunucu tarafı mantığı ACI üzerinde esnek ve ölçeklenebilir bir şekilde çalıştırılabilir.