Viktigt

Översättning är en gemenskapsinsats du kan gå med i. Den här sidan är för närvarande översatt till 100.00%.

8. Containerbaserad driftsättning

Det finns många sätt att använda containeriserade applikationer, från de mest enkla (enkla Docker-bilder) till sofistikerade (Kubernetes och så vidare).

Observera

Den här typen av distribution kräver att docker-applikationen är installerad och igång. Kolla in denna handledning.

Råd

Docker kör färdigpaketerade applikationer (även kallade avbildningar) som kan hämtas som källor (Dockerfile och resurser) för att bygga eller redan byggas från register (privata eller offentliga).

Observera

QGIS Debian-Ubuntu-paketnedladdningar behöver en giltig gpg-autentiseringsnyckel. Se installationssidorna <https://www.qgis.org/resources/installation-guide/#debian–ubuntu>`_ för att uppdatera följande Dockerfile.

8.1. Enkla dockeravbildningar 

Eftersom dockeravbildningen inte finns i ett offentligt register måste du bygga den. För att göra det skapar du en katalog qgis-server och i dess katalog:

skapa en fil Dockerfile med detta innehåll:

FROM debian:bookworm-slim

ENV LANG=en_EN.UTF-8


RUN apt-get update \
    && apt-get install --no-install-recommends --no-install-suggests --allow-unauthenticated -y \
        gnupg \
        ca-certificates \
        wget \
        locales \
    && localedef -i en_US -f UTF-8 en_US.UTF-8 \
    # Add the current key for package downloading
    # Please refer to QGIS install documentation (https://www.qgis.org/fr/site/forusers/alldownloads.html#debian-ubuntu)
    && mkdir -m755 -p /etc/apt/keyrings \
    && wget -O /etc/apt/keyrings/qgis-archive-keyring.gpg https://download.qgis.org/downloads/qgis-archive-keyring.gpg \
    # Add repository for latest version of qgis-server
    # Please refer to QGIS repositories documentation if you want other version (https://qgis.org/resources/installation-guide/#repositories)
    && echo "deb [signed-by=/etc/apt/keyrings/qgis-archive-keyring.gpg] https://qgis.org/debian bookworm main" | tee /etc/apt/sources.list.d/qgis.list \
    && apt-get update \
    && apt-get install --no-install-recommends --no-install-suggests --allow-unauthenticated -y \
        qgis-server \
        spawn-fcgi \
        xauth \
        xvfb \
    && apt-get remove --purge -y \
        gnupg \
        wget \
    && rm -rf /var/lib/apt/lists/*

RUN useradd -m qgis

ENV TINI_VERSION v0.19.0
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini /tini
RUN chmod +x /tini

ENV QGIS_PREFIX_PATH /usr
ENV QGIS_SERVER_LOG_STDERR 1
ENV QGIS_SERVER_LOG_LEVEL 2

COPY cmd.sh /home/qgis/cmd.sh
RUN chmod -R 777 /home/qgis/cmd.sh
RUN chown qgis:qgis /home/qgis/cmd.sh

USER qgis
WORKDIR /home/qgis

ENTRYPOINT ["/tini", "--"]

CMD ["/home/qgis/cmd.sh"]

skapa en fil cmd.sh med detta innehåll:

#!/bin/bash

[[ $DEBUG == "1" ]] && env

exec /usr/bin/xvfb-run --auto-servernum --server-num=1 /usr/bin/spawn-fcgi -p 5555 -n -d /home/qgis -- /usr/lib/cgi-bin/qgis_mapserv.fcgi

bygga upp bilden med:

docker build -f Dockerfile -t qgis-server ./

8.1.1. Första körningen 

För att köra servern behöver du en QGIS-projektfil. Du kan använda en av dina egna eller välja det här exemplet.

För att göra det, skapa en katalog data inom katalogen qgis-server och kopiera din fil till den. För att följa följande förklaringar, byt namn på den till osm.qgs.

Observera

Du kan behöva lägga till annonserade URL:er under fliken QGIS Server i Projekt ► Egenskaper om GetCapabilites är trasiga. Till exempel om din server är exponerad på port 8080, kommer du att lägga till detta för annonserad URL http://localhost:8080/qgis-server/. Mer information finns i avsnitt Konfigurera ditt projekt och efterföljande.

Nu kan du köra servern med:

docker network create qgis
docker run -d --rm --name qgis-server --net=qgis --hostname=qgis-server \
              -v $(pwd)/data:/data:ro -p 5555:5555 \
              -e "QGIS_PROJECT_FILE=/data/osm.qgs" \
              qgis-server

Använda alternativ:

-d: körs i bakgrunden
–rm: ta bort behållaren när den är stoppad
–namn: namn på den container som ska skapas
–nät: (tidigare skapat) undernätverk
–hostname: behållarens värdnamn, för senare referenser
-v: lokal datakatalog som ska monteras i behållaren
-p: mappning av port för värd/behållare
-e: miljövariabel som ska användas i containern

För att kontrollera, skriv docker ps | grep qgis-server och du bör se en rad med qgis-server:

CONTAINER ID   IMAGE         COMMAND                  CREATED         STATUS         PORTS                    NAMES
4de8192da76e   qgis-server   "/tini -- /home/qgis…"   3 seconds ago   Up 2 seconds   0.0.0.0:5555->5555/tcp   qgis-server

8.1.2. Användbart prov 

Eftersom servern bara accepterar fastcgi-anslutningar behöver du en HTTP-server som hanterar det här protokollet. För att göra det måste vi skapa en enkel Nginx-konfigurationsfil och starta en Nginx-image.

Skapa en fil nginx.conf i den aktuella katalogen med detta innehåll:

server {
  listen 80;
  server_name _;
  location / {
    root  /usr/share/nginx/html;
    index index.html index.htm;
  }
  location /qgis-server {
    proxy_buffers 16 16k;
    proxy_buffer_size 16k;
    gzip off;
    include fastcgi_params;
    fastcgi_pass qgis-server:5555;
  }
}

Och skriv det här kommandot:

docker run -d --rm --name nginx --net=qgis --hostname=nginx \
              -v $(pwd)/nginx.conf:/etc/nginx/conf.d/default.conf:ro -p 8080:80 \
              nginx:1.13

För att kontrollera tillgängligheten, skriv in i en webbläsare http://localhost:8080/qgis-server/?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetCapabilities

8.1.3. Rensa upp 

Om du vill rensa de avbildningar som körs skriver du :

docker stop qgis-server nginx

8.2. Docker-stackar 

Den tidigare metoden är skriptbar, men inte lätt att paketera, standardisera eller hantera.

För att arbeta med en docker-imageuppsättning kan du använda en docker-stack som hanteras av en orkestrator. I en stack arbetar avbildningarna i samma privata nätverk, och du kan starta/stoppa hela stacken eller distribuera stacken till andra arbetare. Det finns många orkestratorer, till exempel Swarm, Kubernetes och Mesos.

I det följande kommer vi att presentera enkla konfigurationer för teständamål. De är inte lämpliga för produktion.

8.2.1. Swarm/docker-compose 

Docker har nu sin egen orkestrator: Swarm (kompatibel med docker-compose-filer). Du måste aktivera den <https://docs.docker.com/guides/orchestration/#enable-docker-swarm>`_ (Mac-versionen fungerar även med Linux).

Beskrivning av stapeln 

Nu när du har fått Swarm att fungera skapar du servicefilen (se Deploy to Swarm) qgis-stack.yaml:

version: '3.7'

services:
  qgis-server:
    # Should use version with utf-8 locale support:
    image: qgis-server:latest
    volumes:
      - REPLACE_WITH_FULL_PATH/data:/data:ro
    environment:
      - LANG=en_EN.UTF-8
      - QGIS_PROJECT_FILE=/data/osm.qgs
      - QGIS_SERVER_LOG_LEVEL=0  # INFO (log all requests)
      - DEBUG=1                  # display env before spawning QGIS Server

  nginx:
    image: nginx:1.13
    ports:
      - 8080:80
    volumes:
      - REPLACE_WITH_FULL_PATH/nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - qgis-server

För att distribuera (eller uppdatera) stacken, skriv:

docker stack deploy -c qgis-stack.yaml qgis-stack

Kontrollera stackens driftsättningsstatus tills du får 1/1 i kolumnen replicas:

docker stack services qgis-stack

Nåt i den stilen:

ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
gmx7ewlvwsqt        qgis_nginx          replicated          1/1                 nginx:1.13          *:8080->80/tcp
l0v2e7cl43u3        qgis_qgis-server    replicated          1/1                 qgis-server:latest

För att kontrollera WMS-funktioner, skriv in i en webbläsare http://localhost:8080/qgis-server/?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetCapabilities

Rensa upp 

För att städa upp, skriv:

docker stack rm qgis-stack

8.2.2. Kubernetes 

Installation 

Om du har en Docker Desktop-installation är det ganska enkelt att använda Kubernetes (även kallat k8s): enable k8s.

Om inte, följ minikube tutorial eller microk8s för Ubuntu.

Eftersom installationen av Kubernetes kan vara mycket komplex kommer vi endast att fokusera på de aspekter som används i detta demo. För ytterligare / djupare information, se den officiella dokumentationen <https://kubernetes.io/docs/home/>`_.

microk8s

microk8s kräver extra steg: du måste aktivera registret och tagga qgis-serveravbildningen för att Kubernetes ska hitta de skapade avbildningarna.

Först måste du aktivera registret:

microk8s enable dashboard dns registry

Tagga sedan bilden och skicka den till ditt nyskapade register:

docker tag qgis-server 127.0.0.1:32000/qgis-server && docker push 127.0.0.1:32000/qgis-server

Slutligen, lägg till eller komplettera /etc/docker/daemon.json för att få ditt register 127.0.0.1:32000 listat i fältet insecure-registries:

{
  "insecure-registries": ["127.0.0.1:32000"]
}

Skapa manifest 

Kubernetes beskriver de objekt som ska distribueras i yaml-manifest. Det finns många olika typer, men vi kommer bara att använda deployments (hantera pods, dvs. docker-avbildningar) och services för att exponera deployments för interna eller externa ändamål.

Manifest för driftsättning

Skapa en fil deployments.yaml med detta innehåll:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: qgis-server
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      myLabel: qgis-server
  template:
    metadata:
      labels:
        myLabel: qgis-server
    spec:
      containers:
        - name: qgis-server
          image: localhost:32000/qgis-server:latest
          imagePullPolicy: Always
          env:
            - name: LANG
              value: en_EN.UTF-8
            - name: QGIS_PROJECT_FILE
              value: /data/osm.qgs
            - name: QGIS_SERVER_LOG_LEVEL
              value: "0"
            - name: DEBUG
              value: "1"
          ports:
            - containerPort: 5555
          volumeMounts:
            - name: qgis-data
              mountPath: /data/
      volumes:
        - name: qgis-data
          hostPath:
            path: REPLACE_WITH_FULL_PATH/data

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: qgis-nginx
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      myLabel: qgis-nginx
  template:
    metadata:
      labels:
        myLabel: qgis-nginx
    spec:
      containers:
        - name: qgis-nginx
          image: nginx:1.13
          ports:
            - containerPort: 80
          volumeMounts:
            - name: nginx-conf
              mountPath: /etc/nginx/conf.d/
      volumes:
        - name: nginx-conf
          configMap:
            name: nginx-configuration

---
kind: ConfigMap
apiVersion: v1
metadata:
  name: nginx-configuration
data:
  nginx.conf: |
    server {
      listen 80;
      server_name _;
      location / {
        root  /usr/share/nginx/html;
        index index.html index.htm;
      }
      location /qgis-server {
        proxy_buffers 16 16k;
        proxy_buffer_size 16k;
        gzip off;
        include fastcgi_params;
        fastcgi_pass qgis-server:5555;
        }
      }

Servicemanifest

Skapa en fil services.yaml med detta innehåll:

apiVersion: v1
kind: Service
metadata:
  name: qgis-server
  namespace: default
spec:
  type: ClusterIP
  selector:
    myLabel: qgis-server
  ports:
    - port: 5555
      targetPort: 5555
---
apiVersion: v1
kind: Service
metadata:
  name: qgis-nginx
  namespace: default
spec:
  type: NodePort
  selector:
    myLabel: qgis-nginx
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080

Distribuera manifest 

För att distribuera bilderna och tjänsterna i Kubernetes kan man använda instrumentpanelen (klicka på + längst upp till höger) eller kommandoraden.

Observera

När du använder kommandoraden med microk8s måste du prefixera varje kommando med microk8s.

För att distribuera eller uppdatera dina manifest:

kubectl apply -f ./

För att kontrollera vad som för närvarande är utplacerat:

kubectl get pods,services,deployment

Du bör få något i stil med:

NAME                               READY   STATUS    RESTARTS   AGE
pod/qgis-nginx-54845ff6f6-8skp9    1/1     Running   0          27m
pod/qgis-server-75df8ddd89-c7t7s   1/1     Running   0          27m

NAME                       TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
service/Kubernetes         ClusterIP   10.152.183.1     <none>        443/TCP        5h51m
service/qgis-exec-server   ClusterIP   10.152.183.218   <none>        5555/TCP       35m
service/qgis-nginx         NodePort    10.152.183.234   <none>        80:30080/TCP   27m
service/qgis-server        ClusterIP   10.152.183.132   <none>        5555/TCP       27m

NAME                          READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/qgis-nginx    1/1     1            1           27m
deployment.apps/qgis-server   1/1     1            1           27m

Om du vill läsa nginx/qgis-loggar skriver du :

kubectl logs -f POD_NAME

För att kontrollera WMS-funktioner, skriv in i en webbläsare http://localhost:30080/qgis-server/?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetCapabilities

Rensa upp 

För att städa upp, skriv:

kubectl delete service/qgis-server service/qgis-nginx deployment/qgis-nginx deployment/qgis-server configmap/nginx-configuration

8.3. Driftsättning i molnet 

Att hantera ett eget kluster av servrar för att hantera distributionen av containeriserade applikationer är ett komplext jobb. Du måste hantera flera olika frågor, t.ex. hårdvara, bandbredd och säkerhet på olika nivåer.

Molnlösningar kan vara ett bra alternativ när du inte vill fokusera på infrastrukturhantering.

En molndriftsättning kan använda proprietära mekanismer, men de är också kompatibla med de steg som förklarats tidigare (docker images och stack management).

8.3.1. AWS användningsfall 

Med Amazon AWS, genom ECS (Elastic Container Service)-funktioner, kan du använda docker-compose eller Kubernetes-kompatibla omslag för att hantera din stack. Du måste skapa ett ”avbildningsregister” <https://console.aws.amazon.com/ecr/home>`_ för att dina anpassade avbildningar ska vara tillgängliga.

För att använda docker-compose liknande funktioner måste du installera ecs-cli-klienten och ha korrekta behörigheter / roller. Sedan kan du med hjälp av kommandona ecs-cli compose återanvända stack description.

För att använda Kubernetes kan du använda AWS webbkonsol eller kommandoradsverktyget eksctl och ha rätt behörigheter / roller. Med en välkonfigurerad kubectl-miljö kan du sedan återanvända Kubernetes manifest.