النشر والإنتاج

النشر والإنتاج — Deployment

هذا الدرس الأخير يجمع كل شيء — كيف تأخذ تطبيق Go من جهازك إلى الإنتاج بشكل موثوق ومُراقب.

CI/CD مع GitHub Actions

main.go

package main

import "fmt"

func main() {
    fmt.Println(`# .github/workflows/deploy.yml
name: Build & Deploy

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.22'

      - name: تنزيل الاعتماديات
        run: go mod download

      - name: الاختبارات مع كشف السباق
        run: go test -race -v ./...

      - name: التغطية
        run: go test -coverprofile=coverage.out ./...

      - name: الفحص الثابت
        uses: golangci/golangci-lint-action@v4

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: بناء صورة Docker
        run: docker build -t myapp:${{ github.sha }} .

      - name: نشر
        if: github.ref == 'refs/heads/main'
        run: |
          docker tag myapp:${{ github.sha }} registry.example.com/myapp:latest
          docker push registry.example.com/myapp:latest`)
}

Output:

Makefile للمشروع

main.go

package main

import "fmt"

func main() {
    fmt.Println(`# Makefile
.PHONY: build test run lint clean

# البناء — Build
build:
	CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/server ./cmd/server

# الاختبارات — Test
test:
	go test -race -cover ./...

# التشغيل — Run
run:
	go run ./cmd/server

# الفحص الثابت — Lint
lint:
	golangci-lint run

# التنظيف — Clean
clean:
	rm -rf bin/

# Docker
docker-build:
	docker build -t myapp .

docker-run:
	docker compose up -d`)

    fmt.Println("\n=== الاستخدام ===")
    fmt.Println("make build    → بناء الملف التنفيذي")
    fmt.Println("make test     → تشغيل الاختبارات")
    fmt.Println("make lint     → فحص الكود")
    fmt.Println("make run      → تشغيل محلي")
}

Output:

الإيقاف اللطيف — Graceful Shutdown

عند إيقاف الخادم، يجب إنهاء الطلبات الحالية قبل الإغلاق:

main.go

package main

import (
    "context"
    "fmt"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)

func main() {
    // التقاط إشارات النظام — Catch OS signals
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

    // محاكاة خادم يعمل — Simulate running server
    fmt.Println("🚀 الخادم يعمل...")

    // محاكاة طلبات نشطة — Simulate active requests
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Printf("  📝 طلب %d قيد المعالجة\n", id)
            time.Sleep(time.Duration(id*50) * time.Millisecond)
            fmt.Printf("  ✅ طلب %d اكتمل\n", id)
        }(i)
    }

    // محاكاة إشارة إيقاف بعد 100ms — Simulate stop signal
    go func() {
        time.Sleep(100 * time.Millisecond)
        quit <- syscall.SIGINT
    }()

    <-quit
    fmt.Println("\n⏳ جاري الإيقاف اللطيف...")

    // مهلة للإيقاف — Shutdown timeout
    _, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // انتظار الطلبات الحالية — Wait for current requests
    wg.Wait()
    fmt.Println("👋 تم الإيقاف بنجاح")
}

Output:

الكود الحقيقي للإيقاف اللطيف

func main() {
    srv := &http.Server{Addr: ":8080", Handler: router}

    // تشغيل في goroutine — Run in goroutine
    go func() {
        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatal(err)
        }
    }()

    // انتظار إشارة الإيقاف — Wait for stop signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    // إيقاف لطيف مع مهلة — Graceful shutdown with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    srv.Shutdown(ctx)
}

التصحيح بـ pprof — Profiling

main.go

package main

import "fmt"

func main() {
    fmt.Println("=== تصحيح الأداء بـ pprof ===\n")

    fmt.Println(`// أضف هذا في main.go
import _ "net/http/pprof"

go func() {
    log.Println(http.ListenAndServe(":6060", nil))
}()`)

    fmt.Println("\n=== الأدوات ===")
    commands := []struct {
        cmd  string
        desc string
    }{
        {"go tool pprof http://localhost:6060/debug/pprof/profile", "CPU profiling (30 ثانية)"},
        {"go tool pprof http://localhost:6060/debug/pprof/heap", "تحليل الذاكرة"},
        {"go tool pprof http://localhost:6060/debug/pprof/goroutine", "عدد goroutines"},
        {"curl localhost:6060/debug/pprof/", "صفحة الملخص"},
    }

    for _, c := range commands {
        fmt.Printf("  %s\n    → %s\n\n", c.cmd, c.desc)
    }

    fmt.Println("💡 في pprof التفاعلي:")
    fmt.Println("  top10    → أبطأ 10 دوال")
    fmt.Println("  web      → رسم بياني في المتصفح")
    fmt.Println("  list foo → تفاصيل دالة محددة")
}

Output:

systemd — تشغيل كخدمة

main.go

package main

import "fmt"

func main() {
    fmt.Println(`# /etc/systemd/system/myapp.service
[Unit]
Description=My Go Application
After=network.target postgresql.service

[Service]
Type=simple
User=appuser
Group=appuser
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/server
Restart=on-failure
RestartSec=5
StandardOutput=journal
StandardError=journal
Environment=ENV=production
Environment=PORT=8080

# أمان — Security
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/opt/myapp/data

[Install]
WantedBy=multi-user.target`)

    fmt.Println("\n=== أوامر systemd ===")
    fmt.Println("sudo systemctl enable myapp    → تفعيل عند الإقلاع")
    fmt.Println("sudo systemctl start myapp     → تشغيل")
    fmt.Println("sudo systemctl status myapp    → الحالة")
    fmt.Println("sudo journalctl -u myapp -f    → السجلات المباشرة")
}

Output:

نظرة على الخدمات المصغرة — Microservices Overview

main.go

package main

import "fmt"

func main() {
    fmt.Println("=== متى تنتقل للخدمات المصغرة؟ ===\n")

    fmt.Println("ابدأ بـ Monolith دائماً! 🏗️")
    fmt.Println("انتقل للخدمات المصغرة فقط عندما:\n")

    reasons := []string{
        "الفريق كبير (5+ مطورين) ويحتاجون تنسيق أقل",
        "أجزاء مختلفة تحتاج scaling مختلف",
        "تريد نشر أجزاء بشكل مستقل",
        "تحتاج تقنيات مختلفة لأجزاء مختلفة",
    }

    for i, r := range reasons {
        fmt.Printf("  %d. %s\n", i+1, r)
    }

    fmt.Println("\n=== أدوات Go للخدمات المصغرة ===")
    tools := []struct{ name, use string }{
        {"gRPC", "تواصل سريع بين الخدمات"},
        {"NATS/Kafka", "رسائل غير متزامنة"},
        {"OpenTelemetry", "تتبع موزع (tracing)"},
        {"Consul/etcd", "اكتشاف الخدمات"},
        {"Kubernetes", "إدارة الحاويات"},
    }

    for _, t := range tools {
        fmt.Printf("  • %s — %s\n", t.name, t.use)
    }

    fmt.Println("\n🎉 مبروك! أكملت رحلة Go من الصفر إلى الإنتاج!")
}

Output:

تحدي — Challenge

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    fmt.Println("🚀 الخادم بدأ على :8080")

    var wg sync.WaitGroup

    // أضف 2 إلى WaitGroup ثم شغّل goroutine لكل طلب
    // كل goroutine تطبع "✅ طلب N اكتمل" ثم تستدعي wg.Done()
    // اكتب الكود هنا

    time.Sleep(30 * time.Millisecond)
    fmt.Println("⏳ إيقاف لطيف...")

    wg.Wait()
    fmt.Println("👋 تم الإيقاف")
}