Kubernetes-Äquivalent zur env-Datei in Docker

Hintergrund:

Derzeit verwenden wir Docker und Docker Compose für unsere Dienste. Wir haben die Konfiguration für verschiedene Umgebungen in Dateien ausgelagert, die Umgebungsvariablen definieren, die von der Anwendung gelesen werden. Zum Beispiel eine prod.envDatei:

ENV_VAR_ONE=Something Prod
ENV_VAR_TWO=Something else Prod

und eine test.envDatei:

ENV_VAR_ONE=Something Test
ENV_VAR_TWO=Something else Test

Daher können wir beim Starten des Containers einfach die Datei prod.envoder test.envverwenden:

docker run --env-file prod.env <image>

Unsere Anwendung übernimmt dann ihre Konfiguration basierend auf den in definierten Umgebungsvariablen prod.env.

Fragen:

1. Gibt es eine Möglichkeit, Umgebungsvariablen aus einer Datei in Kubernetes bereitzustellen (z. B. beim Definieren eines Pods), anstatt sie wie folgt fest zu codieren:

apiVersion: v1
Art: Pod
Metadaten: 
  Etiketten: 
    Kontext: Docker-K8s-Labor
    Name: MySQL-Pod
  Name: MySQL-Pod
spec: 
  Behälter: 
    - - 
      env: 
        - - 
          Name: MYSQL_USER
          Wert: MySQL
        - - 
          Name: MYSQL_PASSWORD
          Wert: MySQL
        - - 
          Name: MYSQL_DATABASE
          Wert: Probe
        - - 
          Name: MYSQL_ROOT_PASSWORD
          Wert: Supersekret
      Bild: "MySQL: Neueste"
      Name: MySQL
      Häfen: 
        - - 
          containerPort: 3306

2. Wenn dies nicht möglich ist, welcher Ansatz wird vorgeschlagen?

Sie können die Umgebungsvariablen eines Containers mithilfe von Secrets oder ConfigMaps füllen . Verwenden Sie Secrets, wenn die Daten, mit denen Sie arbeiten, vertraulich sind (z. B. Kennwörter), und ConfigMaps, wenn dies nicht der Fall ist.

Geben Sie in Ihrer Pod-Definition an, dass der Container Werte aus einem Geheimnis abrufen soll:

apiVersion: v1
kind: Pod
metadata: 
  labels: 
    context: docker-k8s-lab
    name: mysql-pod
  name: mysql-pod
spec: 
  containers:
  - image: "mysql:latest"
    name: mysql
    ports: 
    - containerPort: 3306
    envFrom:
      - secretRef:
         name: mysql-secret

Beachten Sie, dass diese Syntax nur in Kubernetes 1.6 oder höher verfügbar ist. In einer früheren Version von Kubernetes müssen Sie jeden Wert manuell angeben, z.

env: 
- name: MYSQL_USER
  valueFrom:
    secretKeyRef:
      name: mysql-secret
      key: MYSQL_USER

(Beachten Sie, dass envein Array als Wert verwendet wird.)

Und für jeden Wert wiederholen.

Unabhängig davon, welchen Ansatz Sie verwenden, können Sie jetzt zwei verschiedene Geheimnisse definieren, eines für die Produktion und eines für den Entwickler.

dev-secret.yaml:

apiVersion: v1
kind: Secret
metadata:
  name: mysql-secret
type: Opaque
data:
  MYSQL_USER: bXlzcWwK
  MYSQL_PASSWORD: bXlzcWwK
  MYSQL_DATABASE: c2FtcGxlCg==
  MYSQL_ROOT_PASSWORD: c3VwZXJzZWNyZXQK

prod-secret.yaml:

apiVersion: v1
kind: Secret
metadata:
  name: mysql-secret
type: Opaque
data:
  MYSQL_USER: am9obgo=
  MYSQL_PASSWORD: c2VjdXJlCg==
  MYSQL_DATABASE: cHJvZC1kYgo=
  MYSQL_ROOT_PASSWORD: cm9vdHkK

Und stellen Sie das richtige Geheimnis für den richtigen Kubernetes-Cluster bereit:

kubectl config use-context dev
kubectl create -f dev-secret.yaml

kubectl config use-context prod
kubectl create -f prod-secret.yaml

Wenn ein Pod gestartet wird, werden seine Umgebungsvariablen mit den im Secret angegebenen Werten gefüllt.

Ein neues Update für Kubernetes (v1.6) ermöglicht das, wonach Sie gefragt haben (vor Jahren).

Sie können jetzt envFromFolgendes in Ihrer Yaml-Datei verwenden:

  containers:
  - name: django
    image: image/name
    envFrom:
      - secretRef:
         name: prod-secrets

Wo Entwicklungsgeheimnisse Ihr Geheimnis sind, können Sie es erstellen durch:

kubectl create secret generic prod-secrets --from-env-file=prod/env.txt`

Wo der Inhalt der txt-Datei ein Schlüsselwert ist:

DB_USER=username_here
DB_PASSWORD=password_here

Die Dokumente sind immer noch Seen von Beispielen, ich musste wirklich hart an diesen Orten suchen:

• Secrets docs , search for envFrom- zeigt an, dass diese Option verfügbar ist.
• Die entsprechenden ConfigMapDokumente zeigen ein Beispiel für die Verwendung.

Wenn Sie einen Pod für Kubernetes mithilfe einer YAML-Datei definieren, gibt es keine direkte Möglichkeit, eine andere Datei anzugeben, die Umgebungsvariablen für einen Container enthält. Das Kubernetes-Projekt sagt, dass sie diesen Bereich in Zukunft verbessern werden (siehe Kubernetes-Dokumente ).

In der Zwischenzeit schlage ich vor, ein Bereitstellungstool zu verwenden und den Pod YAML zu einer Vorlage zu machen. Wenn Sie beispielsweise Ansible verwenden, sieht Ihre Pod-YAML-Datei folgendermaßen aus:

Datei my-pod.yaml.template:

apiVersion: v1
kind: Pod
...
spec:
  containers:
  ...
    env:
    - name: MYSQL_ROOT_PASSWORD
      value: {{ mysql_root_pasword }}
    ...

Dann kann Ihr Ansible-Playbook die Variable an einer mysql_root_passwordgeeigneten Stelle angeben und beim Erstellen der Ressource ersetzen, zum Beispiel:

Datei my-playbook.yaml:

- hosts: my_hosts
  vars_files: 
  - my-env-vars-{{ deploy_to }}.yaml
  tasks:
  - name: create pod YAML from template
    template: src=my-pod.yaml.template dst=my-pod.yaml
  - name: create pod in Kubernetes
    command: kubectl create -f my-pod.yaml

Datei my-env-vars-prod.yaml:

mysql_root_password: supersecret

Datei my-env-vars-test.yaml:

mysql_root_password: notsosecret

Jetzt erstellen Sie die Pod-Ressource, indem Sie beispielsweise Folgendes ausführen:

ansible-playbook -e deploy=test my-playbook.yaml

Das funktioniert bei mir:

Datei env-secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: env-secret
type: Opaque
stringData:
  .env: |-
    APP_NAME=Laravel
    APP_ENV=local

und in die deployment.yamloderpod.yaml

spec:
  ...
        volumeMounts:
        - name: foo
          mountPath: "/var/www/html/.env"
          subPath: .env
      volumes:
      - name: foo
        secret:
          secretName: env-secret
````

Dies ist eine alte Frage, aber sie hat viele Zuschauer, deshalb füge ich meine Antwort hinzu. Der beste Weg, um die Konfiguration von der K8-Implementierung zu trennen, ist die Verwendung von Helm. Jedes Helm-Paket kann eine values.yamlDatei enthalten, und wir können diese Werte problemlos im Helm-Diagramm verwenden. Wenn wir eine Mehrkomponententopologie haben, können wir ein Umbrella-Helm-Paket erstellen und das übergeordnete Wertepaket kann auch die untergeordneten Wertedateien überschreiben.

Dies ist eine alte Frage, aber lassen Sie mich meine Antwort für zukünftige Anfänger beschreiben.

Sie können kustomize configMapGenerator verwenden.

configMapGenerator:
  - name: example
    env: dev.env

und verweisen Sie auf diese configMap / dieses Beispiel in der Pod-Definition