Docker imajlarınızı nerede saklıyorsunuz? Docker Hub mu, AWS ECR mi, yoksa başka bir yerde mi? Peki ya size GitHub’ın kendi konteyner kayıt defteri (Container Registry) sunduğunu söylesem? Evet, doğru duydunuz! GitHub Container Registry (GHCR), Docker imajlarınızı doğrudan GitHub ekosisteminde saklamanıza ve yönetmenize olanak tanıyan güçlü bir araç.

💰 Peki Bu Ücretsiz mi?

İşin en güzel tarafı şu: Herkese açık (public) konteyner imajları tamamen ücretsiz! Depolama limiti yok, veri transferi limiti yok. Açık kaynak projeleriniz için GHCR’ı gönül rahatlığıyla kullanabilirsiniz. Üstelik public imajlarınızı herkes kimlik doğrulaması yapmadan indirebilir.

Özel (private) imajlar için ise GitHub planınıza göre belirli kotalar geçerli:

🎁 Bonus: GitHub Actions workflow’larınızda GITHUB_TOKEN kullanarak yaptığınız imaj indirmeleri veri transferi kotanızdan düşülmez! Yani CI/CD pipeline’larınızda GHCR’dan imaj çekmek tamamen ücretsiz.

Kota aşımı durumunda ne olur? Eğer ödeme yönteminiz tanımlı değilse işlemleriniz engellenir. Tanımlıysa, fazla kullanım için ücretlendirilirsiniz. Depolama için GB başına saatlik hesaplama yapılır, veri transferi ise GB başına faturalandırılır.

🤔 Docker Hub Varken Neden GHCR Seçeyim?

Haklısınız, Docker Hub da public imajlar için ücretsiz. Peki o zaman neden GHCR’ı tercih edelim? İşte Docker Hub’ın sizi zorlayabileceği noktalar ve GHCR’ın öne çıktığı durumlar:

Docker Hub’ın Sınırlamaları:

Eğer popüler bir açık kaynak proje geliştiriyorsanız veya CI/CD pipeline’ınız sık sık imaj çekiyorsa, Docker Hub’ın rate limiting’i ciddi sorun yaratabilir. GHCR’da böyle bir sınırlama yok.

GHCR’ı Tercih Etmeniz Gereken Durumlar:

1. Zaten GitHub kullanıyorsanız → Kod ve imajlar tek çatı altında, ekstra hesap yok
2. GitHub Actions kullanıyorsanız → GITHUB_TOKEN ile sıfır yapılandırma, ekstra secret gerekmez
3. CI/CD yoğunluğunuz yüksekse → Rate limiting yok, pipeline’lar takılmaz
4. Takım çalışması yapıyorsanız → GitHub organizasyon yapısıyla entegre izin yönetimi
5. Private + Public karışık kullanıyorsanız → Tek platform, tek yönetim

Docker Hub’ı Tercih Etmeniz Gereken Durumlar:

1. Maksimum erişilebilirlik istiyorsanız → Docker Hub hala varsayılan, herkes bilir
2. Resmi imajlara ihtiyacınız varsa → nginx, postgres, node gibi imajlar Docker Hub’da
3. GitHub dışında geliştirme yapıyorsanız → GitLab, Bitbucket kullanıcıları için daha pratik

💡 Pro Tip: İkisini birlikte de kullanabilirsiniz! Geliştirme ve CI/CD için GHCR, son kullanıcı dağıtımı için Docker Hub. GitHub Actions ile her iki registry’e aynı anda push yapabilirsiniz.

Bu yazıda, GHCR’ı nasıl kullanacağınızı adım adım öğreneceğiz. Manuel işlemlerden GitHub Actions ile otomasyona, özel (private) ve herkese açık (public) depo kullanımından çoklu platform (multi-platform) derlemelerine kadar her şeyi ele alacağız. Üstelik tüm bunları gerçek bir Python FastAPI projesi üzerinden göstereceğiz!

İçindekiler

1. Konteyner Kayıt Defteri (Container Registry) Nedir?
2. GitHub Container Registry (GHCR) Nedir?
3. Ön Gereksinimler
4. Örnek FastAPI Projemizi Hazırlayalım
5. Senaryo 1: Manuel Push ve Pull İşlemleri
6. Senaryo 2: GitHub Actions ile Otomatik Build ve Push
7. Senaryo 3: Özel ve Herkese Açık Depo Kullanımı
8. Güvenlik ve Erişim Yönetimi
9. Çoklu Platform (Multi-Platform) Image Build
10. Sonuç

1. Konteyner Kayıt Defteri (Container Registry) Nedir?

Docker ile çalışmaya başladığınızda karşınıza çıkan ilk kavramlardan biri konteyner imajlarıdır (container images). Peki bu imajları nerede saklayacağız? İşte tam bu noktada Konteyner Kayıt Defteri (Container Registry) devreye giriyor.

Temel Kavramlar

Konteyner İmajı (Container Image), bir uygulamayı çalıştırmak için gereken her şeyi içeren paketlenmiş dosya sistemidir. Kod, çalışma zamanı (runtime), sistem araçları, kütüphaneler ve ayarlar tek bir pakette toplanır. Bu imajlar katmanlı (layered) bir yapıya sahiptir ve her katman bir öncekinin üzerine inşa edilir.

Konteyner Kayıt Defteri (Container Registry) ise bu imajları depolamak, yönetmek ve dağıtmak için kullanılan merkezi bir depodur. Tıpkı Git’in kaynak kodu için yaptığı gibi, container registry de Docker imajları için versiyon kontrolü ve dağıtım altyapısı sağlar.

Container Registry Ne İşe Yarar?

Bir container registry kullanarak şunları yapabilirsiniz:

• Depolama (Storage): İmajlarınızı güvenli bir şekilde saklayabilirsiniz
• Versiyon Kontrolü (Versioning): İmajların farklı versiyonlarını etiketler (tags) ile yönetebilirsiniz
• Dağıtım (Distribution): İmajları farklı ortamlara (geliştirme, test, üretim) kolayca dağıtabilirsiniz
• Erişim Kontrolü (Access Control): Kimin hangi imaja erişebileceğini belirleyebilirsiniz
• Güvenlik Taraması (Security Scanning): İmajlardaki güvenlik açıklarını tespit edebilirsiniz

Yaygın Konteyner Kayıt Defteri Ürünleri

Piyasada birçok container registry çözümü bulunuyor. İşte en yaygın kullanılan 5 tanesi:

1. Docker Hub

Docker Hub, Docker’ın resmi ve en popüler konteyner kayıt defteridir. Dünya genelinde milyonlarca geliştirici tarafından kullanılır.

Kullanım örneği:

docker pull nginx:latest
docker push kullaniciadi/uygulamam:v1.0

2. Amazon Elastic Container Registry (ECR)

AWS’nin yönetilen konteyner kayıt servisidir. AWS ekosistemi ile derin entegrasyon sunar.

Kullanım örneği:

aws ecr get-login-password | docker login --username AWS --password-stdin 123456789.dkr.ecr.eu-west-1.amazonaws.com
docker push 123456789.dkr.ecr.eu-west-1.amazonaws.com/uygulamam:v1.0

3. Google Artifact Registry

Google Cloud’un yeni nesil artifact yönetim servisidir. Eski Google Container Registry’nin (GCR) yerini almıştır.

Kullanım örneği:

gcloud auth configure-docker europe-west1-docker.pkg.dev
docker push europe-west1-docker.pkg.dev/proje-id/repo-adi/imaj:tag

4. Azure Container Registry (ACR)

Microsoft Azure’un yönetilen Docker kayıt servisidir. Azure DevOps ve Azure Kubernetes Service ile sorunsuz çalışır.

Kullanım örneği:

az acr login --name benimregistrym
docker push benimregistrym.azurecr.io/uygulamam:v1.0

5. Harbor

VMware tarafından geliştirilen açık kaynaklı (open source) bir container registry çözümüdür. Kendi sunucularınızda barındırabilirsiniz (self-hosted).

Kullanım örneği:

docker login harbor.sirketiniz.com
docker push harbor.sirketiniz.com/proje/uygulamam:v1.0

Karşılaştırma Tablosu

Şimdi bu ürünlerin arasında özel bir yere sahip olan GitHub Container Registry’yi (GHCR) detaylıca inceleyelim!

2. GitHub Container Registry (GHCR) Nedir?

GitHub Container Registry (GHCR), GitHub’ın sunduğu bir konteyner imaj kayıt servisidir. Docker Hub’a benzer şekilde çalışır, ancak GitHub ekosistemine sıkı sıkıya entegre edilmiştir.

GHCR’ın temel avantajları şunlardır:

• Tek Çatı Altında Yönetim: Kaynak kodunuz ve konteyner imajlarınız aynı platformda bulunur
• Esnek İzin Yönetimi: İmaj izinlerini depodan bağımsız olarak ayarlayabilirsiniz
• GitHub Actions Entegrasyonu: CI/CD pipeline’larınızla sorunsuz çalışır
• Ücretsiz Herkese Açık İmajlar: Public imajlar için depolama limiti yoktur
• Anonim Erişim: Herkese açık imajlara kimlik doğrulaması olmadan erişilebilir

GHCR’ın paket ad alanı (namespace) ghcr.io şeklindedir ve Docker, OCI (Open Container Initiative) gibi konteyner imaj formatlarını destekler.

3. Ön Gereksinimler

Başlamadan önce aşağıdakilerin hazır olduğundan emin olalım:

• GitHub Hesabı: Henüz yoksa github.com adresinden oluşturabilirsiniz
• Docker: Yerel makinenizde Docker Engine kurulu olmalı
• Kişisel Erişim Jetonu (Personal Access Token – PAT): GHCR’a kimlik doğrulaması için gerekli
• Git: Versiyon kontrol işlemleri için

Kişisel Erişim Jetonu (PAT) Oluşturma

GHCR ile etkileşim kurmak için uygun izinlere sahip bir PAT oluşturmamız gerekiyor. Adımlar şöyle:

1. GitHub’da Settings (Ayarlar) sayfasına gidin
2. Sol menüden Developer settings > Personal access tokens > Tokens (classic) seçin
3. Generate new token (classic) butonuna tıklayın
4. Token’a açıklayıcı bir isim verin (örn: “GHCR Access”)
5. Aşağıdaki kapsamları (scopes) seçin:
   • read:packages – İmajları indirmek için
   • write:packages – İmajları yüklemek için
   • delete:packages – İmajları silmek için (opsiyonel)

💡 İpucu: repo kapsamı otomatik olarak seçilebilir, ancak bu gereksiz geniş erişim sağlar. Sadece write:packages kapsamı için şu URL’yi kullanabilirsiniz: https://github.com/settings/tokens/new?scopes=write:packages

6. Generate token butonuna tıklayın ve token’ı güvenli bir yere kaydedin

⚠️ Önemli: Token sadece bir kez gösterilir. Kaybederseniz yeni bir tane oluşturmanız gerekir.

4. Örnek FastAPI Projemizi Hazırlayalım

Şimdi GHCR’a yükleyeceğimiz örnek bir FastAPI uygulaması oluşturacağız. Bu basit bir API olacak ama gerçek dünya senaryolarını temsil edecek.

Proje Yapısı

fastapi-ghcr-demo/
├── app/
│   ├── __init__.py
│   └── main.py
├── requirements.txt
├── Dockerfile
└── .github/
    └── workflows/
        └── docker-publish.yml

app/main.py

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional
import os

app = FastAPI(
    title="FastAPI GHCR Demo",
    description="GitHub Container Registry örnek uygulaması",
    version="1.0.0"
)

class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None

@app.get("/")
def read_root():
    return {
        "message": "Merhaba! FastAPI GHCR Demo'ya hoş geldiniz 🚀",
        "environment": os.getenv("ENVIRONMENT", "development")
    }

@app.get("/health")
def health_check():
    return {"status": "healthy", "version": "1.0.0"}

@app.post("/items/")
def create_item(item: Item):
    item_dict = item.dict()
    if item.tax:
        price_with_tax = item.price + item.tax
        item_dict.update({"price_with_tax": price_with_tax})
    return item_dict

@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
    return {"item_id": item_id, "q": q}

app/init.py

# Bu dosya boş kalabilir

requirements.txt

fastapi==0.111.0
uvicorn[standard]==0.29.0
pydantic==2.7.0

Dockerfile

# Temel imaj olarak Python 3.12 slim kullanıyoruz
FROM python:3.12-slim

# Metadata etiketleri - GHCR için önemli!
LABEL org.opencontainers.image.source="https://github.com/KULLANICI_ADINIZ/fastapi-ghcr-demo"
LABEL org.opencontainers.image.description="FastAPI GHCR Demo Uygulaması"
LABEL org.opencontainers.image.licenses="MIT"

# Çalışma dizinini ayarla
WORKDIR /code

# Bağımlılıkları önce kopyala (cache optimizasyonu için)
COPY ./requirements.txt /code/requirements.txt

# Bağımlılıkları yükle
RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

# Uygulama kodunu kopyala
COPY ./app /code/app

# Port'u expose et
EXPOSE 8000

# Uygulamayı başlat
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

💡 İpucu: LABEL org.opencontainers.image.source etiketi çok önemlidir! Bu etiket, konteyner imajınızı GitHub deposuna otomatik olarak bağlar ve izinlerin miras alınmasını sağlar.

5. Senaryo 1: Manuel Push ve Pull İşlemleri

Şimdi Docker imajımızı manuel olarak GHCR’a nasıl yükleyeceğimizi ve indireceğimizi göreceğiz.

Adım 1: Docker ile GHCR’a Giriş Yapma

Öncelikle, oluşturduğumuz PAT ile GHCR’a giriş yapmamız gerekiyor:

# PAT'ı ortam değişkeni olarak kaydet (güvenlik için)
export CR_PAT=ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxx

# Docker ile GHCR'a giriş yap
echo $CR_PAT | docker login ghcr.io -u KULLANICI_ADINIZ --password-stdin

Başarılı bir giriş sonrası şu mesajı göreceksiniz:

Login Succeeded

💡 İpucu: Token’ı komut satırı geçmişine kaydetmemek için export komutunun başına bir boşluk ekleyebilirsiniz.

Adım 2: Docker İmajını Oluşturma (Build)

Proje dizininde aşağıdaki komutu çalıştırarak imajı oluşturalım:

# İmajı oluştur
docker build -t fastapi-ghcr-demo:latest .

# Oluşturulan imajı kontrol et
docker images | grep fastapi-ghcr-demo

Adım 3: İmajı GHCR Formatında Etiketleme (Tag)

GHCR’a yüklemek için imajı doğru formatta etiketlememiz gerekiyor:

# Format: ghcr.io/KULLANICI_ADINIZ/IMAJ_ADI:ETIKET
docker tag fastapi-ghcr-demo:latest ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest

# Versiyon etiketi de ekleyelim
docker tag fastapi-ghcr-demo:latest ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:1.0.0

Adım 4: İmajı GHCR’a Yükleme (Push)

Artık imajımızı GHCR’a yükleyebiliriz:

# Latest etiketi ile yükle
docker push ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest

# Versiyon etiketi ile de yükle
docker push ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:1.0.0

Başarılı bir yükleme sonrası çıktı şöyle görünecektir:

The push refers to repository [ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo]
5f70bf18a086: Pushed
...
latest: digest: sha256:abc123... size: 1234

Adım 5: İmajı GitHub’da Görüntüleme

Yüklenen imajı görmek için:

1. GitHub profilinize gidin
2. Packages sekmesine tıklayın
3. fastapi-ghcr-demo paketini göreceksiniz

Adım 6: İmajı İndirme (Pull)

Başka bir makinede veya temizledikten sonra imajı indirmek için:

# GHCR'a giriş yap (gerekirse)
echo $CR_PAT | docker login ghcr.io -u KULLANICI_ADINIZ --password-stdin

# İmajı indir
docker pull ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest

# Veya belirli bir versiyon
docker pull ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:1.0.0

Adım 7: İmajı Çalıştırma

docker run -d -p 8000:8000 --name fastapi-demo ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest

# API'yi test et
curl http://localhost:8000
curl http://localhost:8000/health

6. Senaryo 2: GitHub Actions ile Otomatik Build ve Push

Manuel işlemler güzel ama gerçek dünyada CI/CD pipeline’ları kullanırız. GitHub Actions ile her kod değişikliğinde otomatik olarak imaj oluşturup GHCR’a yükleyeceğiz.

.github/workflows/docker-publish.yml

name: Docker İmaj Build ve Push

on:
  push:
    branches: ['main']
    tags: ['v*']
  pull_request:
    branches: ['main']

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    
    # GITHUB_TOKEN için gerekli izinler
    permissions:
      contents: read
      packages: write
      attestations: write
      id-token: write

    steps:
      # 1. Kodu çek
      - name: Checkout repository
        uses: actions/checkout@v4

      # 2. QEMU kurulumu (multi-platform için)
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3

      # 3. Docker Buildx kurulumu
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      # 4. GHCR'a giriş yap
      - name: Log in to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      # 5. Metadata çıkar (etiketler ve labels)
      - name: Extract metadata (tags, labels)
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=schedule
            type=ref,event=branch
            type=ref,event=tag
            type=ref,event=pr
            type=sha,prefix=sha-
            type=raw,value=latest,enable=${{ github.ref == format('refs/heads/{0}', 'main') }}

      # 6. İmajı build et ve push et
      - name: Build and push Docker image
        id: push
        uses: docker/build-push-action@v6
        with:
          context: .
          push: ${{ github.event_name != 'pull_request' }}
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

      # 7. Build özeti oluştur
      - name: Generate artifact attestation
        uses: actions/attest-build-provenance@v1
        if: ${{ github.event_name != 'pull_request' }}
        with:
          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          subject-digest: ${{ steps.push.outputs.digest }}
          push-to-registry: true

Workflow Açıklaması

Bu workflow şunları yapar:

1. Tetikleyiciler: main branch’e push veya PR açıldığında çalışır
2. QEMU Kurulumu: Çoklu platform desteği için gerekli emülasyon katmanını kurar
3. Docker Buildx: Gelişmiş build özellikleri için Buildx’i yapılandırır
4. GHCR Girişi: GITHUB_TOKEN kullanarak otomatik kimlik doğrulaması yapar
5. Metadata: Akıllı etiketleme stratejisi uygular
6. Build ve Push: İmajı oluşturur ve GHCR’a yükler
7. Attestation: Build kanıtlama belgesi oluşturur (güvenlik için)

GITHUB_TOKEN vs PAT

GitHub Actions içinde GITHUB_TOKEN kullanmak önerilir:

• Otomatik oluşturulur: Her workflow çalışmasında GitHub tarafından otomatik olarak oluşturulur
• Minimum yetki: Sadece gerekli izinlere sahiptir
• Süresi dolar: Workflow tamamlandığında geçersiz olur
• Yönetim gerektirmez: PAT gibi manuel yönetim gerekmez

Workflow’u Aktifleştirme

1. Dosyayı .github/workflows/docker-publish.yml olarak kaydedin
2. Değişiklikleri commit edin ve main branch’e push edin
3. GitHub’da Actions sekmesinde workflow’un çalıştığını göreceksiniz

7. Senaryo 3: Özel ve Herkese Açık Depo Kullanımı

GHCR, esnek görünürlük (visibility) ayarları sunar. İmajlarınızı özel (private), dahili (internal – Enterprise için) veya herkese açık (public) yapabilirsiniz.

Varsayılan Görünürlük

GHCR’a ilk kez bir imaj yüklediğinizde, varsayılan görünürlük private (özel) olarak ayarlanır. Bu, imaja erişmek için kimlik doğrulaması gerektiği anlamına gelir.

Görünürlük Değiştirme

İmajın görünürlüğünü değiştirmek için:

1. GitHub’da Packages sekmesine gidin
2. İlgili paketi seçin
3. Package settings bölümüne gidin
4. Danger Zone altında Change visibility seçeneğine tıklayın
5. İstediğiniz görünürlüğü seçin ve onaylayın

⚠️ Dikkat: Bir imajı public yaptıktan sonra tekrar private yapamazsınız!

Görünürlük Seçenekleri

Public İmaj Kullanımı

Herkese açık imajlar için kimlik doğrulaması gerekmez:

# Giriş yapmadan doğrudan indirebilirsiniz
docker pull ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest

Bu, açık kaynak projeler veya paylaşılan temel imajlar için idealdir.

Private İmaj Kullanımı

Özel imajlar için mutlaka kimlik doğrulaması yapmalısınız:

# Önce giriş yap
echo $CR_PAT | docker login ghcr.io -u KULLANICI_ADINIZ --password-stdin

# Sonra indir
docker pull ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest

İmajı Depoya Bağlama

Dockerfile’daki LABEL etiketi ile imajı otomatik olarak bir depoya bağlayabilirsiniz:

LABEL org.opencontainers.image.source="https://github.com/KULLANICI_ADINIZ/fastapi-ghcr-demo"

Bu bağlantı sayesinde:

• İmaj, depo sayfasında görünür
• Depo izinleri imaja miras alınabilir
• GitHub Actions’da GITHUB_TOKEN otomatik erişim kazanır

8. Güvenlik ve Erişim Yönetimi

Konteyner güvenliği kritik bir konudur. GHCR, kapsamlı erişim kontrol mekanizmaları sunar.

Token Kapsamları (Scopes)

PAT oluştururken doğru kapsamları seçmek önemlidir:

En İyi Güvenlik Pratikleri

1. Minimum Yetki İlkesi: Sadece gerekli kapsamları verin
2. Token Süre Sınırı: PAT’lara son kullanma tarihi belirleyin
3. GITHUB_TOKEN Tercih Edin: GitHub Actions’da mümkünse GITHUB_TOKEN kullanın
4. Gizli Bilgileri Koruyun: Token’ları asla koda yazmayın, GitHub Secrets kullanın
5. Düzenli Denetim: Erişim yetkilerini periyodik olarak gözden geçirin

GitHub Actions’da Güvenli Token Kullanımı

permissions:
  contents: read
  packages: write

steps:
  - name: Log in to GHCR
    uses: docker/login-action@v3
    with:
      registry: ghcr.io
      username: ${{ github.actor }}
      password: ${{ secrets.GITHUB_TOKEN }}

İmaj İmzalama (Image Signing)

Üretim ortamları için imaj imzalama düşünülebilir:

- name: Generate artifact attestation
  uses: actions/attest-build-provenance@v1
  with:
    subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
    subject-digest: ${{ steps.push.outputs.digest }}
    push-to-registry: true

Bu, imajın nereden geldiğini ve nasıl oluşturulduğunu kanıtlar.

Erişim Kontrolü Yapılandırma

İmaj bazında erişim kontrolü ayarlamak için:

1. Package settings > Manage access bölümüne gidin
2. Invite teams or people ile kullanıcı veya takım ekleyin
3. Uygun rol atayın:
   • Read: Sadece indirme
   • Write: İndirme ve yükleme
   • Admin: Tam yetki (silme dahil)

9. Çoklu Platform (Multi-Platform) Image Build

Modern uygulamalar farklı CPU mimarilerinde çalışmalıdır. ARM işlemcili sunucular (AWS Graviton, Apple Silicon) giderek yaygınlaşıyor. Docker Buildx ile tek seferde birden fazla platform için imaj oluşturabiliriz.

Neden Çoklu Platform?

• Apple Silicon (M1/M2/M3): ARM64 mimarisi kullanır
• AWS Graviton: ARM tabanlı, maliyet etkin sunucular
• Raspberry Pi: ARM işlemcili mini bilgisayarlar
• Geleneksel Sunucular: x86-64 (AMD64) mimarisi

Buildx ile Çoklu Platform Build

Docker Buildx, tek bir komutla birden fazla platform için imaj oluşturmanızı sağlar [23]:

# Builder oluştur ve kullan
docker buildx create --name mybuilder --use

# Builder'ı başlat
docker buildx inspect --bootstrap

# Çoklu platform build (push ile birlikte)
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  --tag ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest \
  --push \
  .

GitHub Actions ile Çoklu Platform

Workflow dosyamızı güncelleyelim [24]:

name: Multi-Platform Docker Build

on:
  push:
    branches: ['main']
    tags: ['v*']

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-multiplatform:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      # QEMU - ARM emülasyonu için gerekli
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3

      # Buildx - Çoklu platform build için gerekli
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Log in to GHCR
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

      # Çoklu platform build
      - name: Build and push multi-platform image
        uses: docker/build-push-action@v6
        with:
          context: .
          platforms: linux/amd64,linux/arm64
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

Desteklenen Platformlar

Yaygın platform tanımları [25]:

Platform Bilgisini Kontrol Etme

Oluşturulan imajın platform bilgisini kontrol etmek için:

# İmaj manifest'ini incele
docker buildx imagetools inspect ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest

# Yerel imajın mimarisini kontrol et
docker image inspect ghcr.io/KULLANICI_ADINIZ/fastapi-ghcr-demo:latest | grep Architecture

Performans İpuçları

QEMU emülasyonu yavaş olabilir. Alternatifler [26]:

1. Native Runner Kullanımı: ARM runner’lar kullanın (GitHub Enterprise veya üçüncü parti)
2. Cross-Compilation: Dockerfile’da çapraz derleme kullanın
3. Build Cache: GitHub Actions cache’ini etkinleştirin

10. Sonuç

Bu rehberde GitHub Container Registry’yi (GHCR) kapsamlı bir şekilde inceledik. Öğrendiklerimizi özetleyelim:

Öğrendiklerimiz

✅ GHCR Temelleri: GitHub’ın konteyner kayıt defteri servisi ve avantajları

✅ Manuel İşlemler: PAT oluşturma, Docker login, tag ve push komutları

✅ GitHub Actions Otomasyonu: CI/CD pipeline ile otomatik build ve push

✅ Görünürlük Yönetimi: Public, private ve internal imaj ayarları

✅ Güvenlik: Token kapsamları, erişim kontrolü ve en iyi pratikler

✅ Çoklu Platform: AMD64 ve ARM64 için tek imaj oluşturma

Ne Zaman GHCR Kullanmalı?

• Kaynak kodunuz zaten GitHub’daysa
• GitHub Actions kullanıyorsanız
• Tek platform üzerinden yönetim istiyorsanız
• Açık kaynak projeler için ücretsiz public registry arıyorsanız

GitHub Container Registry, modern Dev/Data/ML/AI Ops iş akışları alternatif bir çözümdür. Docker Hub veya diğer registry’lere alternatif olarak değerlendirmeye değer! Başka bir yazıda görüşmek dileğiyle…

Kaynaklar

[1] GitHub Docs – Working with the Container registry. https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry

[2] Codefresh Docs – GitHub Container Registry. https://codefresh.io/docs/docs/integrations/docker-registries/github-container-registry/

[3] GitHub Docs – About permissions for GitHub Packages. https://docs.github.com/en/packages/learn-github-packages/about-permissions-for-github-packages

[4] DEV Community – Using Github Container Registry. https://dev.to/davidmaceachern/using-github-container-registry-15m0

[5] GitHub Docs – Configuring a package’s access control and visibility. https://docs.github.com/en/packages/learn-github-packages/configuring-a-packages-access-control-and-visibility

[6] Medium – Pushing Docker Images to GitHub Registry: Manual and Automated Methods. https://medium.com/devopsturkiye/pushing-docker-images-to-githubs-registry-manual-and-automated-methods-19cce3544eb1

[7] Medium – Get started with GitHub GHCR. https://medium.com/@deepak1812002/get-started-with-github-ghcr-an-alternative-of-dockerhub-f7d5b2198b9a

[8] Andrew Hoog – Authorizing GitHub Container Registry. https://www.andrewhoog.com/posts/authorizing-github-container-registry/

[9] FastAPI Documentation – FastAPI in Containers – Docker. https://fastapi.tiangolo.com/deployment/docker/

[10] DEV Community – Pushing container images to GitHub Container Registry with GitHub Actions. https://dev.to/willvelida/pushing-container-images-to-github-container-registry-with-github-actions-1m6b

[11] Dev-Ore – Docker and GitHub Container Registry (GHCR) Quickstart. https://www.dev-ore.com/blog/docker-github-container-registry-quickstart/

[12] Nira – The Ultimate Manual for GitHub Container Registry. https://nira.com/github-container-registry/

[13] Shipyard – GitHub Actions: Building Docker Images and Pushing to a Container Registry. https://shipyard.build/blog/gha-recipes-build-and-push-container-registry/

[14] Paul’s Blog – Publishing Container Images to GitHub Container Registry. https://paulyu.dev/article/publishing-container-images-to-ghcr/

[15] GitHub Marketplace – push-to-ghcr. https://github.com/marketplace/actions/push-to-ghcr

[16] Hashnode – Publish Docker image: GHCR, GitHub Actions. https://blog.pradumnasaraf.dev/publish-image-on-ghcr

[17] GitHub Actions workflows in combination with GitHub Container Registry Package Visibility. https://niklasmtj.de/blog/gh-actions-workflows-combination-with-ghcr/

[18] DevOps Journal – GitHub Container Registry. https://devopsjournal.io/blog/2021/01/06/GitHub-Container-Registry

[19] GitHub Community Discussion – Super confusing GitHub Container Registry. https://github.com/orgs/community/discussions/26861

[20] 0ink.net – Using the Github Container Registry. https://0ink.net/posts/2025/2025-11-01-using-ghcr.html

[21] Baeldung – Use Private Docker Image in GitHub Actions. https://www.baeldung.com/ops/github-actions-private-docker-image

[22] Docker Docs – Multi-platform builds. https://docs.docker.com/build/building/multi-platform/

[23] Docker Blog – Faster Multi-Platform Builds: Dockerfile Cross-Compilation Guide. https://www.docker.com/blog/faster-multi-platform-builds-dockerfile-cross-compilation-guide/

[24] GitHub – docker/build-push-action. https://github.com/docker/build-push-action

[25] Docker Docs – docker buildx build. https://docs.docker.com/reference/cli/docker/buildx/build/

[26] Blacksmith – Building Multi-Platform Docker Images for ARM64 in GitHub Actions. https://www.blacksmith.sh/blog/building-multi-platform-docker-images-for-arm64-in-github-actions

[27] Docker Blog – Building Multi-Arch Images for Arm and x86 with Docker Desktop. https://www.docker.com/blog/multi-arch-images/

[28] ARM Learn – Build multi-architecture images with Docker buildx. https://learn.arm.com/learning-paths/cross-platform/docker/buildx/

[29] Better Stack – FastAPI Docker Best Practices. https://betterstack.com/community/guides/scaling-python/fastapi-docker-best-practices/

[30] Docker Docs – Push to multiple registries with GitHub Actions. https://docs.docker.com/build/ci/github-actions/push-multi-registries/