Docker & Containers
Embedded Build Ortamı

# Resmi Docker repository ekle
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) \
  signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin

# Sudo olmadan Docker kullan
sudo usermod -aG docker $(whoami)
# Çıkış yap ve tekrar giriş yap

# Image indir
docker pull ubuntu:22.04
docker pull debian:12-slim

# Yerel image listesi
docker images
# REPOSITORY   TAG        IMAGE ID       CREATED        SIZE
# ubuntu       22.04      a6be0dcb2575   3 weeks ago    77.8MB
# debian       12-slim    c5e5c75af97e   3 weeks ago    74.8MB

# Image bilgisi
docker inspect ubuntu:22.04

# Image sil
docker rmi ubuntu:22.04

# Kullanılmayan image'ları temizle
docker image prune -a

# Tek seferlik container (çıkışta silinir)
docker run --rm ubuntu:22.04 uname -a

# İnteraktif bash shell
docker run --rm -it ubuntu:22.04 bash

# Arka planda çalıştır (daemon)
docker run -d --name my-server nginx:alpine
# d7a3f1b09e2c8f6...

# Çalışan container listesi
docker ps

# Tüm container'lar (durmuş dahil)
docker ps -a

# Çalışan container'a komut gönder
docker exec -it my-server sh

# Container durdur / başlat / sil
docker stop my-server
docker start my-server
docker rm my-server

# Container logları
docker logs -f my-server

# Image katmanlarını görüntüle
docker history ubuntu:22.04
# IMAGE          CREATED        CREATED BY                                      SIZE
# a6be0dcb2575   3 weeks ago    /bin/sh -c #(nop)  CMD ["bash"]                 0B
# <missing>      3 weeks ago    /bin/sh -c #(nop) ADD file:...                  77.8MB

# Katman ID'lerini ve boyutları detaylı görüntüle
docker inspect ubuntu:22.04 --format '{{range .RootFS.Layers}}{{println .}}{{end}}'

# syntax=docker/dockerfile:1
FROM ubuntu:22.04 AS base

# Build arg — toolchain prefix değiştirilebilir
ARG DEBIAN_FRONTEND=noninteractive
ARG CROSS_ARCH=aarch64

# Katman birleştirme: tek RUN = tek katman
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc-${CROSS_ARCH}-linux-gnu \
    g++-${CROSS_ARCH}-linux-gnu \
    make cmake ninja-build \
    pkg-config ca-certificates \
    git curl wget file \
  && rm -rf /var/lib/apt/lists/*

# Ortam değişkenleri
ENV CROSS_COMPILE=${CROSS_ARCH}-linux-gnu-
ENV ARCH=arm64
ENV PKG_CONFIG_PATH=/usr/${CROSS_ARCH}-linux-gnu/lib/pkgconfig

WORKDIR /build

# Root olmayan kullanıcı (güvenlik)
RUN useradd -m -u 1000 builder
USER builder

CMD ["/bin/bash"]

# ── Stage 1: Builder ──────────────────────────────────
FROM ubuntu:22.04 AS builder

ARG DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc-aarch64-linux-gnu make libssl-dev \
  && rm -rf /var/lib/apt/lists/*

WORKDIR /src
COPY . .

# Statik binary derle
RUN aarch64-linux-gnu-gcc \
    -static -O2 \
    -o /out/app \
    main.c \
  && aarch64-linux-gnu-strip /out/app

# ── Stage 2: Runtime (scratch — yalnızca binary) ──────
FROM scratch AS runtime

COPY --from=builder /out/app /app

ENTRYPOINT ["/app"]

# Build: docker build --target runtime -t my-app:arm64 .
# Sonuç image boyutu: yalnızca binary kadar (~500 KB)

# Temel build
docker build -t my-builder:latest .

# Build arg ile
docker build \
  --build-arg CROSS_ARCH=arm \
  -t my-builder:arm32 .

# Belirli stage'e kadar build
docker build --target builder -t my-builder:full .

# Build cache'i atla
docker build --no-cache -t my-builder:fresh .

# BuildKit ile paralel build (önerilir)
DOCKER_BUILDKIT=1 docker build -t my-builder:latest .

# -v /host/path:/container/path
# Mevcut dizini /build olarak monte et
docker run --rm -it \
  -v "$(pwd):/build" \
  my-builder:latest \
  make -C /build -j$(nproc)

# Read-only mount (kaynak kod değiştirilmesin)
docker run --rm \
  -v "$(pwd)/src:/build/src:ro" \
  -v "$(pwd)/output:/build/output" \
  my-builder:latest \
  make -C /build

# Yeni sözdizimi (--mount)
docker run --rm \
  --mount "type=bind,source=$(pwd),target=/build" \
  my-builder:latest bash

# Volume oluştur
docker volume create yocto-sstate
docker volume create buildroot-dl

# Volume listesi
docker volume ls

# Volume ile container çalıştır
docker run --rm \
  -v yocto-sstate:/build/sstate-cache \
  -v buildroot-dl:/build/dl \
  -v "$(pwd):/build/src:ro" \
  yocto-builder:latest \
  bitbake core-image-minimal

# Volume bilgisi
docker volume inspect yocto-sstate
# "Mountpoint": "/var/lib/docker/volumes/yocto-sstate/_data"

# Volume sil
docker volume rm yocto-sstate

# Kullanılmayan volume'ları temizle
docker volume prune

# /tmp ve /run gibi geçici dizinler için ideal
# Container silindiğinde veri kaybolur
docker run --rm \
  --tmpfs /tmp:rw,size=512m,mode=1777 \
  my-builder:latest bash

# --mount sözdizimi ile
docker run --rm \
  --mount "type=tmpfs,target=/tmp,tmpfs-size=512m" \
  my-builder:latest bash

# Host port 8080 → container port 80
docker run -d -p 8080:80 nginx:alpine

# Belirli interface'e bind
docker run -d -p 127.0.0.1:8080:80 nginx:alpine

# Tüm EXPOSE edilen portları rastgele yayınla
docker run -d -P nginx:alpine

# Çalışan port mappingleri görüntüle
docker port my-container

# Host ağını paylaş (Linux only)
docker run --rm --network host nginx:alpine

# Custom bridge network oluştur
docker network create \
  --driver bridge \
  --subnet 172.20.0.0/16 \
  --ip-range 172.20.240.0/20 \
  build-net

# Container'ları aynı ağa bağla
docker run -d --name registry \
  --network build-net \
  registry:2

docker run --rm --network build-net \
  my-builder:latest \
  curl http://registry:5000/v2/_catalog

# Aynı custom network'teki container'lar
# birbirlerine isimle (DNS) erişebilir

# Network listesi
docker network ls

# Network bilgisi
docker network inspect build-net

# Temizlik
docker network rm build-net

# Docker Buildx eklentisi (modern Docker'da dahili gelir)
docker buildx version
# github.com/docker/buildx v0.13.1 ...

# QEMU user-static kur (farklı mimari binary çalıştırma için)
sudo apt-get install -y qemu-user-static binfmt-support

# binfmt_misc kayıt (QEMU user-static ile otomatik)
docker run --rm --privileged \
  multiarch/qemu-user-static --reset -p yes

# Binfmt kayıtlarını doğrula
ls /proc/sys/fs/binfmt_misc/ | grep qemu
# qemu-aarch64
# qemu-arm
# qemu-riscv64
# ...

# Multi-arch builder oluştur
docker buildx create \
  --name multiarch-builder \
  --driver docker-container \
  --use

# Builder'ı başlat ve mimarileri doğrula
docker buildx inspect --bootstrap
# Platforms: linux/amd64, linux/arm64, linux/arm/v7, linux/arm/v6, linux/riscv64

# ARM64 + ARM32v7 için image oluştur ve registry'e push et
docker buildx build \
  --platform linux/arm64,linux/arm/v7 \
  -t ghcr.io/myorg/my-app:latest \
  --push \
  .

# Geniş platform listesi (amd64 dahil)
docker buildx build \
  --platform linux/amd64,linux/arm64,linux/arm/v7,linux/arm/v6 \
  -t ghcr.io/myorg/my-app:1.0.0 \
  -t ghcr.io/myorg/my-app:latest \
  --push .

# Push etmeden yerel test (belirli platform)
docker buildx build \
  --platform linux/arm64 \
  --output "type=docker,name=my-app:arm64-test" \
  --load \
  .

# Manifest list incele
docker buildx imagetools inspect ghcr.io/myorg/my-app:latest

# syntax=docker/dockerfile:1
FROM ubuntu:22.04

# Buildx tarafından otomatik doldurulur
ARG TARGETARCH
ARG TARGETVARIANT

RUN apt-get update && apt-get install -y --no-install-recommends \
    curl ca-certificates \
  && rm -rf /var/lib/apt/lists/*

# Mimariye göre farklı binary indir
RUN case "${TARGETARCH}${TARGETVARIANT}" in \
      "arm64")   ARCH_SLUG="aarch64"  ;; \
      "armv7")   ARCH_SLUG="armv7l"   ;; \
      "amd64")   ARCH_SLUG="x86_64"   ;; \
      *)         echo "Unsupported: ${TARGETARCH}"; exit 1 ;; \
    esac \
  && curl -Lo /usr/local/bin/my-tool \
      "https://example.com/releases/${ARCH_SLUG}/my-tool" \
  && chmod +x /usr/local/bin/my-tool

ENTRYPOINT ["/usr/local/bin/my-tool"]

# syntax=docker/dockerfile:1
FROM ubuntu:22.04

ARG DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y --no-install-recommends \
    # ARM 32-bit hard-float toolchain
    gcc-arm-linux-gnueabihf \
    g++-arm-linux-gnueabihf \
    # ARM 64-bit toolchain
    gcc-aarch64-linux-gnu \
    g++-aarch64-linux-gnu \
    # Build araçları
    make cmake ninja-build \
    autoconf automake libtool \
    pkg-config bc flex bison \
    # Kernel araçları
    libssl-dev libncurses-dev \
    # Genel yardımcılar
    git wget curl file xz-utils \
    ca-certificates python3 python3-pip \
  && rm -rf /var/lib/apt/lists/*

# ARM32 ve ARM64 için symlink'ler
ENV CC_ARM32=arm-linux-gnueabihf-gcc
ENV CXX_ARM32=arm-linux-gnueabihf-g++
ENV CC_ARM64=aarch64-linux-gnu-gcc
ENV CXX_ARM64=aarch64-linux-gnu-g++

WORKDIR /build

# Root olmayan kullanıcı — host UID ile eşleştir
ARG UID=1000
ARG GID=1000
RUN groupadd -g ${GID} builder \
  && useradd -m -u ${UID} -g builder builder

USER builder
CMD ["/bin/bash"]

# Image oluştur (host UID geçirerek — dosya izinleri için)
docker build \
  --build-arg UID=$(id -u) \
  --build-arg GID=$(id -g) \
  -f Dockerfile.arm-builder \
  -t arm-builder:latest .

# Kaynak kodu bind mount ile ARM64 derle
docker run --rm \
  -v "$(pwd):/build" \
  arm-builder:latest \
  aarch64-linux-gnu-gcc -O2 -o /build/app_arm64 /build/src/main.c

# Makefile projesi için
docker run --rm \
  -v "$(pwd):/build" \
  arm-builder:latest \
  make -C /build \
    CROSS_COMPILE=aarch64-linux-gnu- \
    ARCH=arm64 \
    -j$(nproc)

# CMake projesi için
docker run --rm \
  -v "$(pwd):/build" \
  arm-builder:latest \
  bash -c "cmake -B /build/build-arm64 \
    -DCMAKE_TOOLCHAIN_FILE=/build/cmake/arm64-toolchain.cmake \
    -DCMAKE_BUILD_TYPE=Release /build \
  && cmake --build /build/build-arm64 -j$(nproc)"

# Derlenen binary'nin mimarisini doğrula
file app_arm64
# app_arm64: ELF 64-bit LSB pie executable, ARM aarch64, ...

# CMake cross-compilation toolchain — AArch64
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)

set(CROSS_PREFIX aarch64-linux-gnu-)

set(CMAKE_C_COMPILER   ${CROSS_PREFIX}gcc)
set(CMAKE_CXX_COMPILER ${CROSS_PREFIX}g++)
set(CMAKE_AR           ${CROSS_PREFIX}ar)
set(CMAKE_STRIP        ${CROSS_PREFIX}strip)

set(CMAKE_FIND_ROOT_PATH  /usr/aarch64-linux-gnu)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

# Cortex-A53 optimizasyonu
set(CMAKE_C_FLAGS   "-mcpu=cortex-a53 -O2")
set(CMAKE_CXX_FLAGS "-mcpu=cortex-a53 -O2")

services:

  # ── Cross-compile builder ──────────────────────────
  builder:
    build:
      context: .
      dockerfile: Dockerfile.arm-builder
      args:
        UID: "${UID:-1000}"
        GID: "${GID:-1000}"
    volumes:
      - "./src:/build/src:ro"
      - "./output:/build/output"
      - buildroot-dl:/build/dl
    environment:
      - CROSS_COMPILE=aarch64-linux-gnu-
      - ARCH=arm64
    working_dir: /build
    command: make -j4

  # ── Özel Docker registry ──────────────────────────
  registry:
    image: registry:2
    ports:
      - "5000:5000"
    volumes:
      - registry-data:/var/lib/registry
    environment:
      REGISTRY_STORAGE_DELETE_ENABLED: "true"
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:5000/v2/"]
      interval: 10s
      timeout: 5s
      retries: 3

  # ── Build artifact sunucusu ────────────────────────
  artifact-server:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - "./output:/usr/share/nginx/html:ro"
    depends_on:
      builder:
        condition: service_completed_successfully

volumes:
  buildroot-dl:
  registry-data:

# Tüm servisleri başlat
docker compose up -d

# Build ve başlat (image yeniden oluştur)
docker compose up --build -d

# Yalnızca builder servisini çalıştır (tek seferlik)
docker compose run --rm builder

# Servis logları
docker compose logs -f builder

# Servis durumu
docker compose ps

# Tüm servisleri durdur
docker compose down

# Volume'larla birlikte temizle
docker compose down -v

services:
  sstate-server:
    image: nginx:alpine
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost/"]
      interval: 5s
      timeout: 3s
      retries: 5
      start_period: 10s

  yocto-builder:
    build: .
    depends_on:
      sstate-server:
        condition: service_healthy
    environment:
      - SSTATE_MIRROR=http://sstate-server/sstate-cache

# Oturum aç
docker login
# Username: myusername
# Password: ...
# Login Succeeded

# Image etiketle (Docker Hub formatı: kullanıcı/repo:tag)
docker tag arm-builder:latest myusername/arm-builder:latest
docker tag arm-builder:latest myusername/arm-builder:22.04-gcc13

# Push
docker push myusername/arm-builder:latest
docker push myusername/arm-builder:22.04-gcc13

# Pull
docker pull myusername/arm-builder:latest

# GitHub Personal Access Token ile oturum aç
# Token izinleri: read:packages, write:packages, delete:packages
echo "${GITHUB_TOKEN}" | docker login ghcr.io \
  -u myusername --password-stdin

# Image etiketle (ghcr.io/org/repo:tag)
docker tag arm-builder:latest \
  ghcr.io/myorg/arm-builder:latest

# Push
docker push ghcr.io/myorg/arm-builder:latest

# Multi-arch push buildx ile
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t ghcr.io/myorg/arm-builder:latest \
  --push .

# GitHub Actions'ta GITHUB_TOKEN ile otomatik login
# - uses: docker/login-action@v3
#   with:
#     registry: ghcr.io
#     username: ${{ github.actor }}
#     password: ${{ secrets.GITHUB_TOKEN }}

# Registry container başlat
docker run -d \
  --name local-registry \
  --restart always \
  -p 5000:5000 \
  -v registry-data:/var/lib/registry \
  registry:2

# Image push
docker tag arm-builder:latest localhost:5000/arm-builder:latest
docker push localhost:5000/arm-builder:latest

# Image pull
docker pull localhost:5000/arm-builder:latest

# Registry catalog
curl http://localhost:5000/v2/_catalog
# {"repositories":["arm-builder"]}

# Tag listesi
curl http://localhost:5000/v2/arm-builder/tags/list
# {"name":"arm-builder","tags":["latest"]}

# syntax=docker/dockerfile:1
FROM ubuntu:22.04

ARG DEBIAN_FRONTEND=noninteractive

# Yocto Scarthgap resmi bağımlılıkları
RUN apt-get update && apt-get install -y --no-install-recommends \
    gawk wget git diffstat unzip texinfo gcc \
    build-essential chrpath socat cpio python3 \
    python3-pip python3-pexpect xz-utils debianutils \
    iputils-ping python3-git python3-jinja2 \
    python3-subunit zstd liblz4-tool file \
    libacl1 libegl1-mesa libsdl1.2-dev \
    pylint xterm \
  && rm -rf /var/lib/apt/lists/*

# repo tool (Android repo)
RUN curl -o /usr/local/bin/repo \
    https://storage.googleapis.com/git-repo-downloads/repo \
  && chmod a+x /usr/local/bin/repo

# Host UID ile eşleşen kullanıcı
ARG UID=1000
ARG GID=1000
RUN groupadd -g ${GID} yocto \
  && useradd -m -u ${UID} -g yocto -s /bin/bash yocto \
  && echo "yocto ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers

# Git config (BitBake için gerekli)
RUN git config --system user.email "ci@build.local" \
  && git config --system user.name "Yocto CI"

USER yocto
WORKDIR /build

CMD ["/bin/bash"]

# Image oluştur
docker build \
  --build-arg UID=$(id -u) \
  --build-arg GID=$(id -g) \
  -f Dockerfile.yocto \
  -t yocto-builder:scarthgap .

# Kalıcı volume'lar oluştur
docker volume create yocto-sstate    # sstate-cache (~20–50 GB)
docker volume create yocto-downloads # indirilen kaynaklar (~5–10 GB)

# Yocto build çalıştır
docker run --rm -it \
  -v "$(pwd)/poky:/build/poky:ro" \
  -v "$(pwd)/meta-custom:/build/meta-custom:ro" \
  -v yocto-sstate:/build/build/sstate-cache \
  -v yocto-downloads:/build/build/downloads \
  -v "$(pwd)/output:/build/output" \
  yocto-builder:scarthgap \
  bash -c "
    source /build/poky/oe-init-build-env /build/build
    bitbake core-image-minimal 2>&1 | tee /build/output/build.log
  "

# Makine tanımı
MACHINE = "qemuarm64"

# Paralel build (container CPU sayısına göre)
BB_NUMBER_THREADS = "4"
PARALLEL_MAKE = "-j 4"

# sstate-cache dizini (volume mount noktası)
SSTATE_DIR = "/build/build/sstate-cache"

# Downloads dizini (volume mount noktası)
DL_DIR = "/build/build/downloads"

# CI modunda interaktif sorulardan kaçın
CONNECTIVITY_CHECK_URIS = ""

# Disk alanı uyarı eşiği
BB_DISKMON_DIRS = "\
  STOPTASKS,/build,1G,100K \
  ABORT,/build,100M,1K"

name: Yocto Build CI

on:
  push:
    paths: ['meta-custom/**']

jobs:
  yocto-build:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Cache sstate (GitHub Actions cache)
        uses: actions/cache@v4
        with:
          path: sstate-cache
          key: yocto-sstate-${{ hashFiles('meta-custom/**/*.bb') }}
          restore-keys: yocto-sstate-

      - name: Build Yocto image
        run: |
          docker build \
            --build-arg UID=$(id -u) \
            --build-arg GID=$(id -g) \
            -f Dockerfile.yocto \
            -t yocto-builder:ci .

          docker run --rm \
            -v "$(pwd):/build/workspace:ro" \
            -v "$(pwd)/sstate-cache:/build/build/sstate-cache" \
            -v "$(pwd)/artifacts:/build/output" \
            yocto-builder:ci \
            bash -c "
              source /build/workspace/poky/oe-init-build-env /build/build
              cp /build/workspace/conf/local.conf conf/local.conf
              bitbake core-image-minimal
              cp tmp/deploy/images/qemuarm64/* /build/output/
            "

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: yocto-images
          path: artifacts/