Production Deployment

Deployment Options

Crafter LoL can be deployed to various platforms:

Docker Compose

Simple single-server deployment

Kubernetes

Scalable container orchestration

Cloud Platforms

AWS, GCP, Azure managed services

Platform as a Service

Heroku, Render, Railway

Pre-Deployment Checklist

Update Data Dragon Version

Ensure you’re using the latest League of Legends patch:

curl https://ddragon.leagueoflegends.com/api/versions.json

Update application.properties:

ddragon.version=16.3.1

Configure Environment Variables

Set production values for:

PORT
CORS_ORIGINS
ddragon.version
VITE_API_URL

Build Production Assets

Backend:

cd source/Back/crafter
mvn clean package -DskipTests

Frontend:

cd source/Front/Crafter_League_of_Legends
npm run build

Security Review

Enable HTTPS
Set restrictive CORS origins
Use environment variables for secrets
Implement rate limiting
Review exposed ports

Docker Compose Deployment

Production docker-compose.yml

Create docker-compose.prod.yml:

version: '3.8'

services:
  backend:
    image: crafter-lol-backend:latest
    container_name: crafter-backend-prod
    ports:
      - "5000:5000"
    environment:
      - PORT=5000
      - CORS_ORIGINS=${FRONTEND_URL}
      - ddragon.version=16.3.1
      - ddragon.language=es_MX
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
        reservations:
          cpus: '0.5'
          memory: 256M
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:5000/api/game/question"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

  frontend:
    image: crafter-lol-frontend:latest
    container_name: crafter-frontend-prod
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/ssl:/etc/nginx/ssl:ro
    depends_on:
      backend:
        condition: service_healthy
    restart: unless-stopped
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

  # Optional: Reverse proxy with Nginx
  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
      - ./nginx/logs:/var/log/nginx
    depends_on:
      - backend
      - frontend
    restart: unless-stopped

Deploy

# Set environment variables
export FRONTEND_URL=https://yourdomain.com

# Pull latest images
docker-compose -f docker-compose.prod.yml pull

# Start services
docker-compose -f docker-compose.prod.yml up -d

# Check status
docker-compose -f docker-compose.prod.yml ps

Kubernetes Deployment

Backend Deployment

Create k8s/backend-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: crafter-backend
  labels:
    app: crafter-backend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: crafter-backend
  template:
    metadata:
      labels:
        app: crafter-backend
    spec:
      containers:
      - name: backend
        image: crafter-lol-backend:latest
        ports:
        - containerPort: 5000
        env:
        - name: PORT
          value: "5000"
        - name: CORS_ORIGINS
          valueFrom:
            configMapKeyRef:
              name: crafter-config
              key: frontend-url
        - name: ddragon.version
          value: "16.3.1"
        resources:
          limits:
            cpu: "1000m"
            memory: "512Mi"
          requests:
            cpu: "500m"
            memory: "256Mi"
        livenessProbe:
          httpGet:
            path: /api/game/question
            port: 5000
          initialDelaySeconds: 40
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /api/game/question
            port: 5000
          initialDelaySeconds: 30
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: crafter-backend-service
spec:
  selector:
    app: crafter-backend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 5000
  type: LoadBalancer

Frontend Deployment

Create k8s/frontend-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: crafter-frontend
  labels:
    app: crafter-frontend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: crafter-frontend
  template:
    metadata:
      labels:
        app: crafter-frontend
    spec:
      containers:
      - name: frontend
        image: crafter-lol-frontend:latest
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: "500m"
            memory: "128Mi"
          requests:
            cpu: "250m"
            memory: "64Mi"
---
apiVersion: v1
kind: Service
metadata:
  name: crafter-frontend-service
spec:
  selector:
    app: crafter-frontend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

ConfigMap

Create k8s/configmap.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: crafter-config
data:
  frontend-url: "https://yourdomain.com"
  ddragon-version: "16.3.1"
  ddragon-language: "es_MX"

Deploy to Kubernetes

# Apply configurations
kubectl apply -f k8s/configmap.yaml
kubectl apply -f k8s/backend-deployment.yaml
kubectl apply -f k8s/frontend-deployment.yaml

# Check status
kubectl get pods
kubectl get services

# View logs
kubectl logs -f deployment/crafter-backend

AWS Deployment

Using AWS Elastic Beanstalk

Install EB CLI

pip install awsebcli

Initialize Application

cd source/Back/crafter
eb init -p docker crafter-lol-backend

Create Environment

eb create crafter-prod-env \
  --instance-type t3.medium \
  --envvars PORT=5000,CORS_ORIGINS=https://yourdomain.com

Deploy

eb deploy

Check Status

eb status
eb logs

Using AWS ECS (Fargate)

Push Images to ECR

# Authenticate
aws ecr get-login-password --region us-east-1 | \
  docker login --username AWS --password-stdin <account-id>.dkr.ecr.us-east-1.amazonaws.com

# Tag and push backend
docker tag crafter-lol-backend:latest <account-id>.dkr.ecr.us-east-1.amazonaws.com/crafter-backend:latest
docker push <account-id>.dkr.ecr.us-east-1.amazonaws.com/crafter-backend:latest

# Tag and push frontend
docker tag crafter-lol-frontend:latest <account-id>.dkr.ecr.us-east-1.amazonaws.com/crafter-frontend:latest
docker push <account-id>.dkr.ecr.us-east-1.amazonaws.com/crafter-frontend:latest

Create Task Definition

Use AWS Console or CLI to create ECS task definition with:

Backend container: 512 CPU, 1024 Memory
Frontend container: 256 CPU, 512 Memory
Environment variables

Create ECS Service

Choose Fargate launch type
Configure load balancer
Set desired task count (2-3 for HA)
Enable auto-scaling

Heroku Deployment

Backend on Heroku

Install Heroku CLI

curl https://cli-assets.heroku.com/install.sh | sh

heroku login
heroku create crafter-lol-backend

Set Environment Variables

heroku config:set \
  CORS_ORIGINS=https://crafter-lol-frontend.herokuapp.com \
  ddragon.version=16.3.1

Deploy

cd source/Back/crafter
git init
heroku git:remote -a crafter-lol-backend
git add .
git commit -m "Initial deploy"
git push heroku master

Heroku automatically detects the Dockerfile and builds the image.

Environment-Specific Configuration

Backend

Create application-prod.properties:

# Server
server.port=${PORT:5000}

# Data Dragon
ddragon.base.url=https://ddragon.leagueoflegends.com
ddragon.version=${DDRAGON_VERSION:16.3.1}
ddragon.language=${DDRAGON_LANGUAGE:es_MX}

# CORS
cors.allowed.origins=${CORS_ORIGINS}

# Cache - longer TTL in production
spring.cache.caffeine.spec=maximumSize=1000,expireAfterWrite=48h

# Logging
logging.level.com.crafter.league.of.legends=INFO
logging.level.org.springframework.web=WARN

Activate with:

java -jar app.jar --spring.profiles.active=prod

Or in Docker:

ENTRYPOINT ["java", "-Dspring.profiles.active=prod", "-jar", "app.jar"]

Frontend

Create .env.production:

VITE_API_URL=https://api.yourdomain.com/api

Build with:

npm run build

SSL/TLS Configuration

Let’s Encrypt with Certbot

# Install Certbot
sudo apt-get install certbot

# Obtain certificate
sudo certbot certonly --standalone -d yourdomain.com -d www.yourdomain.com

# Certificates stored at:
# /etc/letsencrypt/live/yourdomain.com/fullchain.pem
# /etc/letsencrypt/live/yourdomain.com/privkey.pem

Nginx SSL Configuration

server {
    listen 443 ssl http2;
    server_name yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    # Backend proxy
    location /api/ {
        proxy_pass http://backend:5000/api/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # Frontend
    location / {
        proxy_pass http://frontend:80/;
        proxy_set_header Host $host;
    }
}

# Redirect HTTP to HTTPS
server {
    listen 80;
    server_name yourdomain.com;
    return 301 https://$server_name$request_uri;
}

Monitoring and Logging

Application Logs

Docker Compose:

docker-compose logs -f --tail=100 backend

Kubernetes:

kubectl logs -f deployment/crafter-backend --tail=100

Metrics with Spring Boot Actuator

Add to pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Enable endpoints in application-prod.properties:

management.endpoints.web.exposure.include=health,metrics,info
management.endpoint.health.show-details=always

Access:

Health: GET /actuator/health
Metrics: GET /actuator/metrics
Cache stats: GET /actuator/metrics/cache.gets

Performance Optimization

Enable HTTP/2

Improves load times for assets:

listen 443 ssl http2;

CDN for Static Assets

Use CloudFront, Cloudflare, or similar for frontend assets.

Database Connection Pooling

If you add a database:

spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5

JVM Tuning

Optimize garbage collection:

ENTRYPOINT ["java", \
  "-XX:+UseG1GC", \
  "-XX:MaxGCPauseMillis=200", \
  "-XX:+UseContainerSupport", \
  "-XX:MaxRAMPercentage=75.0", \
  "-jar", "app.jar"]

Rollback Strategy

Docker Tags

Always tag images with version:

docker build -t crafter-lol-backend:v1.2.3 .
docker tag crafter-lol-backend:v1.2.3 crafter-lol-backend:latest

Rollback:

docker-compose down
docker-compose up -d crafter-lol-backend:v1.2.2

Kubernetes

# View rollout history
kubectl rollout history deployment/crafter-backend

# Rollback to previous version
kubectl rollout undo deployment/crafter-backend

# Rollback to specific revision
kubectl rollout undo deployment/crafter-backend --to-revision=2

Security Best Practices

Use HTTPS Everywhere

Enforce HTTPS for all traffic. Use HSTS header:

add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

Restrict CORS

Never use * in production:

cors.allowed.origins=https://yourdomain.com,https://www.yourdomain.com

Rate Limiting

Implement rate limiting on API endpoints to prevent abuse.

Security Headers

Add security headers in Nginx:

add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;

Keep Dependencies Updated

Regularly update dependencies:

mvn versions:display-dependency-updates
npm outdated

Backup and Disaster Recovery

Crafter LoL is stateless - no database backups needed. However, ensure you have:

Source code in version control (Git)
Docker images in registry (ECR, Docker Hub)
Configuration backed up (.env files, Kubernetes configs)
SSL certificates backed up

Troubleshooting Production Issues

502 Bad Gateway

Causes:

Backend container not running
Backend health check failing
Wrong port configuration

Debug:

docker ps  # Check if backend is running
docker logs crafter-backend  # Check for errors
curl http://localhost:5000/api/game/question  # Test directly

CORS Errors in Production

Cause: CORS_ORIGINS doesn’t match frontend domainFix:

# Check current value
docker exec crafter-backend env | grep CORS

# Update and restart
docker-compose down
export CORS_ORIGINS=https://yourdomain.com
docker-compose up -d

Out of Memory Errors

Symptoms: Container keeps restarting, logs show OutOfMemoryErrorSolutions:

Increase container memory limit
Reduce MaxRAMPercentage

Analyze heap dump:

docker exec crafter-backend jmap -dump:live,format=b,file=/tmp/heap.bin 1

Setup

Architecture

Deployment

​Deployment Options

Docker Compose

Kubernetes

Cloud Platforms

Platform as a Service

​Pre-Deployment Checklist

​Docker Compose Deployment

​Production docker-compose.yml

​Deploy

​Kubernetes Deployment

​Backend Deployment

​Frontend Deployment

​ConfigMap

​Deploy to Kubernetes

​AWS Deployment

​Using AWS Elastic Beanstalk

​Using AWS ECS (Fargate)

​Heroku Deployment

​Backend on Heroku

​Environment-Specific Configuration

​Backend

​Frontend

​SSL/TLS Configuration

​Let’s Encrypt with Certbot

​Nginx SSL Configuration

​Monitoring and Logging

​Application Logs

​Metrics with Spring Boot Actuator

​Performance Optimization

​Rollback Strategy

​Docker Tags

​Kubernetes

​Security Best Practices

​Backup and Disaster Recovery

​Troubleshooting Production Issues

​Next Steps

Docker Deployment

Environment Configuration

Build docs developers (and LLMs) love

Deployment Options

Pre-Deployment Checklist

Docker Compose Deployment

Production docker-compose.yml

Deploy

Kubernetes Deployment

Backend Deployment

Frontend Deployment

ConfigMap

Deploy to Kubernetes

AWS Deployment

Using AWS Elastic Beanstalk

Using AWS ECS (Fargate)

Heroku Deployment

Backend on Heroku

Environment-Specific Configuration

Backend

Frontend

SSL/TLS Configuration

Let’s Encrypt with Certbot

Nginx SSL Configuration

Monitoring and Logging

Application Logs

Metrics with Spring Boot Actuator

Performance Optimization

Rollback Strategy

Docker Tags

Kubernetes

Security Best Practices

Backup and Disaster Recovery

Troubleshooting Production Issues

Next Steps