Docker ve Docker Compose Kullanarak Ubuntu 14.04 Üzerinde Sürekli Entegrasyon Test Ortamı Nasıl Yapılandırılır?

Docker ve Docker Compose Kullanarak Ubuntu 14.04 Üzerinde Sürekli Entegrasyon Test Ortamı Nasıl Yapılandırılır?

Sürekli Entegrasyon (CI), modern yazılım geliştirme süreçlerinin vazgeçilmez bir parçasıdır. Geliştiricilerin kod değişikliklerini sık sık merkezi bir depoya entegre etmelerini ve her entegrasyonda otomatik testler çalıştırmalarını sağlayarak, hataların erken tespit edilmesine, entegrasyon sorunlarının azaltılmasına ve daha istikrarlı bir kod tabanının korunmasına yardımcı olur. Bu makalede, Docker ve Docker Compose’u kullanarak Ubuntu 14.04 işletim sistemi üzerinde nasıl güçlü ve taşınabilir bir sürekli entegrasyon test ortamı kuracağımızı adım adım inceleyeceğiz.

Ubuntu 14.04, güncel bir işletim sistemi olmasa da, bazı eski sistemlerde veya belirli kurumsal ortamlarda hala kullanılıyor olabilir. Bu nedenle, bu platform üzerinde Docker ve Docker Compose kurulumu ve yapılandırması, spesifik gereksinimleri olan kullanıcılar için değerli bir rehber olacaktır. Docker, uygulamaları ve bağımlılıklarını izole edilmiş konteynerler içinde paketleyerek “bir kez inşa et, her yerde çalıştır” prensibini mümkün kılar. Docker Compose ise birden fazla Docker konteynerini tanımlama ve çalıştırma sürecini basitleştiren bir araçtır. Bu iki teknolojinin birleşimi, test ortamlarımızın tutarlı, tekrarlanabilir ve bağımsız olmasını sağlar, bu da CI süreçleri için kritik öneme sahiptir.

Amacımız, geliştiricilerin kod değişikliklerini push ettiklerinde otomatik olarak tetiklenecek, uygulama ve veritabanı gibi servisleri içeren izole bir ortamda testleri çalıştıracak ve sonuçları raporlayacak bir yapı kurmaktır. Bu sayede, testlerin yerel makinelerde veya farklı ortamlarda farklı sonuçlar vermesi gibi “benim makinemde çalışıyordu” sorunlarının önüne geçeceğiz.

Sürekli Entegrasyonun Önemi ve Docker’ın Rolü

Sürekli Entegrasyon, yazılım geliştirme döngüsünü hızlandıran ve kalitesini artıran temel bir pratik olarak kabul edilir. Geliştiriciler, kodlarını kısa aralıklarla ana dal (main branch) ile birleştirerek, olası entegrasyon hatalarını ve çakışmaları erkenden tespit ederler. Bu sayede, büyük ve karmaşık birleştirme işlemlerinden kaynaklanan riskler minimize edilir. Otomatik testler, her bir kod değişikliğinin mevcut işlevselliği bozup bozmadığını kontrol ederken, geliştiricilere anında geri bildirim sağlar.

Docker, CI süreçlerine paha biçilmez faydalar sunar:

* İzolasyon: Her test koşumu, kendi izole konteyneri içinde çalışır. Bu, testlerin birbirini etkilemesini engeller ve temiz bir test ortamı sağlar.
* Tutarlılık: Geliştirme, test ve hatta üretim ortamlarında aynı Docker imajları kullanılarak, “benim makinemde çalışıyordu” sorunları ortadan kalkar. Herkes aynı bağımlılıklar ve konfigürasyonlarla çalışır.
* Taşınabilirlik: Docker konteynerleri, temel işletim sisteminden bağımsızdır. Bu, CI ortamının kolayca farklı sunuculara veya bulut platformlarına taşınabilmesini sağlar.
* Hızlı Kurulum ve Yıkım: Test ortamları saniyeler içinde ayağa kaldırılabilir ve testler bittikten sonra kolayca yok edilebilir. Bu, kaynak kullanımını optimize eder ve hızlı geri bildirim döngüleri sağlar.
* Bağımlılık Yönetimi: Uygulamanın tüm bağımlılıkları (veritabanları, önbellek servisleri vb.) Docker Compose ile tek bir dosya içinde tanımlanabilir ve yönetilebilir.

Ön Gereksinimler

Bu makaledeki adımları takip edebilmek için aşağıdaki ön gereksinimlere sahip olmanız gerekmektedir:

* Ubuntu 14.04 Sunucusu: İnternet erişimi olan, temiz bir Ubuntu 14.04 LTS (Trusty Tahr) sunucusu. SSH erişiminiz olması tercih edilir.
* Sudo Yetkileri: Sunucuda sudo komutunu kullanabilen bir kullanıcı hesabına sahip olmanız gerekmektedir.
* Temel Linux Bilgisi: Komut satırı kullanımı, dosya sisteminde gezinme gibi temel Linux bilgisi.
* Temel Docker ve Docker Compose Bilgisi: Konteynerler, imajlar, servisler gibi temel kavramlara aşina olmak.
* Git: Proje kodunu sunucuya klonlamak için Git yüklü olması faydalıdır.

Ubuntu 14.04 Üzerine Docker Kurulumu

Ubuntu 14.04, Docker’ın daha eski sürümleriyle uyumlu olduğundan, kurulum adımları güncel Ubuntu sürümlerinden biraz farklılık gösterebilir. Docker CE (Community Edition) sürümünü kuracağız.

Sistem Güncellemesi ve Gerekli Paketlerin Kurulumu

İlk olarak, sistem paket listemizi güncelleyelim ve Docker’ın düzgün çalışması için gerekli bazı paketleri kuralım:

sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common

* apt-transport-https: HTTPS üzerinden APT depolarına erişim sağlar.
* ca-certificates: SSL/TLS sertifikalarını doğrulamak için gereklidir.
* curl: URL’lerden dosya indirmek için kullanılır.
* software-properties-common: Depo ekleme gibi işlemleri yönetmek için kullanılır.

Docker GPG Anahtarını Ekleme

Docker’ın resmi deposundan indirdiğimiz paketlerin güvenilirliğini doğrulamak için GPG anahtarını sistemimize eklememiz gerekiyor:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Bu komut, Docker’ın GPG anahtarını indirir ve apt-key add komutuyla sistemimize ekler.

Docker APT Deposunu Ekleme

Şimdi, Docker’ın resmi deposunu sistemimizin APT kaynaklarına eklemeliyiz. Ubuntu 14.04 için trusty kod adını kullanacağız:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu trusty stable"

Bu komut, Docker CE’nin kararlı (stable) sürümünü içeren depoyu ekler. Ardından, yeni depoyu algılaması için paket listemizi tekrar güncelleyelim:

sudo apt-get update

Docker CE Kurulumu

Artık Docker CE’yi kurmaya hazırız:

sudo apt-get install -y docker-ce

Bu komut, Docker motorunu ve ilgili bileşenleri sisteminize kuracaktır.

Docker Servisini Başlatma ve Etkinleştirme

Kurulumdan sonra Docker servisi otomatik olarak başlamazsa, manuel olarak başlatabilir ve sistem başlangıcında otomatik olarak başlaması için etkinleştirebilirsiniz:

sudo systemctl start docker
sudo systemctl enable docker

Ubuntu 14.04, systemctl yerine upstart kullanabilir. Eğer systemctl komutu hata verirse, aşağıdaki komutları deneyin:

sudo service docker start
sudo update-rc.d docker enable

Kullanıcıyı docker Grubuna Ekleme

sudo kullanmadan Docker komutlarını çalıştırabilmek için kullanıcınızı docker grubuna eklemeniz önerilir. Bu, CI süreçlerinde otomasyonu kolaylaştırır:

sudo usermod -aG docker $USER

Bu komutu çalıştırdıktan sonra, değişikliğin etkili olması için oturumu kapatıp tekrar açmanız veya sunucuyu yeniden başlatmanız gerekmektedir.

Docker Kurulumunu Test Etme

Docker’ın düzgün çalıştığını doğrulamak için basit bir test konteyneri çalıştıralım:

docker run hello-world

Eğer her şey yolundaysa, Docker’ın bir test imajını indirip bir konteyner içinde çalıştırdığını ve çıktı olarak “Hello from Docker!” mesajını göreceksiniz.

Docker Compose Kurulumu

Docker Compose, birden fazla Docker konteynerini tanımlama ve çalıştırma aracıdır. YAML dosyaları kullanarak tüm servislerinizi yapılandırmanıza olanak tanır.

Docker Compose İndirme

Docker Compose’u doğrudan GitHub deposundan indireceğiz. En son kararlı sürümü indirmek için aşağıdaki komutu kullanabilirsiniz. (Bu makale yazıldığı sırada 1.29.2 en güncel kararlı sürümdü. Siz en güncel sürümü kontrol edebilirsiniz.)

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Bu komut, işletim sisteminize ve mimarinize uygun Docker Compose ikili dosyasını indirir ve /usr/local/bin dizinine docker-compose adıyla kaydeder.

Çalıştırılabilir İzinleri Verme

İndirilen dosyayı çalıştırılabilir hale getirmemiz gerekiyor:

sudo chmod +x /usr/local/bin/docker-compose

Docker Compose Kurulumunu Test Etme

Kurulumun başarılı olduğunu doğrulamak için sürüm kontrolü yapalım:

docker-compose --version

Çıktıda Docker Compose sürüm numarasını görmeniz gerekmektedir, örneğin: docker-compose version 1.29.2, build 5ffc4cb2.

Sürekli Entegrasyon Ortamı İçin Temel Proje Yapısı

CI ortamımızı yapılandırmadan önce, örnek bir proje yapısına ihtiyacımız var. Tipik bir web uygulaması için aşağıdaki gibi bir yapı düşünebiliriz:

my-ci-project/
├── app/
│   ├── Dockerfile             # Uygulama için Dockerfile
│   ├── requirements.txt       # Python bağımlılıkları (örnek)
│   └── app.py                 # Ana uygulama kodu (örnek)
├── tests/
│   ├── Dockerfile.test        # Test ortamı için özel Dockerfile (isteğe bağlı)
│   └── run_tests.py           # Testleri çalıştıran betik (örnek)
├── docker-compose.yml         # Docker Compose yapılandırma dosyası
└── .dockerignore              # Docker imajı oluştururken göz ardı edilecek dosyalar

Bu yapı, uygulamanın kodunu (app/), testlerini (tests/) ve Docker yapılandırma dosyalarını ayrı ayrı tutmamızı sağlar.

Dockerfile ve Dockerfile.test Oluşturma

Şimdi, örnek projemiz için Dockerfile’ları oluşturalım. Bir Python uygulamasını baz alarak ilerleyeceğiz, ancak bu prensipler diğer diller için de geçerlidir.

Uygulama Dockerfile (app/Dockerfile)

Bu Dockerfile, ana uygulamamızı çalıştırmak için gerekli imajı oluşturacaktır.

# app/Dockerfile
Ubuntu 14.04 ile uyumlu eski bir Python sürümü seçelim
FROM python:3.6-slim-stretch 

Çalışma dizinini ayarla
WORKDIR /app

Bağımlılıkları kopyala ve kur
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

Uygulama kodunu kopyala
COPY . .

Uygulamanın çalışacağı portu belirt (isteğe bağlı)
EXPOSE 8000

Uygulamayı başlat
CMD ["python", "app.py"]

app/requirements.txt içeriği (örnek):

Flask
gunicorn
psycopg2-binary

app/app.py içeriği (örnek, basit bir Flask uygulaması):

from flask import Flask
import os
import psycopg2

app = Flask(__name__)

@app.route('/')
def hello():
    db_url = os.getenv("DATABASE_URL", "postgres://user:password@localhost:5432/mydatabase")
    try:
        conn = psycopg2.connect(db_url)
        cur = conn.cursor()
        cur.execute("SELECT 1")
        db_status = "Veritabanı bağlantısı başarılı!"
        cur.close()
        conn.close()
    except Exception as e:
        db_status = f"Veritabanı bağlantısı hatası: {e}"
    return f"Merhaba, Docker CI ortamı! 
 {db_status}"

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

Test Ortamı Dockerfile (tests/Dockerfile.test)

Testler için ayrı bir Dockerfile kullanmak, test bağımlılıklarını uygulama imajına dahil etmeyerek imaj boyutunu küçültmeye ve uygulama imajını daha temiz tutmaya yardımcı olur.

# tests/Dockerfile.test
FROM python:3.6-slim-stretch

Çalışma dizinini ayarla
WORKDIR /app

Bağımlılıkları kopyala ve kur (uygulama ve test bağımlılıkları)
COPY app/requirements.txt .
COPY tests/test_requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt \
    && pip install --no-cache-dir -r test_requirements.txt

Uygulama ve test kodunu kopyala
COPY app/. /app
COPY tests/. /tests

Test komutunu varsayılan olarak ayarla (Docker Compose'da üzerine yazılabilir)
CMD ["python", "/tests/run_tests.py"]

tests/test_requirements.txt içeriği (örnek):

pytest
pytest-cov

tests/run_tests.py içeriği (örnek, basit bir pytest betiği):

import pytest
import os
import sys

Pytest'in uygulama kodunu bulabilmesi için PYTHONPATH'e ekle
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../app')))

def run_tests():
    # Pytest'i çalıştır ve sonuçları raporla
    # Bu örnekte, basit bir test dosyası oluşturacağız
    # Örneğin, tests/test_app.py
    print("Testler Başlıyor...")
    # Pytest'i programatik olarak çalıştırmak
    # pytest.main(['-v', '/tests/test_app.py'])
    
    # Basit bir başarılı test senaryosu
    print("Basit bir test başarılı.")
    return 0 # Başarılı dönüş kodu

if __name__ == '__main__':
    # Gerçek bir projede pytest.main() kullanılacaktır.
    # Burada manuel olarak bir test sonucu döndürüyoruz.
    exit_code = run_tests()
    sys.exit(exit_code)

tests/test_app.py (örnek test dosyası):

import pytest
from app import app # app.py dosyasındaki Flask uygulamasını import et

@pytest.fixture
def client():
    app.config['TESTING'] = True
    with app.test_client() as client:
        yield client

def test_homepage(client):
    rv = client.get('/')
    assert b"Merhaba, Docker CI ortamı!" in rv.data
    assert rv.status_code == 200

def test_db_connection_message(client):
    rv = client.get('/')
    # Veritabanı bağlı olmasa bile hata mesajı dönmeli
    assert b"Veritabanı bağlantısı" in rv.data

.dockerignore dosyası (proje kök dizininde):

.git
.gitignore
__pycache__
*.pyc
.venv
.vscode
node_modules
tmp/

Bu dosya, Docker imajı oluşturulurken gereksiz dosyaların kopyalanmasını engeller, bu da imaj boyutunu azaltır ve build süresini hızlandırır.

docker-compose.yml Yapılandırması

Şimdi, uygulama, veritabanı ve test servislerimizi tanımlayan docker-compose.yml dosyasını oluşturalım.

# docker-compose.yml
version: '3.8' # Ubuntu 14.04 ve Docker Compose 1.29.2 için en uygun versiyonlardan biri

services:
  # Uygulama servisi
  app:
    build:
      context: ./app # app/ dizinindeki Dockerfile'ı kullan
      dockerfile: Dockerfile
    ports:
      - "8000:8000" # Host'un 8000 portunu konteynerin 8000 portuna yönlendir
    volumes:
      - ./app:/app # Kod değişikliklerini anında yansıtmak için bağlama noktası
    environment:
      # Veritabanı bağlantı bilgileri
      - DATABASE_URL=postgres://user:password@db:5432/mydatabase
    depends_on:
      - db # app servisi, db servisi başlamadan başlamaz

  # Veritabanı servisi
  db:
    image: postgres:9.6 # Ubuntu 14.04 ile uyumlu eski bir PostgreSQL sürümü
    environment:
      - POSTGRES_DB=mydatabase
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - db_data:/var/lib/postgresql/data # Veritabanı verilerini kalıcı hale getir

  # Test servisi
  test:
    build:
      context: . # Proje kök dizinini bağlam olarak kullan
      dockerfile: tests/Dockerfile.test # tests/Dockerfile.test dosyasını kullan
    volumes:
      - ./app:/app # Uygulama koduna erişim için
      - ./tests:/tests # Test kodlarına erişim için
    environment:
      - DATABASE_URL=postgres://user:password@db:5432/mydatabase
    depends_on:
      - db # Testler veritabanına ihtiyaç duyabilir
    command: python /tests/run_tests.py # Testleri çalıştıracak komut

volumes:
  db_data: # Veritabanı verileri için isimlendirilmiş bir volume

* version: '3.8': Docker Compose dosya formatının sürümünü belirtir. Docker Compose 1.29.2 ile uyumludur.
* services: Tanımlanacak servisleri içerir.
* app: Ana web uygulamamızı çalıştıran servistir.
* build: app/Dockerfile dosyasını kullanarak bir imaj oluşturur.
* ports: Host makinenin 8000 portunu konteynerin 8000 portuna eşler.
* volumes: Yerel app dizinini konteynerin /app dizinine bağlar. Bu, kod değişikliklerinin konteyner içinde anında görünmesini sağlar.
* environment: Uygulamanın kullanacağı ortam değişkenlerini (veritabanı URL’si gibi) ayarlar.
* depends_on: app servisinin db servisi başlamadan önce başlatılmamasını sağlar.
* db: PostgreSQL veritabanı servisi.
* image: postgres:9.6 imajını kullanır. Ubuntu 14.04 ile uyumlu, daha eski ve kararlı bir sürüm seçilmiştir.
* environment: Veritabanı adını, kullanıcı adını ve şifresini ayarlar.
* volumes: db_data adında bir volume kullanarak veritabanı verilerini konteyner yeniden başlatılsa bile kalıcı hale getirir.
* test: Testleri çalıştıran servistir.
* build: tests/Dockerfile.test dosyasını kullanarak bir imaj oluşturur.
* volumes: Uygulama ve test kodlarına erişim için bağlama noktaları oluşturur.
* environment: Uygulama gibi, testlerin de veritabanına erişmesi gerekiyorsa ortam değişkenleri sağlanır.
* depends_on: Testlerin başlamadan önce veritabanının hazır olmasını sağlar.
* command: Konteynerin başlatıldığında çalıştıracağı komutu belirtir (test betiğini çalıştırmak).
* volumes: Kalıcı depolama için kullanılan isimlendirilmiş volume’leri tanımlar.

CI İş Akışı ve Otomasyon

Artık Docker ve Docker Compose ile sürekli entegrasyon ortamımızı tanımladık. Sıra geldi bu ortamı kullanarak testleri çalıştırmaya ve otomatikleştirmeye.

Manuel Test Çalıştırma

Geliştirme aşamasında veya CI sistemine entegre etmeden önce testleri manuel olarak çalıştırmak isteyebilirsiniz:

1. Proje dizinine gidin:

cd my-ci-project

2. Tüm servisleri inşa edin ve çalıştırın:

docker-compose up --build -d

Bu komut, app ve db servislerini arka planda (-d) başlatacaktır. --build parametresi, Dockerfile’lardaki değişiklikleri algılayıp imajları yeniden oluşturur.
3. Test servisini çalıştırın:

docker-compose run --rm test

* run: Belirli bir servisi çalıştırır.
* --rm: Konteyner çıktıktan sonra otomatik olarak kaldırılmasını sağlar (temizlik için idealdir).
* test: docker-compose.yml dosyasında tanımladığımız test servisi.

Bu komut, test servisini başlatacak, command bölümünde tanımlanan test betiğini çalıştıracak ve testler bittikten sonra konteyneri kaldıracaktır. Test betiğinizin çıkış koduna (0 başarı, 1 veya daha fazlası hata) göre Docker Compose komutu da başarılı veya başarısız olacaktır.

Eğer sadece testleri çalıştırıp diğer servislerin otomatik olarak durmasını istiyorsanız, docker-compose up komutunu test servisiyle kullanıp abort-on-container-exit bayrağını ekleyebilirsiniz:

docker-compose up --build test --abort-on-container-exit

Bu komut, test servisi tamamlandığında (başarılı veya başarısız) tüm bağımlı servisleri (bu durumda db) de durduracaktır.

Otomasyon Araçları ile Entegrasyon

Gerçek bir sürekli entegrasyon ortamında, bu adımlar Jenkins, GitLab CI, CircleCI gibi bir CI/CD aracı tarafından otomatik olarak tetiklenir. Temel iş akışı şuna benzer:

1. Kod Değişikliği: Geliştirici kodunu Git deposuna (örneğin GitHub, GitLab) gönderir.
2. CI Tetikleyici: CI/CD aracı, bu değişikliği algılar ve bir CI işi başlatır.
3. Kod Klonlama: CI sunucusu, projenin en son sürümünü klonlar.

git clone 
    cd my-ci-project

4. Docker İmajlarını Oluşturma ve Servisleri Başlatma: CI aracı, docker-compose.yml dosyasını kullanarak tüm servisleri (uygulama, veritabanı, test) inşa eder ve başlatır.

docker-compose build
    docker-compose run --rm test

Veya tüm servisleri arka planda başlatıp sonra testi çalıştırmak için:

docker-compose up -d db # Sadece bağımlı servisleri başlat
    docker-compose run --rm test

Bu komut, test servisinin çalışmasını bekler ve çıkış koduna göre CI işinin durumunu belirler. Testler başarılı olursa, CI işi başarılı sayılır; aksi takdirde başarısız olur.
5. Temizlik: Testler tamamlandıktan sonra, CI sunucusu konteynerleri ve ağları temizler. docker-compose down komutu bunun için kullanılabilir.

docker-compose down

Basit Bir Bash Betiği ile Otomasyon Örneği:

Eğer Jenkins gibi bir CI aracı kullanmıyorsanız, basit bir bash betiği ile de bu süreci otomatikleştirebilirsiniz. Bu betiği bir Git hook’u ile veya zamanlanmış bir görev olarak çalıştırabilirsiniz.

#!/bin/bash

Hata durumunda betiği durdur
set -e

PROJECT_DIR="/home/ciuser/my-ci-project" # Projenizin yolu
REPO_URL="https://github.com/youruser/my-ci-project.git" # Git depo URL'niz

echo "CI İşlemi Başlıyor..."

Proje dizinine git veya klonla
if [ -d "$PROJECT_DIR" ]; then
  echo "Mevcut projeyi güncelliyor..."
  cd "$PROJECT_DIR"
  git pull origin main # Ana dalınızı güncelleyin
else
  echo "Projeyi klonluyor..."
  git clone "$REPO_URL" "$PROJECT_DIR"
  cd "$PROJECT_DIR"
fi

Docker Compose servislerini inşa et ve test servisini çalıştır
echo "Docker imajları inşa ediliyor ve testler çalıştırılıyor..."
Sadece test servisi ve bağımlı servislerin ayağa kalkıp test bitince kapanmasını sağlar
docker-compose up --build test --abort-on-container-exit

Testler başarılı olursa bu noktaya gelinir
echo "Tüm testler başarıyla tamamlandı!"

Temizlik (isteğe bağlı, eğer --abort-on-container-exit kullanılmadıysa)
docker-compose down

echo "CI İşlemi Tamamlandı."

exit 0 # Başarılı çıkış

Bu betiği run_ci.sh olarak kaydedip chmod +x run_ci.sh ile çalıştırılabilir hale getirdikten sonra, bash run_ci.sh komutuyla CI sürecini başlatabilirsiniz.

İpuçları ve En İyi Uygulamalar

CI ortamınızı daha verimli ve güvenilir hale getirmek için bazı ipuçları:

* Küçük ve Odaklanmış İmajlar: alpine gibi minimal temel imajlar kullanarak Docker imaj boyutlarını küçültün. Bu, indirme ve oluşturma sürelerini azaltır.
* .dockerignore Kullanımı: İmajınıza gereksiz dosyaların (örneğin .git dizini, node_modules, __pycache__) dahil edilmesini engellemek için .dockerignore dosyasını kullanın.
* Docker Katman Önbellekleme: Dockerfile içindeki adımların sırasını optimize edin. Sık değişen adımları (örneğin kod kopyalama) sona bırakın, nadiren değişen adımları (örneğin bağımlılık kurulumu) başa alın. Bu, Docker’ın katman önbelleklemesini daha etkin kullanmasını sağlar ve inşa sürelerini kısaltır.
* Test Veritabanı Yönetimi: Her test koşumunda temiz bir veritabanı sağlamak kritiktir. docker-compose.yml içindeki volumes tanımını kaldırarak veya test betiğinizde veritabanını sıfırlayarak bunu yapabilirsiniz. Testlerin sonunda veritabanı volume’unu kaldırmak da bir seçenektir (docker volume rm my-ci-project_db_data).
* Çevre Değişkenleri: Hassas bilgileri (veritabanı şifreleri, API anahtarları) doğrudan docker-compose.yml içine yazmaktan kaçının. Bunun yerine, .env dosyaları kullanın veya CI/CD araçlarının sır yönetimi özelliklerinden faydalanın.
* Test Kapsamı: Birim testleri, entegrasyon testleri ve kabul testlerini CI sürecinize dahil edin. Her bir test türü farklı bir değeri doğrular.
* Konteyner Temizliği: Başarısız CI koşumlarından sonra veya düzenli aralıklarla kullanılmayan Docker imajlarını, konteynerleri ve volume’leri temizleyin (docker system prune -a).
* Sağlık Kontrolleri: docker-compose.yml içinde healthcheck tanımlayarak servislerin gerçekten hazır olup olmadığını kontrol edebilirsiniz. Özellikle veritabanı gibi servislerin tamamen başlatılmasını beklemek için faydalıdır.
* Versiyonlama: Docker imajlarınızı ve Docker Compose dosyalarınızı projenizin Git deposuyla birlikte versiyonlayın. Bu, ortamınızın her zaman tekrarlanabilir olmasını sağlar.

Sorun Giderme

Kurulum veya çalıştırma sırasında karşılaşabileceğiniz bazı yaygın sorunlar ve çözümleri:

* docker komutu bulunamıyor veya izin hatası:
* Kullanıcınızı docker grubuna eklediğinizden ve oturumu yeniden başlattığınızdan emin olun (sudo usermod -aG docker $USER).
* Docker servisi çalışıyor mu kontrol edin (sudo systemctl status docker veya sudo service docker status).
* docker-compose komutu bulunamıyor:
* Docker Compose’u doğru dizine indirdiğinizden (/usr/local/bin) ve çalıştırılabilir izinleri verdiğinizden emin olun (sudo chmod +x /usr/local/bin/docker-compose).
* Konteynerler başlamıyor veya çöküyor:
* docker logs komutunu kullanarak konteyner loglarını kontrol edin.
* docker inspect ile konteynerin detaylı yapılandırmasına ve durumuna bakın.
* docker-compose up komutunu -d olmadan çalıştırarak, konteynerlerin başlatılırkenki çıktılarını doğrudan terminalde görebilirsiniz.
* Ağ sorunları (servisler birbirini göremiyor):
* docker-compose.yml dosyasındaki depends_on ve environment değişkenlerinin doğru ayarlandığından emin olun. Servisler, servis adlarıyla birbirlerine erişebilirler (örneğin db servisine db host adıyla).
* Firewall kurallarını kontrol edin (Ubuntu 14.04’te ufw veya iptables). Docker, kendi ağ kurallarını oluşturur, ancak bazen çakışmalar olabilir.
* Yetersiz kaynak (bellek, CPU):
* Özellikle eski bir sunucuda veya çok sayıda servisle çalışırken kaynak sıkıntısı yaşanabilir. docker stats komutu ile konteynerlerin kaynak kullanımını izleyebilirsiniz. Gereksiz konteynerleri ve imajları temizleyin.

Sonuç

Bu makalede, Ubuntu 14.04 gibi daha eski bir işletim sistemi üzerinde Docker ve Docker Compose kullanarak nasıl sağlam ve etkili bir sürekli entegrasyon test ortamı kuracağımızı detaylı bir şekilde inceledik. Docker’ın izolasyon, tutarlılık ve taşınabilirlik gibi avantajları sayesinde, geliştirme sürecinizi hızlandıracak ve yazılım kalitenizi artıracak güvenilir bir test altyapısı oluşturduk.

Kurulum adımlarından örnek bir proje yapısına, Dockerfile ve docker-compose.yml yapılandırmalarından CI iş akışının otomasyonuna kadar her adımı ele aldık. Ayrıca, performans, güvenlik ve temizlik gibi konularda en iyi uygulamalar ve karşılaşabileceğiniz olası sorunlara yönelik çözümler sunduk.

Unutulmamalıdır ki, Ubuntu 14.04 artık uzun süreli destek (LTS) almıyor ve güvenlik güncellemeleri durdurulmuştur. Mümkün olduğunca, daha yeni ve desteklenen bir Ubuntu sürümüne (örneğin Ubuntu 20.04 LTS veya 22.04 LTS) geçiş yapmanız şiddetle tavsiye edilir. Ancak, bu makaledeki bilgiler, eski sistemlerdeki mevcut altyapıları modernize etmek veya belirli kısıtlamalar altında çalışmak zorunda olanlar için değerli bir kaynak olacaktır.

Bu CI ortamı, sadece testlerinizi otomatikleştirmekle kalmayacak, aynı zamanda geliştirme ekibinizin daha hızlı iterasyon yapmasına ve daha güvenle kod dağıtmasına olanak tanıyacaktır. Sürekli entegrasyon ve Docker’ın gücünü birleştirerek, yazılım geliştirme süreçlerinizi bir sonraki seviyeye taşıyabilirsiniz.