it-swarm.com.de

Wie setze ich dynamische Werte mit der Kubernetes yaml-Datei ein?

Zum Beispiel eine Implementierungs-Yaml-Datei:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: guestbook
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: guestbook
      spec:
        container:
          - name: guestbook
            image: {{Here want to read value from config file outside}}

Es gibt eine ConfigMap-Funktion mit Kubernetes, aber das schreibt auch den Schlüssel/Wert in die yaml-Datei. Gibt es eine Möglichkeit, den Schlüssel für Umgebungsvariablen festzulegen?

8
online

Ich glaube nicht, dass es möglich ist, ein Bild über eine Variable oder eine Konfigurationszuordnung in Kubernetes festzulegen. Sie können jedoch beispielsweise Helm verwenden, um Ihre Implementierungen wesentlich flexibler und konfigurierbarer zu gestalten.

3
Jakub

Sie können dies nicht automatisch tun, Sie müssen ein externes Skript verwenden, um Ihre Vorlage zu "kompilieren", oder den von @Jakub vorgeschlagenen Helm.

Möglicherweise möchten Sie ein benutzerdefiniertes Bash-Skript verwenden, das möglicherweise in Ihre CI-Pipeline integriert ist.

Wenn Sie eine Vorlage-Yml-Datei mit dem Namen deploy.yml.template erhalten, die der von Ihnen bereitgestellten sehr ähnlich ist, können Sie Folgendes verwenden:

#!/bin/bash

# sample value for your variables
MYVARVALUE="nginx:latest"

# read the yml template from a file and substitute the string 
# {{MYVARNAME}} with the value of the MYVARVALUE variable
template=`cat "deploy.yml.template" | sed "s/{{MYVARNAME}}/$MYVARVALUE/g"`

# apply the yml with the substituted value
echo "$template" | kubectl apply -f -
11
whites11

Sie können beim Deployment auch envsubst verwenden.

z.B.

cat $app/deployment.yaml | envsubst | kubectl apply ...

Es werden alle Variablen in der Datei durch ihre Werte ersetzt. Wir verwenden diesen Ansatz erfolgreich für unser CI, wenn wir es in mehreren Umgebungen bereitstellen, auch um den CI_TAG usw. in die Bereitstellungen einzufügen.

5
M U

Eine Linie:

cat app-deployment.yaml | sed "s/{{BITBUCKET_COMMIT}}/$BITBUCKET_COMMIT/g" | kubectl apply -f -

In Yaml:

  ...
  containers:
  - name: ulisses
    image: niceuser/niceimage:{{BITBUCKET_COMMIT}}
  ...
3
CelinHC

Ich habe kubetpl verwendet

Es hat drei verschiedene Template-Varianten und unterstützt ConfigMap/Secret Freezing.

1
Jingshao Chen

Ich erstelle ein Skript mit dem Namen kubectl_create und verwenden Sie es, um den Befehl create auszuführen. Es ersetzt jeden Wert in der Vorlage, auf den in einer Umgebungsvariablen verwiesen wird.

#!/bin/bash
set -e
eval "cat <<EOF
$(<$1)
EOF
" | kubectl create -f -

Wenn die Vorlagendatei beispielsweise Folgendes enthält:

apiVersion: v1
kind: Service

metadata:
  name: nginx-external
  labels:
    app: nginx

spec:
  loadBalancerIP: ${PUBLIC_IP}
  type: LoadBalancer
  ports:
  - name: http
    port: 80
    targetPort: 80
  - name: https
    port: 443
    targetPort: 443

  selector:
    app: nginx

Lauf kubectl_create nginx-service.yaml und dann wird die Umgebungsvariable PUBLIC_IP ersetzt, bevor der eigentliche Befehl kubectl create ausgeführt wird.

1
Jerry Bowman

Helm ist genau für solche Dinge und vieles mehr gedacht. Es behandelt komplexe Ressourcenbereitstellungen als Gruppe usw.

Aber wenn wir immer noch nach einer einfachen Alternative suchen, wie wäre es dann mit Ameise?

Wenn Sie die Datei als Teil des Erstellungs- oder Testprozesses ändern möchten, können Sie auch eine Ant-Task ausführen.

Mit ant können Sie alle Umgebungswerte als Eigenschaft laden oder einfach die Eigenschaftendatei wie folgt laden:

<property environment="env" />
<property file="build.properties" />

Dann können Sie ein Ziel haben, das Vorlagendateien in Ihre gewünschte yaml-Datei konvertiert.

<target name="generate_from_template">

    <!-- Copy task to replaces values and create new file -->
    <copy todir="${dest.dir}" verbose="true" overwrite="true" failonerror="true">

        <!-- List of files to be processed -->
        <fileset file="${source.dir}/xyz.template.yml" />

        <!-- Mapper to transform filename. Removes '.template' from the file
            name when copying the file to output directory -->
        <mapper type="regexp" from="(.*).template(.*)" to="\1\2" />

        <!-- Filter chain that replaces the template values with actual values 
            fetched from properties file -->
        <filterchain>
            <expandproperties />
        </filterchain>
    </copy>
</target>

Natürlich können Sie fileset anstelle von file verwenden, wenn Sie Werte für mehrere Dateien (verschachtelt oder was auch immer) dynamisch ändern möchten.

Ihre Vorlagendatei xyz.template.yml Sollte aussehen, wie:

apiVersion: v1
kind: Service
metadata:
  name: ${XYZ_RES_NAME}-ser
  labels:
    app: ${XYZ_RES_NAME}
    version: v1
spec:
  type: NodePort
  ports:
    - port: ${env.XYZ_RES_PORT}
      protocol: TCP
  selector:
    app: ${XYZ_RES_NAME}
    version: v1

env. Eigenschaft, die aus Umgebungsvariablen und anderen aus der Eigenschaftendatei geladen wird

Hoffe es hat geholfen :)

0
Vikas Tawniya

Ich erstelle ein Skript namens kubectl_apply. Es lädt Variablen aus .env, ersetzt $ {CUSTOMVAR} in yml und übergibt sie an den Befehl kubectl

  #!/bin/bash
  set -a
  source .env
  set +a
  eval "cat <<EOF
  $(<$1)
  EOF
  " | kubectl apply -f -
0

Mein Ansatz:

tools/jinja2-cli.py:

#!/usr/bin/env python3
import os
import sys
from jinja2 import Environment, FileSystemLoader

sys.stdout.write(Environment(loader=FileSystemLoader('templates/')).from_string(sys.stdin.read()).render(env=os.environ) + "\n")

Regel machen:

_GENFILES = $(basename $(TEMPLATES))
GENFILES = $(_GENFILES:templates/%=%)

$(GENFILES): %: templates/%.in $(MKFILES) tools/jinja2-cli.py .env
        env $$(cat .env | xargs) tools/jinja2-cli.py < $< > [email protected] || (rm -f [email protected]; false)

Innerhalb der Datei können Sie ein beliebiges Jinja-Syntaxkonstrukt verwenden, z. {{env.IMAGE}} wird durch den in .env definierten Wert von IMAGE ersetzt.

Ein anderer Ansatz könnte sein

env $(cat .env | xargs) cat <<EOF | kubectl create -f -
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: guestbook
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: guestbook
      spec:
        container:
          - name: guestbook
            image: ${IMAGE}
EOF
0
nyet