Svarbu

Vertimas yra bendruomenės pastangos, prie kurių jūs galite prisijungti. Šis puslapis šiuo metu išverstas 100.00%.

8. Konteinerizuotas išdėstymas

Yra daug būdų, kaip galima naudoti konteinerizuotą aplikaciją, nuo pačių paprasčiausių (paprastas Docker vaizdas) iki sudėtingų (Kubernetes ir pan.).

Pastaba

Tokio tipo išdėstymui reikia, kad būtų įdiegta ir paleista docker aplikacija. Peržiūrėkite šį vadovą.

Patarimas

Docker run yra iš anksto supakuota aplikacija (dar žinoma kaip vaizdas). Ją galima sukurti atsisiuntus kaip šaltinį (Dockerfile ir resursus), arba gauti jau sukurtą iš registrų (privačių ar viešų).

Pastaba

QGIS Debian-Ubuntu paketui reikia tinkamo gpg autentifikacijos rakto. Prašome skaityti diegimo puslapius, kad keistumėte šį Dockerfile.

8.1. Paprasti docker vaizdai 

Kadangi viešame registre docker vaizdo nėra, jums reikės jį susikurti. Kad tai padarytumėte, sukurkite aplanką qgis-server ir jame:

sukurkite failą Dockerfile su tokiu turiniu:

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"]

sukurkite failą cmd.sh su tokiu turiniu:

#!/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

sukurkite vaizdą su:

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

8.1.1. Pirmas paleidimas 

Kad paleistumėte serverį, jums reikės QGIS projekto failo. Jūs galite naudoti vieną iš jūsų, arba pasirinkti šį pavyzdį.

Kad tai padarytumėte, sukurkite aplanką data viduje anksčiau sukurto aplanko qgis-server ir nukopijuokite į jį savo failą. Kad tiktų žemiau einantys paaiškinimai, pervadinkite jį į osm.qgs.

Pastaba

Jums gali reikėti pridėti reklamuojamą URL kortelėje QGIS Serveris, kurią rasite Projektas ► Savybės, jei GetCapabilities bus neteisingas. Pavyzdžiui, jei jūsų serveris išorėje matomas per prievadą 8080, jūs įrašysite kaip reklamuojamą URL http://localhost:8080/qgis-server/. Daugiau informacijos rasite skiltyje Jūsų projekto konfigūravimas ir tolimesnėse.

Dabar jūs galite paleisti serverį įvykdydami:

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

Naudotos parinktys:

-d: vykdyti fone
–rm: pašalinti konteinerį, kai jis sustabdomas
–name: kuriamo konteinerio pavadinimas
–net: (anksčiau sukurtas) potinklis
–hostname: konteinerio mašinos pavadinimas, vėlesniam naudojimui
-v: vietinis duomenų aplankas, kurį reikia prijungti prie konteinerio
-p: mašinos/konteinerio prievadų sugretinimas
-e: aplinkos kintamasis, kurį reikia naudoti konteineryje

Kad patikrintumėte, rašykite docker ps | grep qgis-server ir tada turėtumėte matyti eilutę su 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. Panaudojamas pavyzdys 

Kadangi serveris priima tik fastcgi jungtis, jums reikia HTTP serverio, kuris apdoroja protokolą. Kad tai padarytumėte, jums reikia sukurti paprastą Nginx konfigūracijos failą ir paleisti Nginx vaizdą.

Dabartiniame aplanke sukurkite nginx.conf su tokiu turiniu:

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;
  }
}

Ir įrašykite tokią komandą:

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

Kad patikrintumėte galimybių pasiekiamumą, įrašykite naršyklėje http://localhost:8080/qgis-server/?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetCapabilities

8.1.3. Susitvarkymas 

Kad išvalytumėte vykdomus vaizdus, įrašykite:

docker stop qgis-server nginx

8.2. Doker rinkiniai 

Ankstesnį būdą galima aprašyti scenarijumi, bet jo negalima lengvai supakuoti ar standartizuoti bei lengvai valdyti.

Norint dirbti su docker vaizdų rinkiniu, jūs galėtumėte naudoti docker rinkinį, kurį valdo orkestratorius. Rinkinyje vaizdai veikia tame pačiame privačiame potinklyje ir jūs galite paleisti / sustabdyti visą rinkinį ar išplatinti rinkinį į kitus darbininkus. Yra daug orkestratorių, pavyzdžiui Swarm, Kubernetes ir Mesos.

Žemiau pateiktos paprastos konfigūracijos, skirtos testavimui. Jos netinka gamybai.

8.2.1. Swarm/docker-compose 

Docker dabar turi savo orkestratorių: Swarm (suderinamą su docker-compose failais). Jūs turite jį įjungti (Mac versija veiks ir su Linux).

Rinkinio aprašymas 

Dabar, kai turite veikiantį Swarm, sukurkite paslaugos failą (žr. Išplatinti į 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

Kad pateiktumėte (ar atnaujintumėte) rinkinį, rašykite:

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

Tikrinkite rinkinio pateikimo būseną, kol gausite 1/1 stulpelyje replicas:

docker stack services qgis-stack

Kažkas panašaus į:

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

Kad patikrintumėte WMS galimybes, įrašykite naršyklėje http://localhost:8080/qgis-server/?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetCapabilities

Susitvarkymas 

Kad apsitvarkytumėte, rašykite:

docker stack rm qgis-stack

8.2.2. Kubernetes 

Įdiegimas 

Jei turite įsidiegę Docker Desktop, Kubernetes (dar vadinamo k8s) naudojimas yra gan paprastas: įjunkite k8s.

Priešingu atveju sekite minikube vadovą arba microk8s skirtą Ubuntu.

Kadangi Kubernetes diegimas gali būti tikrai sudėtingas, mes koncentruosimės tik ties šios demonstracijos aspektais. Tolimesnę / detalesnę informaciją rasite oficialioje dokumentacijoje.

microk8s

microk8s reikia kelių papildomų žingsnių: jūs turite įjungti registrą ir pridėti žymą qgis-server vaizdui, kad Kubernetes rastų sukurtus vaizdus.

Visų pirmą, įjunkite registrą:

microk8s enable dashboard dns registry

Tada pridėkite žymą ir sustumkite vaizdą į jūsų naujai sukurtą registrą:

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

Galų gale, pridėkite ir pabaikite /etc/docker/daemon.json, kad jūsų registras 127.0.0.1:32000 būtų sąraše lauke insecure-registries:

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

Manifestų kūrimas 

Kubernetes yaml manifestuose aprašo platinamus objektus. Yra daug skirtingų tipų, bet mes naudosime tik platinimus (valdyti podus, t.y. docker vaizdus) ir paslaugas, kad išplatinimai būtų matomi vidiniais ar išoriniais tikslais.

Platinimo manifestai

Sukurkite failą deployments.yaml su tokiu turiniu:

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;
        }
      }

Paslaugos manifestas

Sukurkite failą services.yaml su tokiu turiniu:

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

Manifestų platinimas 

Norint platinti vaizdus ir paslaugus Kubernetes, galima naudoti švieslentę (spauskite + viršutiniame dešiniame kampe) arba komandinę eilutę.

Pastaba

Kai komandinė eilutė naudojama su microk8s, jūs turėsite prieš kiekvieną komandą rašyti priešdėlį microk8s.

Norėdami platinti ar atnaujinti jūsų manifestus:

kubectl apply -f ./

Kad patikrintumėte, kas šiuo metu išplatinta:

kubectl get pods,services,deployment

Turėtumėte gauti kažką panašaus į tai:

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

Norėdami skaityti nginx/qgis žurnalą, rašykite:

kubectl logs -f POD_NAME

Norėdami patikrinti WMS galimybes, naršyklėje rašykite http://localhost:30080/qgis-server/?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetCapabilities

Susitvarkymas 

Norėdami apsitvarkyti rašykite:

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

8.3. Platinimas debesyje 

Nuosavo serverių spiečiaus tvarkymas valdant konteinerizuotų aplikacijų platinimą yra sudėtingas darbas. Jūs turite valdyti kelis dalykus, tokius kaip aparatinė įranga, pralaidumas ir saugumas skirtinguose lygmenyse.

Debesų platinimo sprendimai gali būtų gera alternatyva, kai jūs nenorite gilintis į infrastruktūros valdymą.

Platinimas debesyje gali naudoti nuosavybinius mechanizmus, bet jie taipogi suderinami su etapais, paaiškintais anksčiau (docker vaizdai ir rinkinių valdymas).

8.3.1. AWS atvejis 

Su Amazon AWS, per ECS (Elastic Container Service) funkcionalumus, jūs galite naudoti docker-compose ar Kubernetes suderinamus įrankius jūsų rinkinio valdymui. Jūs turėsite sukurti vaizdų registrą, kad jūsų savi vaizdai būtų prieinami.

Norėdami naudoti į docker-compose panašų funkcionalumą, turite įdiegti ecs-cli klientą ir turėti reikiamas teises / vaidmenis. Tada, naudodami ecs-cli compose komandas jūs galite perpanaudoti rinkinio aprašymą.

Norėdami naudoti Kubernetes, jūs galite naudoti AWS žiniatinklio konsolę ar komandinės eilutės įrankį eksctl ir turėti reikiamas teises / vaidmenis. Tada su gerai sukonfigūruota kubectl aplinka jūs galite perpanaudoti Kubernetes manifestus.