Working with Containers and Orchestration

docker run --name my-nginx -d -p 8080:80 nginx:latest

docker run --name custom-nginx -d -p 8080:80 -v /host/nginx.conf:/etc/nginx/nginx.conf nginx:latest

FROM nginx:latest
COPY ./html /usr/share/nginx/html
COPY ./nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# Build stage
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Final stage
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY ./nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

docker run -d \
  --name nginx-container \
  -v /host/nginx.conf:/etc/nginx/nginx.conf \
  -v /host/html:/usr/share/nginx/html \
  nginx:latest

docker run -e NGINX_PORT=8080 -e NGINX_SSL_PORT=8443 nginx:latest

server {
    listen ${NGINX_PORT};
    root /usr/share/nginx/html;

    location / {
        try_files $uri $uri/ =404;
    }
}

upstream backend {
    server 127.0.0.1:8080;
    server 127.0.0.1:8081;

    health_check;
}

server {
    listen 80;

    location / {
        proxy_pass http://backend;
    }
}

upstream api {
    server 127.0.0.1:3000;
    server 127.0.0.1:3001;

    health_check interval=10s timeout=5s port=3000 path=/health expect=200;
}

server {
    listen 80;

    location /api {
        proxy_pass http://api;
    }
}

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: example-service
            port:
              number: 80

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-tls-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  tls:
  - hosts:
    - example.com
    secretName: example-tls-secret
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: example-service
            port:
              number: 443

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-config
data:
  nginx.conf: |
    events {
      worker_connections 1024;
    }
    http {
      server {
        listen 80;
        location / {
          return 200 'Hello from Nginx!';
        }
      }
    }

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        volumeMounts:
        - name: config-volume
          mountPath: /etc/nginx/conf.d
      volumes:
      - name: config-volume
        configMap:
          name: nginx-config

# Define upstream with multiple servers
upstream backend {
    server 10.0.1.10:8080 weight=1;
    server 10.0.1.11:8080 weight=1;
    server 10.0.1.12:8080 weight=1;
}

# Main server block
server {
    listen 80;
    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

http {
    limit_req_zone $binary_remote_addr zone=api:10m rate=1r/s;

    server {
        listen 80;
        location /api/ {
            limit_req zone=api burst=5 nodelay;
            proxy_pass http://backend;
        }
    }
}

http {
    limit_conn_zone $binary_remote_addr zone=conn:10m;

    server {
        listen 80;
        location / {
            limit_conn conn 10;
            proxy_pass http://backend;
        }
    }
}

version: '3.8'
services:
  nginx:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./html:/usr/share/nginx/html
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

version: '3.8'
services:
  nginx:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - api
      - frontend

  api:
    image: node:alpine
    command: npm start
    working_dir: /app
    volumes:
      - ./api:/app
    ports:
      - "3000:3000"

  frontend:
    image: node:alpine
    command: npm run build
    working_dir: /app
    volumes:
      - ./frontend:/app
    ports:
      - "4200:4200"

apiVersion: v1
kind: Pod
metadata:
  name: app-with-sidecar
spec:
  containers:
  - name: main-app
    image: myapp:latest
    ports:
    - containerPort: 8080
  - name: sidecar-logger
    image: fluentd:latest
    volumeMounts:
    - name: logs
      mountPath: /var/log/app
  volumes:
  - name: logs
    emptyDir: {}