
# AlmaLinux 9'da Zaman/Saat Senkronizasyonu: Chrony (NTP) Rehberi

Doğru zaman senkronizasyonu; log tutarlılığı, sertifika/geçerlilik kontrolleri, Kerberos/SSO ve dağıtık sistemlerde kritik öneme sahiptir. AlmaLinux 9, varsayılan olarak NTP istemcisi/sunucusu için Chrony kullanır.

Bu rehberde Chrony kurulumu, temel/ileri ayarlar, iç ağda NTP sunucusu olarak çalışma ve sorun giderme adımlarını bulacaksınız.

## 1) Ön kontrol: tarih, saat ve NTP durumu

```bash
# Sistem tarih/saat ve NTP durumu
timedatectl

# Chrony servis durumu
systemctl status chronyd --no-pager

# Etkin NTP eşleşmeleri (kaynaklar ve ofsetler)
chronyc sources -v
chronyc tracking
```

Beklenen: NTP `yes`/`active` ve en az bir kaynakta `^*` veya `^+` gibi bir işaret görmeniz.

## 2) Zaman dilimi ayarlama

```bash
# Mevcut saat dilimini listele
timedatectl list-timezones | grep Europe/Istanbul

# Saat dilimini ayarla
sudo timedatectl set-timezone Europe/Istanbul

# Doğrula
timedatectl
```

## 3) Chrony kurulumu ve servis yönetimi

```bash
sudo dnf install -y chrony
sudo systemctl enable --now chronyd
sudo systemctl status chronyd --no-pager
```

## 4) NTP sunucularını yapılandırma

Ana yapılandırma dosyası `/etc/chrony.conf` konumundadır. Varsayılan olarak `rhel.pool.ntp.org` havuzları gelir. Kurum içi NTP kullanacaksanız bunları özelleştirin.

```bash
sudo cp /etc/chrony.conf /etc/chrony.conf.bak.$(date +%F)
sudo nano /etc/chrony.conf
```

Örnek minimal içerik:

```conf
# /etc/chrony.conf

# Kurum içi NTP sunucuları (örnek)
server ntp1.example.local iburst
server ntp2.example.local iburst

# DNS çözümlenemeyecekse IP yazın
# server 192.168.10.10 iburst

# Donanım saati ile uyum
rtcsync

# Boot sonrası büyük sapmayı hızlı düzelt
makestep 1.0 3

driftfile /var/lib/chrony/drift
logdir /var/log/chrony
```

Değişiklik sonrası yeniden başlatın ve doğrulayın:

```bash
sudo systemctl restart chronyd
sleep 3
chronyc sources -v
chronyc tracking
```

## 5) Sistem saati ve donanım saati (RTC)

```bash
# Donanım saatini sistem saatine yaz
sudo hwclock --systohc

# RTC'nin UTC tutulması önerilir
sudo timedatectl set-local-rtc 0
timedatectl
```

## 6) Firewall ayarları (NTP sunucusu olarak hizmet verecekseniz)

Yalnızca bu sunucu diğer cihazlara NTP dağıtacaksa UDP/123 açın.

```bash
sudo firewall-cmd --add-service=ntp --permanent
sudo firewall-cmd --reload
sudo firewall-cmd --list-services | grep ntp || echo "ntp service not listed"
```

## 7) İç ağda NTP sunucusu olarak çalıştırma (opsiyonel)

`/etc/chrony.conf` dosyanıza aşağıdaki satırları ekleyin:

```conf
# Yerel ağ istemcilerine izin verin (CIDR bloğunu kendi ağınıza göre değiştirin)
allow 192.168.0.0/16

# Kaynaklar geçici olarak yoksa yerel referans kullan (stratum 10)
local stratum 10
```

Ardından servisi yeniden başlatın ve dinleme portunu doğrulayın:

```bash
sudo systemctl restart chronyd
sudo ss -ulpn | grep ":123"
```

İstemci tarafta test:

```bash
chronyc sources -n
chronyc tracking
```

## 8) Sanal makineler, konteynerlar ve bulut notları

- Hypervisor (VMware/Proxmox/KVM) düzeyinde zaman senkronu açıksa ikili senkronizasyon çakışmaları olabilir. Ya hypervisor senkronunu ya da guest NTP'yi tercih edin.
- Kubernetes node'larında host saat doğruluğu pod'lar için kritiktir; node düzeyinde Chrony çalışmalıdır.
- Bulut sağlayıcılarında (AWS/Azure/GCP) sağlayıcının önerdiği NTP uç noktalarını kullanın.

## 9) Sorun giderme

```bash
# Kaynak listesi ve ofsetler
chronyc sources -v

# Senkron durumu ve ofset tahmini
chronyc tracking

# Son 10 ölçüm
chronyc sourcestats -v

# Hata ayıklama logları
sudo grep -iE "chrony|ntp|step" /var/log/messages /var/log/chrony/* 2>/dev/null | tail -n 100

# NTP trafiği (UDP/123)
sudo tcpdump -ni any udp port 123 -c 20
```

Yaygın problemler ve çözümler:

- "Not synchronized" veya kaynak yok: Ağ/Firewall kontrol edin, DNS çözümünü test edin (`dig ntp.org`).
- Büyük saat farkı nedeniyle eşitleme yavaş: `makestep` satırının etkin olduğundan emin olun ve servisi yeniden başlatın.
- Proxy arkasında NTP: NTP UDP/123'tür; HTTP proxy üzerinden çalışmaz. Ağ kuralı gereklidir.

## 10) İyi uygulamalar (Best Practices)

- En az 2-3 upstream NTP sunucu tanımlayın; mümkünse coğrafi olarak yakın.
- İç ağ için tek bir authoritative NTP sunucusu konumlandırıp istemcileri ona yönlendirin.
- Log/metric takibi için `chronyc tracking` çıktısını izleyin; ofset sapmaları için uyarı eşikleri belirleyin.
- Saat dilimi ve RTC ayarlarını standardize edin (UTC önerilir, uygulama ihtiyaçlarına göre görüntüleme katmanında dönüştürün).

---

Her ortam farklıdır. Değişiklikleri production'a almadan önce test ortamında doğrulamanız önerilir.




AlmaLinux 9'da Zaman/Saat Senkronizasyonu: Chrony (NTP) Rehberi


# Cloud-Native Development: Bulut Odaklı Uygulama Geliştirme

Cloud-native development, uygulamaları bulut ortamının avantajlarından tam olarak yararlanacak şekilde tasarlama ve geliştirme yaklaşımıdır.

## Cloud-Native Nedir?

Cloud-native, uygulamaların bulut ortamında doğal olarak çalışacak şekilde tasarlandığı bir yaklaşımdır. Bu yaklaşım, ölçeklenebilirlik, esneklik ve dayanıklılık gibi bulut avantajlarından maksimum fayda sağlar.

### Temel Prensipler
- **Microservices**: Uygulamaları küçük, bağımsız servislere bölme
- **Containerization**: Docker container'ları ile paketleme
- **Orchestration**: Kubernetes ile container yönetimi
- **DevOps**: Geliştirme ve operasyon süreçlerinin entegrasyonu

## Cloud-Native Mimarisi

### 12-Factor App Methodology
```bash
# 1. Codebase - Tek kod deposu
git clone https://github.com/company/app.git

# 2. Dependencies - Bağımlılıkları açıkça belirt
# requirements.txt
Flask==2.0.1
redis==3.5.3

# 3. Config - Konfigürasyonu ortam değişkenlerinde sakla
export DATABASE_URL=postgresql://user:pass@localhost/db
export REDIS_URL=redis://localhost:6379

# 4. Backing Services - Dış servisleri kaynak olarak kullan
# Herhangi bir veritabanı, cache, message queue

# 5. Build, Release, Run - Ayrı aşamalar
# Build: Docker image oluştur
# Release: Konfigürasyon ile birleştir
# Run: Container'ı çalıştır

# 6. Processes - Stateless ve stateless işlemler
# Uygulama state'i dış servislerde sakla

# 7. Port Binding - Kendi port'unu export et
# Uygulama kendi port'unu dinlesin

# 8. Concurrency - Process modeli ile ölçeklendir
# Horizontal scaling için hazır ol

# 9. Disposability - Hızlı başlatma ve güvenli kapatma
# Graceful shutdown implement et

# 10. Dev/Prod Parity - Geliştirme ve production benzerliği
# Aynı araçları ve süreçleri kullan

# 11. Logs - Log'ları stdout'a yaz
# Log aggregation için hazır ol

# 12. Admin Processes - Admin işlemlerini tek seferlik yap
# Migration, backup gibi işlemler
```

## Containerization

### Docker Best Practices
```dockerfile
# Multi-stage build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine AS runtime
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
EXPOSE 3000
CMD ["npm", "start"]
```

### Docker Compose
```yaml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:pass@db:5432/app
    depends_on:
      - db
      - redis
  
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=app
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
    volumes:
      - postgres_data:/var/lib/postgresql/data
  
  redis:
    image: redis:6-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:
```

## Kubernetes Deployment

### Deployment Configuration
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cloud-native-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: cloud-native-app
  template:
    metadata:
      labels:
        app: cloud-native-app
    spec:
      containers:
      - name: app
        image: cloud-native-app:latest
        ports:
        - containerPort: 3000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: database-url
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
```

### Service Configuration
```yaml
apiVersion: v1
kind: Service
metadata:
  name: cloud-native-app-service
spec:
  selector:
    app: cloud-native-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer
```

## CI/CD Pipeline

### GitHub Actions
```yaml
name: CI/CD Pipeline

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

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
        cache: 'npm'
    
    - name: Install dependencies
      run: npm ci
    
    - name: Run tests
      run: npm test
    
    - name: Run linting
      run: npm run lint

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Build Docker image
      run: docker build -t cloud-native-app:${{ github.sha }} .
    
    - name: Push to registry
      run: |
        echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
        docker push cloud-native-app:${{ github.sha }}

  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Deploy to Kubernetes
      run: |
        kubectl set image deployment/cloud-native-app app=cloud-native-app:${{ github.sha }}
```

## Monitoring ve Observability

### Prometheus Configuration
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
    scrape_configs:
      - job_name: 'cloud-native-app'
        static_configs:
          - targets: ['cloud-native-app-service:80']
        metrics_path: '/metrics'
```

### Application Metrics
```javascript
const prometheus = require('prom-client');

// Metrics
const httpRequestDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status_code']
});

const httpRequestTotal = new prometheus.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status_code']
});

// Middleware
app.use((req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000;
    httpRequestDuration
      .labels(req.method, req.route?.path || req.path, res.statusCode)
      .observe(duration);
    httpRequestTotal
      .labels(req.method, req.route?.path || req.path, res.statusCode)
      .inc();
  });
  
  next();
});

// Metrics endpoint
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', prometheus.register.contentType);
  res.end(await prometheus.register.metrics());
});
```

## Security Best Practices

### Container Security
```dockerfile
# Non-root user
FROM node:18-alpine
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
USER nextjs

# Security scanning
# docker run --rm -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy image cloud-native-app:latest
```

### Kubernetes Security
```yaml
apiVersion: v1
kind: Pod
metadata:
  name: secure-app
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 2000
  containers:
  - name: app
    image: cloud-native-app:latest
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      capabilities:
        drop:
        - ALL
```

## Performance Optimization

### Horizontal Pod Autoscaling
```yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: cloud-native-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: cloud-native-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
```

## Sonuç

Cloud-native development, modern uygulama geliştirme için güçlü bir yaklaşımdır. Containerization, orchestration, CI/CD ve monitoring gibi teknolojileri kullanarak ölçeklenebilir, dayanıklı ve güvenli uygulamalar geliştirebilirsiniz.

## Önerilen Araçlar

- **Container Runtime**: Docker, containerd
- **Orchestration**: Kubernetes, Docker Swarm
- **CI/CD**: GitHub Actions, GitLab CI, Jenkins
- **Monitoring**: Prometheus, Grafana, Jaeger
- **Service Mesh**: Istio, Linkerd
- **API Gateway**: Kong, AWS API Gateway 

Cloud-Native Development: Bulut Odaklı Uygulama Geliştirme


# Microservices Mimarisi: Modern Uygulama Geliştirme

Microservices mimarisi, büyük ve karmaşık uygulamaları küçük, bağımsız servislere bölerek yönetmeyi sağlayan modern bir yaklaşımdır.

## Microservices Nedir?

Microservices, tek bir uygulamayı küçük, bağımsız servislere bölen bir mimari yaklaşımdır. Her servis kendi iş mantığını yürütür ve diğer servislerle API'lar aracılığıyla iletişim kurar.

### Temel Özellikler
- **Bağımsızlık**: Her servis bağımsız olarak geliştirilebilir ve deploy edilebilir
- **Tek Sorumluluk**: Her servis belirli bir iş fonksiyonuna odaklanır
- **Teknoloji Çeşitliliği**: Farklı servisler farklı teknolojiler kullanabilir
- **Ölçeklenebilirlik**: Servisler bağımsız olarak ölçeklendirilebilir

## Monolith vs Microservices

### Monolith Avantajları
- Basit geliştirme ve deployment
- Düşük network overhead
- Kolay debugging

### Monolith Dezavantajları
- Tek nokta arızası
- Teknoloji kilidi
- Ölçeklendirme zorluğu

### Microservices Avantajları
- Yüksek erişilebilirlik
- Teknoloji esnekliği
- Bağımsız ölçeklendirme

### Microservices Dezavantajları
- Karmaşık network yapısı
- Distributed system zorlukları
- Operational overhead

## Microservices Tasarım Prensipleri

### 1. Domain-Driven Design (DDD)
```java
// User Service - Domain Model
@Entity
public class User {
    @Id
    private String id;
    private String email;
    private String name;
    
    // Domain logic
    public boolean isActive() {
        return status == UserStatus.ACTIVE;
    }
}
```

### 2. API Gateway Pattern
```yaml
# API Gateway Configuration
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-gateway
spec:
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /users
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 80
```

### 3. Service Discovery
```yaml
# Service Discovery with Consul
spring:
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: user-service
        instance-id: ${spring.application.name}:${random.value}
```

## Communication Patterns

### Synchronous Communication
```java
// REST API Client
@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;
    
    public User getUser(String userId) {
        return restTemplate.getForObject(
            "http://user-service/users/" + userId, 
            User.class
        );
    }
}
```

### Asynchronous Communication
```java
// Event-Driven Communication
@Component
public class OrderEventHandler {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // Process order creation
        notificationService.sendNotification(event.getUserId());
    }
}
```

## Data Management

### Database per Service
```sql
-- User Service Database
CREATE TABLE users (
    id VARCHAR(36) PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    name VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Order Service Database
CREATE TABLE orders (
    id VARCHAR(36) PRIMARY KEY,
    user_id VARCHAR(36) NOT NULL,
    total_amount DECIMAL(10,2) NOT NULL,
    status VARCHAR(50) NOT NULL
);
```

### Saga Pattern
```java
// Saga Coordinator
@Component
public class OrderSaga {
    public void createOrder(OrderRequest request) {
        // Step 1: Create Order
        Order order = orderService.createOrder(request);
        
        // Step 2: Reserve Inventory
        inventoryService.reserveInventory(order.getItems());
        
        // Step 3: Process Payment
        paymentService.processPayment(order.getPaymentInfo());
        
        // Step 4: Confirm Order
        orderService.confirmOrder(order.getId());
    }
}
```

## Deployment Strategies

### Blue-Green Deployment
```yaml
# Blue-Green Deployment with Kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service-blue
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
      version: blue
  template:
    metadata:
      labels:
        app: user-service
        version: blue
    spec:
      containers:
      - name: user-service
        image: user-service:v1.0
```

### Canary Deployment
```yaml
# Canary Deployment
apiVersion: networking.k8s.io/v1
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 90
    - destination:
        host: user-service
        subset: v2
      weight: 10
```

## Monitoring ve Observability

### Distributed Tracing
```java
// Jaeger Integration
@SpringBootApplication
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
    
    @Bean
    public Sampler defaultSampler() {
        return Sampler.ALWAYS_SAMPLE;
    }
}
```

### Health Checks
```java
@Component
public class UserServiceHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        try {
            // Check database connection
            userRepository.count();
            return Health.up().build();
        } catch (Exception e) {
            return Health.down()
                .withException(e)
                .build();
        }
    }
}
```

## Best Practices

### 1. Service Granularity
- Çok küçük servislerden kaçının
- Domain sınırlarına göre bölün
- İş mantığına odaklanın

### 2. API Design
- RESTful API standartlarını takip edin
- Versioning stratejisi belirleyin
- Documentation'ı güncel tutun

### 3. Security
- Service-to-service authentication
- API Gateway'de rate limiting
- Input validation ve sanitization

### 4. Testing
- Unit tests for each service
- Integration tests for service interactions
- End-to-end tests for complete workflows

## Sonuç

Microservices mimarisi, modern uygulama geliştirme için güçlü bir yaklaşımdır. Ancak doğru tasarım, implementasyon ve operasyonel süreçler gerektirir. Başarılı bir microservices implementasyonu için domain-driven design, service discovery, monitoring ve testing stratejilerine odaklanın.

## Önerilen Araçlar

- **API Gateway**: Kong, AWS API Gateway, Azure API Management
- **Service Discovery**: Consul, Eureka, etcd
- **Monitoring**: Prometheus, Grafana, Jaeger
- **Message Broker**: RabbitMQ, Apache Kafka, Redis
- **Container Orchestration**: Kubernetes, Docker Swarm 

Microservices Mimarisi: Modern Uygulama Geliştirme


# Kubernetes Cluster Yönetimi: Best Practices

Kubernetes, container orchestration alanında endüstri standardı haline gelmiştir. Ancak Kubernetes cluster'larının etkili yönetimi, doğru stratejiler ve best practices gerektirir.

## Cluster Tasarımı ve Planlama

### Node Yapılandırması
Kubernetes cluster'ınızı tasarlarken dikkat etmeniz gereken temel noktalar:

- **Master Node'lar**: Yüksek erişilebilirlik için en az 3 master node
- **Worker Node'lar**: İş yüküne göre ölçeklendirilebilir yapı
- **Resource Allocation**: CPU, memory ve storage planlaması

### Networking Stratejisi
- **Service Mesh**: Istio veya Linkerd kullanımı
- **Load Balancing**: Ingress controller yapılandırması
- **Security**: Network policies ve RBAC

## Monitoring ve Observability

### Monitoring Stack
```yaml
# Prometheus ve Grafana kurulumu
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
    scrape_configs:
      - job_name: 'kubernetes-pods'
```

### Logging Çözümleri
- **ELK Stack**: Elasticsearch, Logstash, Kibana
- **Fluentd**: Log aggregation
- **Loki**: Grafana tabanlı log aggregation

## Security Best Practices

### RBAC (Role-Based Access Control)
```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
```

### Network Policies
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
```

## Backup ve Disaster Recovery

### Velero ile Backup
```bash
# Velero kurulumu
velero install \
  --provider aws \
  --plugins velero/velero-plugin-for-aws \
  --bucket k8s-backup \
  --backup-location-config region=us-west-2
```

### Backup Stratejileri
- **Scheduled Backups**: Günlük, haftalık backup'lar
- **Point-in-time Recovery**: Belirli zaman noktasına geri dönüş
- **Cross-cluster Migration**: Cluster'lar arası veri taşıma

## Performance Optimization

### Resource Management
- **Resource Requests/Limits**: Pod'lar için kaynak sınırları
- **Horizontal Pod Autoscaling**: Otomatik ölçeklendirme
- **Vertical Pod Autoscaling**: Dikey ölçeklendirme

### Storage Optimization
- **Persistent Volumes**: Uygun storage class seçimi
- **Storage Classes**: SSD vs HDD performans karşılaştırması
- **Volume Snapshots**: Veri koruma stratejileri

## Troubleshooting

### Debug Teknikleri
```bash
# Pod durumunu kontrol et
kubectl describe pod <pod-name>

# Log'ları incele
kubectl logs <pod-name>

# Exec ile pod'a bağlan
kubectl exec -it <pod-name> -- /bin/bash
```

### Common Issues
- **Pod CrashLoopBackOff**: Uygulama hataları
- **Pending Pods**: Resource yetersizliği
- **ImagePullBackOff**: Container image sorunları

## Sonuç

Kubernetes cluster yönetimi, sürekli öğrenme ve adaptasyon gerektiren bir süreçtir. Doğru monitoring, security ve backup stratejileri ile production-ready bir Kubernetes ortamı oluşturabilirsiniz.

## Önerilen Araçlar

- **Monitoring**: Prometheus, Grafana, AlertManager
- **Security**: Falco, OPA Gatekeeper
- **Backup**: Velero, Kasten
- **CI/CD**: ArgoCD, Flux 

Kubernetes Cluster Yönetimi: Best Practices


# Modern Web Tasarım Trendleri 2024

Web tasarım dünyası sürekli evrim geçiriyor ve 2024 yılında da birçok yeni trend öne çıkıyor. Bu yazıda, kullanıcı deneyimini artıran ve modern web sitelerinde sıkça karşılaştığımız trendleri inceleyeceğiz.

## 1. Minimalist Tasarım

Minimalist tasarım yaklaşımı 2024'te de popülerliğini koruyor. Gereksiz elementlerden arındırılmış, temiz ve odaklanmış tasarımlar kullanıcıların dikkatini dağıtmadan ana mesaja odaklanmasını sağlıyor.

### Minimalist Tasarımın Avantajları:
- **Hızlı yükleme süreleri**
- **Daha iyi kullanıcı deneyimi**
- **Mobil uyumluluk**
- **SEO dostu yapı**

## 2. Karanlık Mod (Dark Mode)

Karanlık mod artık sadece bir trend değil, kullanıcı deneyiminin vazgeçilmez bir parçası. Göz yorgunluğunu azaltan ve modern görünüm sağlayan karanlık mod, birçok web sitesinde standart hale geldi.

```css
/* Karanlık mod örneği */
.dark-mode {
  background-color: #1a1a1a;
  color: #ffffff;
}

.dark-mode .card {
  background-color: #2d2d2d;
  border: 1px solid #404040;
}
```

## 3. Mikro Etkileşimler

Küçük animasyonlar ve geçiş efektleri kullanıcı deneyimini önemli ölçüde artırıyor. Hover efektleri, loading animasyonları ve sayfa geçişleri kullanıcıları etkilemek için kullanılıyor.

### Popüler Mikro Etkileşimler:
- **Hover efektleri**
- **Loading animasyonları**
- **Sayfa geçişleri**
- **Scroll animasyonları**

## 4. Glassmorphism

Cam efekti olarak da bilinen glassmorphism, şeffaf ve bulanık arka planlar kullanarak modern bir görünüm sağlıyor. Bu trend özellikle kartlar ve modal pencerelerde sıkça kullanılıyor.

```css
.glassmorphism {
  background: rgba(255, 255, 255, 0.25);
  backdrop-filter: blur(10px);
  border: 1px solid rgba(255, 255, 255, 0.18);
  border-radius: 10px;
}
```

## 5. Responsive Tasarım

Mobil cihazların kullanımının artmasıyla birlikte, responsive tasarım artık bir zorunluluk haline geldi. Tüm cihazlarda mükemmel görünen web siteleri tasarlamak kritik önem taşıyor.

### Responsive Tasarım Prensipleri:
1. **Mobile-first yaklaşım**
2. **Esnek grid sistemleri**
3. **Uyarlanabilir görseller**
4. **Touch-friendly arayüzler**

## Sonuç

2024'te başarılı bir web sitesi tasarlamak için bu trendleri göz önünde bulundurmanız önemli. Ancak unutmayın ki, trendleri takip etmek kadar kullanıcı deneyimini ön planda tutmak da kritik.

> **Önemli Not:** Trendleri takip ederken, sitenizin hedef kitlesine ve amacına uygun olanları seçmeye dikkat edin.

### Kaynaklar:
- [Web Design Trends 2024](https://example.com)
- [UI/UX Best Practices](https://example.com)
- [Mobile Design Guidelines](https://example.com) 

Modern Web Tasarım Trendleri 2024


# 2024'te DevOps Uygulamaları ve Trendler

DevOps, yazılım geliştirme ve operasyonlar arasındaki boşluğu kapatmak için geliştirilen bir kültür ve uygulama setidir. 2024 yılında DevOps uygulamaları daha da gelişmiş ve olgunlaşmış durumda.

## DevOps'un Temel Prensipleri

DevOps'un başarılı olması için uyulması gereken temel prensipler şunlardır:

### 1. Sürekli Entegrasyon (CI)
Kod değişikliklerinin sürekli olarak ana branch'e entegre edilmesi ve otomatik testlerin çalıştırılması.

### 2. Sürekli Dağıtım (CD)
Test edilmiş kodun otomatik olarak production ortamına dağıtılması.

### 3. Otomasyon
Manuel süreçlerin otomatikleştirilmesi ve hata riskinin minimize edilmesi.

## 2024'te Öne Çıkan DevOps Araçları

### Container Teknolojileri
- **Docker**: Uygulama konteynerizasyonu
- **Kubernetes**: Container orchestration
- **Podman**: Docker alternatifi

### CI/CD Araçları
- **GitHub Actions**: GitHub tabanlı CI/CD
- **GitLab CI/CD**: GitLab entegrasyonu
- **Jenkins**: Açık kaynak CI/CD server

### Infrastructure as Code (IaC)
- **Terraform**: Multi-cloud infrastructure management
- **Ansible**: Configuration management
- **Pulumi**: Modern IaC platform

## DevOps Kültürü

DevOps sadece araçlar değil, aynı zamanda bir kültür değişikliğidir:

- **İşbirliği**: Geliştirici ve operasyon ekiplerinin yakın çalışması
- **Şeffaflık**: Süreçlerin ve metriklerin görünür olması
- **Sürekli İyileştirme**: Sürekli öğrenme ve adaptasyon

## Sonuç

DevOps, modern yazılım geliştirme süreçlerinin vazgeçilmez bir parçası haline gelmiştir. 2024'te daha da gelişmiş araçlar ve uygulamalarla birlikte, DevOps kültürü organizasyonların dijital dönüşüm süreçlerinde kritik rol oynamaya devam edecektir. 

2024'te DevOps Uygulamaları ve Trendler

# SEO Optimizasyonu: Başarılı Stratejiler

Arama motoru optimizasyonu (SEO), web sitenizin arama motorlarında üst sıralarda yer almasını sağlayan en önemli dijital pazarlama stratejilerinden biridir. Bu yazıda, başarılı bir SEO stratejisi geliştirmek için uygulamanız gereken adımları inceleyeceğiz.

## 1. Anahtar Kelime Araştırması

SEO'nun temeli anahtar kelime araştırmasıdır. Hedef kitlenizin hangi kelimeleri aradığını belirlemek ve bu kelimeleri içeriğinizde doğal bir şekilde kullanmak kritik önem taşır.

### Anahtar Kelime Araştırma Araçları:
- **Google Keyword Planner**
- **Ahrefs**
- **SEMrush**
- **Ubersuggest**
- **Answer The Public**

### Anahtar Kelime Türleri:
1. **Long-tail anahtar kelimeler** - Daha spesifik ve düşük rekabet
2. **Short-tail anahtar kelimeler** - Genel ve yüksek rekabet
3. **LSI anahtar kelimeler** - Semantik olarak ilişkili kelimeler

## 2. İçerik Kalitesi

Google ve diğer arama motorları, kullanıcılara değer katan kaliteli içerikleri ödüllendirir. Orijinal, bilgilendirici ve güncel içerikler oluşturmak SEO başarınızı artırır.

### Kaliteli İçerik Özellikleri:
- **Orijinal ve benzersiz**
- **Kapsamlı ve detaylı**
- **Güncel ve doğru**
- **Kullanıcı dostu**
- **Görsel destekli**

## 3. Teknik SEO

Site hızı, mobil uyumluluk, güvenli bağlantı (HTTPS) ve site haritası gibi teknik faktörler SEO performansınızı doğrudan etkiler.

### Teknik SEO Kontrol Listesi:

```html

<title>SEO Optimizasyonu: Başarılı Stratejiler | Site Adı</title>


<meta name="description" content="SEO optimizasyonu için uygulamanız gereken temel stratejiler ve teknikler hakkında detaylı rehber.">


<link rel="canonical" href="https://siteadi.com/seo-optimizasyonu" />
```

### Performans Optimizasyonu:
- **Sayfa yükleme hızı** (3 saniyeden az)
- **Core Web Vitals** skorları
- **Mobil uyumluluk**
- **HTTPS kullanımı**

## 4. Backlink Stratejisi

Kaliteli web sitelerinden gelen backlinkler, sitenizin otoritesini artırır ve arama motoru sıralamalarında yükselmenizi sağlar.

### Backlink Kalitesi Faktörleri:
- **Domain Authority (DA)**
- **Relevance (İlgi)**
- **Anchor text çeşitliliği**
- **Doğal link profili**

### Backlink Kazanma Yöntemleri:
1. **Guest posting**
2. **Broken link building**
3. **Infographic paylaşımı**
4. **İçerik pazarlaması**
5. **Sosyal medya etkileşimi**

## 5. Kullanıcı Deneyimi

Kullanıcıların sitenizde geçirdiği süre, sayfa görüntüleme sayısı ve hemen çıkma oranı gibi metrikler SEO performansınızı etkiler.

### UX İyileştirme Önerileri:
- **Kolay navigasyon**
- **Hızlı sayfa yükleme**
- **Mobil uyumlu tasarım**
- **Açık ve okunabilir yazı tipi**
- **Call-to-action butonları**

## SEO İpuçları

### On-Page SEO:
- [x] Meta başlıklarınızı optimize edin
- [x] Alt etiketlerini kullanın
- [x] İç linkleme yapın
- [x] Sayfa hızını artırın
- [x] Mobil uyumluluğu sağlayın

### Off-Page SEO:
- [x] Kaliteli backlinkler kazanın
- [x] Sosyal medya varlığınızı güçlendirin
- [x] Online itibarınızı yönetin
- [x] İçerik pazarlaması yapın

## Sonuç

SEO uzun vadeli bir stratejidir ve sonuçlarını görmek zaman alır. Tutarlı bir şekilde kaliteli içerik üretmek ve teknik optimizasyonları yapmak, arama motoru sıralamalarında başarılı olmanın anahtarıdır.

> **SEO Altın Kuralı:** Kullanıcılar için optimize edin, arama motorları takip edecektir.

### Önerilen Araçlar:
- **Google Search Console** - Ücretsiz SEO analizi
- **Google Analytics** - Trafik analizi
- **PageSpeed Insights** - Performans testi
- **Mobile-Friendly Test** - Mobil uyumluluk kontrolü

SEO Optimizasyonu: Başarılı Stratejiler


# AI/ML ve DevOps Entegrasyonu: MLOps Pratikleri

MLOps (Machine Learning Operations), makine öğrenmesi modellerinin geliştirilmesi, deployment'ı ve yönetimi için DevOps pratiklerinin uygulanmasıdır.

## MLOps Nedir?

MLOps, makine öğrenmesi projelerinde sürekli entegrasyon, sürekli deployment ve sürekli monitoring pratiklerini uygulayarak, ML modellerinin production ortamında güvenilir ve ölçeklenebilir şekilde çalışmasını sağlar.

### MLOps'un Faydaları
- **Hızlı Deployment**: Modellerin hızlı ve güvenli deployment'ı
- **Model Monitoring**: Production'da model performansının takibi
- **Reproducibility**: Deneylerin tekrarlanabilirliği
- **Collaboration**: Veri bilimcileri ve mühendisler arası işbirliği

## MLOps Pipeline

### 1. Data Pipeline
```python
# Data ingestion pipeline
import pandas as pd
from sklearn.model_selection import train_test_split
import mlflow

def load_and_preprocess_data():
    """Veri yükleme ve ön işleme"""
    # Veri yükleme
    df = pd.read_csv('data/raw/customer_data.csv')
    
    # Veri temizleme
    df = df.dropna()
    df = df.drop_duplicates()
    
    # Feature engineering
    df['age_group'] = pd.cut(df['age'], bins=[0, 25, 35, 50, 100], 
                            labels=['Genç', 'Orta', 'Yetişkin', 'Yaşlı'])
    
    return df

def split_data(df):
    """Veriyi train/test olarak böl"""
    X = df.drop('target', axis=1)
    y = df['target']
    
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    
    return X_train, X_test, y_train, y_test
```

### 2. Model Training Pipeline
```python
# Model training with MLflow
import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

def train_model(X_train, y_train, X_test, y_test):
    """Model eğitimi ve değerlendirme"""
    
    # MLflow experiment başlat
    mlflow.set_experiment("customer-churn-prediction")
    
    with mlflow.start_run():
        # Model parametreleri
        params = {
            'n_estimators': 100,
            'max_depth': 10,
            'random_state': 42
        }
        
        # Model eğitimi
        model = RandomForestClassifier(**params)
        model.fit(X_train, y_train)
        
        # Tahminler
        y_pred = model.predict(X_test)
        accuracy = accuracy_score(y_test, y_pred)
        
        # MLflow'a log
        mlflow.log_params(params)
        mlflow.log_metric("accuracy", accuracy)
        mlflow.log_metric("precision", precision_score(y_test, y_pred, average='weighted'))
        mlflow.log_metric("recall", recall_score(y_test, y_pred, average='weighted'))
        
        # Model kaydet
        mlflow.sklearn.log_model(model, "model")
        
        return model, accuracy
```

### 3. Model Registry
```python
# Model registry yönetimi
import mlflow
from mlflow.tracking import MlflowClient

def register_model(run_id, model_name):
    """Model'i registry'ye kaydet"""
    client = MlflowClient()
    
    # Model'i registry'ye kaydet
    model_uri = f"runs:/{run_id}/model"
    model_details = mlflow.register_model(model_uri, model_name)
    
    # Production'a promote et
    client.transition_model_version_stage(
        name=model_name,
        version=model_details.version,
        stage="Production"
    )
    
    return model_details
```

## Containerization

### Dockerfile for ML Model
```dockerfile
# ML model için Dockerfile
FROM python:3.9-slim

WORKDIR /app

# Gerekli paketleri kopyala
COPY requirements.txt .
RUN pip install -r requirements.txt

# Model dosyalarını kopyala
COPY models/ ./models/
COPY app.py .

# Environment variables
ENV MODEL_PATH=/app/models/model.pkl
ENV PORT=8000

EXPOSE 8000

CMD ["python", "app.py"]
```

### Model Serving Application
```python
# Flask app for model serving
from flask import Flask, request, jsonify
import pickle
import pandas as pd
import os

app = Flask(__name__)

# Model yükle
model_path = os.getenv('MODEL_PATH', '/app/models/model.pkl')
with open(model_path, 'rb') as f:
    model = pickle.load(f)

@app.route('/predict', methods=['POST'])
def predict():
    """Tahmin endpoint'i"""
    try:
        data = request.get_json()
        features = pd.DataFrame(data)
        
        # Tahmin yap
        prediction = model.predict(features)
        probability = model.predict_proba(features)
        
        return jsonify({
            'prediction': prediction.tolist(),
            'probability': probability.tolist(),
            'status': 'success'
        })
    except Exception as e:
        return jsonify({
            'error': str(e),
            'status': 'error'
        }), 400

@app.route('/health', methods=['GET'])
def health():
    """Health check endpoint"""
    return jsonify({'status': 'healthy'})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=int(os.getenv('PORT', 8000)))
```

## Kubernetes Deployment

### ML Model Deployment
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-model-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-model
  template:
    metadata:
      labels:
        app: ml-model
    spec:
      containers:
      - name: ml-model
        image: ml-model:latest
        ports:
        - containerPort: 8000
        env:
        - name: MODEL_PATH
          value: "/app/models/model.pkl"
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 5
```

### Model Service
```yaml
apiVersion: v1
kind: Service
metadata:
  name: ml-model-service
spec:
  selector:
    app: ml-model
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: LoadBalancer
```

## CI/CD Pipeline for ML

### GitHub Actions for MLOps
```yaml
name: MLOps Pipeline

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

jobs:
  data-validation:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Python
      uses: actions/setup-python@v3
      with:
        python-version: '3.9'
    
    - name: Install dependencies
      run: |
        pip install -r requirements.txt
    
    - name: Run data validation
      run: |
        python scripts/validate_data.py
    
    - name: Run data tests
      run: |
        python -m pytest tests/test_data.py

  model-training:
    needs: data-validation
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Python
      uses: actions/setup-python@v3
      with:
        python-version: '3.9'
    
    - name: Install dependencies
      run: |
        pip install -r requirements.txt
    
    - name: Set up MLflow
      run: |
        mlflow server --host 0.0.0.0 --port 5000 &
    
    - name: Train model
      run: |
        python scripts/train_model.py
    
    - name: Evaluate model
      run: |
        python scripts/evaluate_model.py

  model-deployment:
    needs: model-training
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
    - uses: actions/checkout@v3
    
    - name: Build Docker image
      run: |
        docker build -t ml-model:${{ github.sha }} .
    
    - name: Push to registry
      run: |
        echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
        docker push ml-model:${{ github.sha }}
    
    - name: Deploy to Kubernetes
      run: |
        kubectl set image deployment/ml-model-deployment ml-model=ml-model:${{ github.sha }}
```

## Model Monitoring

### Model Performance Monitoring
```python
# Model monitoring script
import mlflow
import pandas as pd
from sklearn.metrics import accuracy_score, precision_score, recall_score
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def monitor_model_performance():
    """Model performansını izle"""
    
    # Production verilerini al
    production_data = pd.read_csv('data/production/predictions.csv')
    
    # Gerçek değerler vs tahminler
    y_true = production_data['actual']
    y_pred = production_data['predicted']
    
    # Metrikleri hesapla
    accuracy = accuracy_score(y_true, y_pred)
    precision = precision_score(y_true, y_pred, average='weighted')
    recall = recall_score(y_true, y_pred, average='weighted')
    
    # MLflow'a log
    with mlflow.start_run():
        mlflow.log_metric("production_accuracy", accuracy)
        mlflow.log_metric("production_precision", precision)
        mlflow.log_metric("production_recall", recall)
    
    # Alert thresholds
    if accuracy < 0.8:
        logger.warning(f"Model accuracy below threshold: {accuracy}")
        # Send alert
    
    return accuracy, precision, recall

def detect_data_drift():
    """Veri drift'ini tespit et"""
    from scipy import stats
    
    # Training data
    train_data = pd.read_csv('data/train/train_data.csv')
    
    # Production data
    prod_data = pd.read_csv('data/production/production_data.csv')
    
    # Kolmogorov-Smirnov test
    for column in train_data.select_dtypes(include=[np.number]).columns:
        ks_stat, p_value = stats.ks_2samp(
            train_data[column], 
            prod_data[column]
        )
        
        if p_value < 0.05:
            logger.warning(f"Data drift detected in column: {column}")
```

### Prometheus Metrics
```python
# Prometheus metrics for ML model
from prometheus_client import Counter, Histogram, Gauge
import time

# Metrics
PREDICTION_COUNTER = Counter('ml_predictions_total', 'Total predictions made')
PREDICTION_DURATION = Histogram('ml_prediction_duration_seconds', 'Prediction duration')
MODEL_ACCURACY = Gauge('ml_model_accuracy', 'Current model accuracy')

@app.route('/predict', methods=['POST'])
def predict():
    """Tahmin endpoint'i with metrics"""
    start_time = time.time()
    
    try:
        data = request.get_json()
        features = pd.DataFrame(data)
        
        # Tahmin yap
        prediction = model.predict(features)
        
        # Metrics güncelle
        PREDICTION_COUNTER.inc()
        PREDICTION_DURATION.observe(time.time() - start_time)
        
        return jsonify({
            'prediction': prediction.tolist(),
            'status': 'success'
        })
    except Exception as e:
        return jsonify({
            'error': str(e),
            'status': 'error'
        }), 400

@app.route('/metrics', methods=['GET'])
def metrics():
    """Prometheus metrics endpoint"""
    return generate_latest()
```

## A/B Testing

### Model A/B Testing
```python
# A/B testing for ML models
import random
from flask import request

def get_model_version():
    """A/B testing için model versiyonu seç"""
    user_id = request.headers.get('User-ID')
    
    # Consistent hashing for user assignment
    hash_value = hash(user_id) % 100
    
    if hash_value < 50:
        return 'model-v1'  # Control group
    else:
        return 'model-v2'  # Treatment group

@app.route('/predict', methods=['POST'])
def predict_ab():
    """A/B testing ile tahmin"""
    model_version = get_model_version()
    
    # Model versiyonuna göre tahmin yap
    if model_version == 'model-v1':
        prediction = model_v1.predict(features)
    else:
        prediction = model_v2.predict(features)
    
    # A/B testing metrics
    AB_TEST_COUNTER.labels(model_version=model_version).inc()
    
    return jsonify({
        'prediction': prediction.tolist(),
        'model_version': model_version,
        'status': 'success'
    })
```

## Sonuç

MLOps, makine öğrenmesi projelerinin production ortamında başarılı bir şekilde çalışması için kritik öneme sahiptir. Doğru araçlar ve pratiklerle, ML modellerinizi güvenilir, ölçeklenebilir ve sürdürülebilir şekilde yönetebilirsiniz.

## Önerilen Araçlar

- **Experiment Tracking**: MLflow, Weights & Biases, Neptune
- **Model Registry**: MLflow Model Registry, AWS SageMaker Model Registry
- **Feature Store**: Feast, Tecton, Hopsworks
- **Model Serving**: TensorFlow Serving, TorchServe, Seldon Core
- **Monitoring**: Prometheus, Grafana, Evidently AI
- **Orchestration**: Apache Airflow, Kubeflow, Argo Workflows 

AI/ML ve DevOps Entegrasyonu: MLOps Pratikleri


Selamlar; CentOS sunucuda Software RAID yaptınız ama sistem açılmıyor mu? Verilerinizi kurtarmak için CentOS CD'si ile Rescue modda sunucuyu açın.

Hangi RAID sistemini kullanıyorsanız disk sayısına göre aşağıdaki komutu girin.

Benim sistemimde her diskte 3 partition vardı ve veriler 3. partition içindeydi. Yani `sda3` içindeydi. Sizin sisteminizde `sda1` ise aşağıdaki kodları ona göre düzeltiniz.

```bash
mdadm --assemble --run --force /dev/md2 /dev/sda3 /dev/sdb3 /dev/sdc3 /dev/sdd3
```

RAID birimini aktif ettikten sonra disk içeriğini görmek için mount etmeniz gerekiyor:

```bash
mount /dev/md2 /mnt
```

Artık RAID'li sistemdeki dosyaları görebilirsiniz. Dilerseniz bu sistemi doğrudan kullanmak için `chroot` yapılabilir; ancak bazı durumlarda `chroot` çalışmayabilir.


CentOS Rescue Mode ile Software RAID Mount


cPanel sunucularda otomatik olarak Mail IP adresini değiştiren bir bash script'e rastladım. Bu scripti paylaşmak istedim. `crontab`'e ekleyerek periyodik çalıştırabilirsiniz.

Script, `/etc/mailipaddrpool` dosyasındaki IP listesini kullanır ve `/etc/mailips` içindeki `*:` satırını sıradaki IP ile günceller.

```bash
#!/bin/bash
# Exim Outgoing IP address rotator
# The cPanel Admin 5/9/11
# Files: /etc/mailipaddrpool : list of IP addresses to use for mail

ipfile=/etc/mailipaddrpool
curip=$(grep "*:" /etc/mailips |awk '{print $2}')

if [[ "$curip" == "" ]] || ! grep $curip $ipfile >/dev/null ; then
	curip=$(tail -1 $ipfile)
fi

nextipct=$(cat $ipfile |grep -A 1 $curip |wc -l)

if [ "$nextipct" == "1" ];then
	nextip=$(head -1 $ipfile)
else
	nextip=$(cat $ipfile |grep -A 1 $curip | tail -1)
fi

sed '/*:/d' -i /etc/mailips
sed '/^$/d' -i /etc/mailips
echo "*: $nextip" >> /etc/mailips
```

Örnek `crontab` girişi (her saat çalıştırır):

```bash
0 * * * * /root/scripts/rotate-mail-ip.sh >/dev/null 2>&1
```

Notlar:
- `/etc/mailipaddrpool` içinde her satıra bir IP gelecek şekilde listeler.
- Exim servisinin yapılandırmasına göre değişiklikten sonra servisi yeniden yüklemek gerekebilir: `service exim reload` veya `systemctl reload exim`.



Blog