# Elastic Beanstalk Deployment Guide

Schritt-für-Schritt Anleitung für das Deployment des Image Services auf AWS Elastic Beanstalk.

## 📋 Voraussetzungen

### 1. AWS Account
- AWS Account mit Admin-Rechten
- AWS CLI konfiguriert
- EB CLI installiert

### 2. Tools installieren

```bash
# AWS CLI (macOS)
brew install awscli

# EB CLI
pip install awsebcli

# Docker
# Docker Desktop von https://www.docker.com/products/docker-desktop installieren
```

### 3. AWS Credentials konfigurieren

```bash
# AWS CLI konfigurieren
aws configure

# Eingeben:
# AWS Access Key ID: [Dein Access Key]
# AWS Secret Access Key: [Dein Secret Key]
# Default region name: eu-central-1 (oder deine bevorzugte Region)
# Default output format: json
```

### 4. IAM Rollen erstellen (falls noch nicht vorhanden)

Die folgenden IAM Rollen werden benötigt:

1. **aws-elasticbeanstalk-ec2-role**
   - Policies: AWSElasticBeanstalkWebTier, AWSElasticBeanstalkWorkerTier, AWSElasticBeanstalkMulticontainerDocker

2. **aws-elasticbeanstalk-service-role**
   - Policies: AWSElasticBeanstalkEnhancedHealth, AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy

## 🚀 Deployment Schritte

### Option A: Automatisches Deployment (Empfohlen)

#### 1. Initiales Setup (nur einmal)

```bash
cd backend-image-service

# Environment erstellen
./init-eb-environment.sh image-service-prod

# Warte 5-10 Minuten bis Environment fertig ist
```

Das Script:
- ✅ Erstellt EB Application
- ✅ Erstellt EB Environment
- ✅ Konfiguriert Load Balancer
- ✅ Richtet Health Checks ein
- ✅ Konfiguriert Auto-Scaling (1-4 Instanzen)

#### 2. Updates deployen

```bash
# Nach Code-Änderungen deployen
./deploy-to-eb.sh image-service-prod

# Warte 5-10 Minuten bis Deployment fertig ist
```

Das Script:
- ✅ Baut Docker Image
- ✅ Pushed zu Docker Hub (optional)
- ✅ Erstellt neue Application Version
- ✅ Updated EB Environment
- ✅ Wartet auf erfolgreichen Deployment
- ✅ Testet Health Endpoint

### Option B: Manuelles Deployment

#### 1. Docker Image bauen und pushen

```bash
cd image-service

# Image bauen
docker build -t releasebird/image-service:latest .

# (Optional) Zu Docker Hub pushen
docker login
docker push releasebird/image-service:latest
```

#### 2. EB CLI initialisieren

```bash
# In image-service/ Directory
eb init releasebird-image-service \
    --platform docker \
    --region eu-central-1
```

#### 3. Environment erstellen

```bash
eb create image-service-prod \
    --instance-type t3.medium \
    --envvars NODE_ENV=production,PORT=3000 \
    --elb-type application
```

#### 4. Updates deployen

```bash
# Jedes Mal wenn du Updates hast
eb deploy image-service-prod
```

## 🔧 Konfiguration

### Environment Variablen

In der AWS Console oder via CLI:

```bash
eb setenv NODE_ENV=production PORT=3000
```

### Instance Type

Standard: `t3.medium` (2 vCPU, 4 GB RAM)

Für hohe Last:
```bash
eb scale 4 --instance-type t3.large
```

### Auto-Scaling

Konfiguriert in `.ebextensions/01_environment.config`:
- **Min:** 1 Instance
- **Max:** 4 Instances

Anpassen:
```yaml
aws:autoscaling:asg:
  MinSize: 2      # Minimum Instances
  MaxSize: 10     # Maximum Instances
```

### Health Checks

Konfiguriert für `/health` Endpoint:
- **Interval:** 30 Sekunden
- **Timeout:** 10 Sekunden
- **Unhealthy Threshold:** 3
- **Healthy Threshold:** 2

## 📊 Monitoring & Logs

### Logs anzeigen

```bash
# Aktuelle Logs
eb logs

# Logs streamen
eb logs --stream

# Logs für bestimmte Instance
eb ssh -e image-service-prod
# Dann auf der Instance:
tail -f /var/log/eb-docker/containers/eb-current-app/*.log
```

### CloudWatch Logs

Logs werden automatisch zu CloudWatch gestreamt:
- Log Group: `/aws/elasticbeanstalk/image-service-prod`
- Retention: 7 Tage (konfigurierbar in `.ebextensions/02_cloudwatch.config`)

### Status überprüfen

```bash
# Environment Status
eb status

# Environment Health
eb health

# Detaillierte Health Info
eb health --refresh
```

## 💰 Kosten

Geschätzte monatliche Kosten (eu-central-1):

### Development/Low Traffic
- **Instance:** 1x t3.medium
  - Kosten: ~$30/Monat
- **Load Balancer:** Application LB
  - Kosten: ~$16/Monat
- **Data Transfer:** Minimal
  - Kosten: ~$1-5/Monat

**Total: ~$50-60/Monat**

### Production/High Traffic
- **Instances:** 2-4x t3.medium (Auto-Scaling)
  - Kosten: ~$60-120/Monat
- **Load Balancer:** Application LB
  - Kosten: ~$16/Monat
- **Data Transfer:** Moderate
  - Kosten: ~$10-20/Monat

**Total: ~$90-160/Monat**

### Kosten reduzieren

1. **Spot Instances nutzen:**
```bash
eb create ... --enable-spot
```
Spart ~70% bei Instance-Kosten

2. **Kleinere Instance für Low Traffic:**
```bash
--instance-type t3.small  # 2 vCPU, 2 GB RAM
```

3. **Single Instance (kein Load Balancer):**
```bash
eb create ... --single
```
Spart Load Balancer Kosten (~$16/Monat)

## 🔐 Sicherheit

### 1. Security Groups

EB erstellt automatisch Security Groups:
- **Inbound:** Port 80 (HTTP) von überall
- **Outbound:** Alle Ports

Für HTTPS hinzufügen:
```bash
# SSL Certificate in AWS Certificate Manager erstellen
# Dann in EB Console: Configuration > Load Balancer > Listeners > Add HTTPS
```

### 2. IAM Rollen

Least-Privilege Prinzip:
- EC2 Role: Nur für Docker Pull und CloudWatch Logs
- Service Role: Nur für EB Management

### 3. Environment Properties

Sensible Daten nicht in Code committen:
```bash
# Secrets via Environment Variables
eb setenv API_KEY=your-secret-key
```

## 🚨 Troubleshooting

### Problem: Docker Image Pull schlägt fehl

**Lösung:**
```bash
# 1. Prüfe ob Image public ist auf Docker Hub
# 2. Oder erstelle ECR Repository:

aws ecr create-repository --repository-name image-service

# Image zu ECR pushen:
$(aws ecr get-login --no-include-email)
docker tag releasebird/image-service:latest \
  123456789.dkr.ecr.eu-central-1.amazonaws.com/image-service:latest
docker push 123456789.dkr.ecr.eu-central-1.amazonaws.com/image-service:latest

# Dockerrun.aws.json updaten mit ECR URL
```

### Problem: Health Checks schlagen fehl

**Debug:**
```bash
# SSH in Instance
eb ssh

# Docker Logs anschauen
sudo docker logs $(sudo docker ps -q)

# Health Endpoint testen
curl http://localhost:3000/health
```

### Problem: Out of Memory

**Lösung:**
```bash
# Größere Instance Type
eb scale 1 --instance-type t3.large

# Oder Memory Swap erhöhen (in .ebextensions/)
```

### Problem: Slow Deployments

**Lösung:**
```bash
# Rolling Deployments konfigurieren
# In .ebextensions/03_resources.config bereits konfiguriert

# Oder immutable deployments für Zero-Downtime
eb config
# Ändere DeploymentPolicy zu: Immutable
```

## 📞 Support & Weitere Ressourcen

### AWS Dokumentation
- [Elastic Beanstalk Docker](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/docker.html)
- [EB CLI Command Reference](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3.html)

### Nützliche Befehle

```bash
# Environment neu starten
eb restart

# Environment löschen
eb terminate image-service-prod

# Environment klonen
eb clone image-service-prod --clone-name image-service-staging

# SSH in Instance
eb ssh

# Environment config anzeigen
eb config

# Saved configs
eb config save --cfg prod-config
eb config put prod-config
```

## 🎯 Production Checklist

Vor Production Deployment:

- [ ] AWS Account Setup
- [ ] IAM Rollen erstellt
- [ ] Docker Image getestet
- [ ] Environment Variables konfiguriert
- [ ] Health Checks funktionieren
- [ ] SSL Certificate erstellt (für HTTPS)
- [ ] CloudWatch Alarms eingerichtet
- [ ] Auto-Scaling Limits geprüft
- [ ] Backup/Disaster Recovery Plan
- [ ] Monitoring Dashboard (CloudWatch)
- [ ] Cost Alerts konfiguriert
- [ ] Team hat Zugriff auf AWS Console

## 🚀 Quick Commands Cheat Sheet

```bash
# Setup
./init-eb-environment.sh image-service-prod

# Deploy
./deploy-to-eb.sh image-service-prod

# Status
eb status

# Logs
eb logs --stream

# Scale
eb scale 4

# Restart
eb restart

# SSH
eb ssh

# Terminate
eb terminate image-service-prod
```

---

**Ready to deploy!** 🎉

Fragen? Siehe [README.md](README.md) oder [QUICKSTART.md](QUICKSTART.md)
