API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) · Lektion

Nginx i containerbaserade miljöer

Distribuera och hantera Nginx effektivt i Docker-containrar och Kubernetes-kluster.

Lektion 3 av 411 steg

Nginx i containerbaserade miljöer är en gratis lektion i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för API-gateway och reverse proxy (Nginx + Spring Cloud Gateway), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) innehåller totalt 4 lektioner.

Varför köra Nginx i containrar?

Att köra Nginx i containrar, till exempel Docker, ger många fördelar. Det skapar en konsekvent miljö och säkerställer att Nginx fungerar på samma sätt överallt, från din bärbara dator till produktion.

Viktiga fördelar är bland annat:

Portabilitet: Flytta enkelt Nginx-applikationer mellan olika system.
Isolering: Nginx körs i sin egen isolerade miljö, vilket förhindrar konflikter.
Skalbarhet: Starta snabbt nya Nginx-instanser när trafiken ökar.
Resurseffektivitet: Containrar delar värdoperativsystemets kärna och använder färre resurser än traditionella virtuella maskiner.

Din första Nginx-Dockerfile

En Dockerfile är ett skript som innehåller instruktioner för att bygga en Docker-avbildning. När Nginx körs i en container börjar man vanligtvis med en officiell Nginx-avbildning och lägger sedan till egna konfigurationer eller statiska filer.

Här är en enkel Dockerfile för att skapa en Nginx-avbildning:

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

Köra Nginx i Docker

När du har en Dockerfile (och eventuellt dina nginx.conf- och html-filer) kan du bygga en avbildning och köra den.

Bygg först avbildningen (ge den namnet my-nginx):

docker build -t my-nginx .

Kör sedan en container från din avbildning och mappa port 8080 på värddatorn till port 80 i containern:

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

Anpassad Nginx-konfiguration i Docker

Du behöver ofta använda en anpassad nginx.conf. I stället för att bygga in den i avbildningen med COPY (som i Dockerfile-exemplet) kan du montera den som en volym. Då kan du ändra konfigurationen utan att bygga om avbildningen.

Så här monterar du en lokal fil med namnet ./custom-nginx.conf i containern:

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

Nginx med Docker Compose

För applikationer med flera tjänster (t.ex. Nginx som reverse proxy för ett backend-API) är Docker Compose ovärderligt. Det låter dig definiera och köra Docker-applikationer med flera containrar med hjälp av en enda YAML-fil.

Det här exemplet konfigurerar Nginx så att förfrågningar proxas till en enkel webbtjänst:

version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
  app:
    image: httpd:alpine
    expose:
      - "8080"

Grunderna i Nginx och Kubernetes

Kubernetes (K8s) är en plattform med öppen källkod för containerorkestrering. När Nginx distribueras i en produktionsmiljö erbjuder Kubernetes avancerade funktioner som:

Automatiserad distribution: Deklarativ konfiguration för önskat tillstånd.
Skalning: Skala enkelt Nginx-instanser upp eller ned.
Självläkning: Starta automatiskt om eller ersätt Nginx-containrar som har slutat fungera.
Lastbalansering: Fördela trafiken mellan flera Nginx-instanser.

Viktiga K8s-koncept för Nginx är Pods, Deployments och Services.

Distribuera Nginx i Kubernetes

I Kubernetes definierar du dina applikationer med YAML-filer. Ett Deployment-objekt hanterar en uppsättning identiska Pods och säkerställer att ett angivet antal Nginx-instanser alltid körs.

Här är ett enkelt Kubernetes-Deployment för Nginx:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

Exponera Nginx med K8s Services

En Kubernetes-Service är ett abstrakt sätt att exponera en applikation som körs i en uppsättning Pods. Den tillhandahåller en stabil IP-adress och ett DNS-namn för din Nginx-distribution, även om Pods ersätts.

Vanliga Service-typer för Nginx är NodePort (exponerar Nginx på en port på alla klusternoder) och LoadBalancer (integreras med molnleverantörens lastbalanserare).

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

Nginx-konfiguration med ConfigMaps

För att hantera Nginx-konfiguration i Kubernetes är ConfigMaps det rekommenderade sättet. En ConfigMap lagrar icke-konfidentiella data som nyckel-värde-par, som sedan kan monteras som filer i dina Nginx-Pods.

Det gör att du kan uppdatera Nginx-konfigurationen utan att bygga om din Docker-avbildning eller ändra Deployment-YAML-filen direkt.

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 in K8s!';
        }
      }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-configmap-deployment
spec:
  selector:
    matchLabels:
      app: nginx-configmap
  template:
    metadata:
      labels:
        app: nginx-configmap
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        volumeMounts:
        - name: nginx-config-volume
          mountPath: /etc/nginx/nginx.conf
          subPath: nginx.conf
      volumes:
      - name: nginx-config-volume
        configMap:
          name: nginx-config

Testa dina containerkunskaper

Vilka av följande är giltiga sätt att hantera anpassade Nginx-konfigurationsfiler när Nginx körs i en Docker-container eller ett Kubernetes-kluster?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Nginx i containrar

Vi har gått igenom hur Nginx effektivt kan distribueras och hanteras i containerbaserade miljöer, med fokus på Docker och Kubernetes.

Docker: Ger isolering och portabilitet, vilket gör att Nginx kan köras konsekvent.
Dockerfile: Används för att bygga anpassade Nginx-avbildningar, inklusive anpassade konfigurationer.
Docker Compose: Orkestrerar Nginx-konfigurationer med flera containrar för utveckling.
Kubernetes: Erbjuder robust orkestrering för produktion, med funktioner som skalning och självläkning.
Deployments och Services: Centrala K8s-objekt för att hantera och exponera Nginx-Pods.
ConfigMaps: K8s standardmetod för att hantera Nginx-konfiguration dynamiskt.

Att behärska dessa koncept är avgörande för moderna och skalbara Nginx-distributioner!

Gratis att börja

Lär dig API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Nginx i containerbaserade miljöer” gratis?

Ja – hela texten till ”Nginx i containerbaserade miljöer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway), kan Ni uppgradera till CoddyKit PRO. Kursen i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) innehåller totalt 4 lektioner.

Vad lär jag mig i ”Nginx i containerbaserade miljöer”?

Distribuera och hantera Nginx effektivt i Docker-containrar och Kubernetes-kluster. Ni övar på API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig API-gateway och reverse proxy (Nginx + Spring Cloud Gateway)?

Du behöver inga förkunskaper. Utbildningen i API-gateway och reverse proxy (Nginx + Spring Cloud Gateway) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Nginx i containerbaserade miljöer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här API-gateway och reverse proxy (Nginx + Spring Cloud Gateway)-lektionen?

Ja. Varje API-gateway och reverse proxy (Nginx + Spring Cloud Gateway)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Loggning och mätvärden i Nginx
Prestandajustering av Nginx
Nginx i containerbaserade miljöer
Omladdning utan driftstopp och testning av konfiguration

← Tillbaka till API-gateway och reverse proxy (Nginx + Spring Cloud Gateway)