kubernetes - en to de_DE translation catalogue (212 entries)

en: 
    		  # Create a ClusterRoleBinding for user1, user2, and group1 using the cluster-admin ClusterRole
    		  kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-admin --user=user1 --user=user2 --group=group1
de_DE: 
    		 # Erstellt ein ClusterRoleBinding für user1, user2 und group1 mit der ClusterRole cluster-admin
    		  kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-admin --user=user1 --user=user2 --group=group1

en: 
    		  # Create a RoleBinding for user1, user2, and group1 using the admin ClusterRole
    		  kubectl create rolebinding admin --clusterrole=admin --user=user1 --user=user2 --group=group1
de_DE: 
    		  # Erstellt ein RoleBinding für user1, user2 und group1 mit der ClusterRole admin
    		  kubectl create rolebinding admin --clusterrole=admin --user=user1 --user=user2 --group=group1

en: 
    		  # Create a new configmap named my-config based on folder bar
    		  kubectl create configmap my-config --from-file=path/to/bar
    
    		  # Create a new configmap named my-config with specified keys instead of file basenames on disk
    		  kubectl create configmap my-config --from-file=key1=/path/to/bar/file1.txt --from-file=key2=/path/to/bar/file2.txt
    
    		  # Create a new configmap named my-config with key1=config1 and key2=config2
    		  kubectl create configmap my-config --from-literal=key1=config1 --from-literal=key2=config2
de_DE: 
    		  # Erstellt eine neue ConfigMap mit dem Namen my-config basierend auf dem Ordner bar
    		  kubectl create configmap my-config --from-file=path/to/bar
    
    		  # Erstellt eine neue ConfigMap mit dem Namen my-config mit den angegebenen Keys statt des Dateinamens auf der Festplatte.
    		  kubectl create configmap my-config --from-file=key1=/path/to/bar/file1.txt --from-file=key2=/path/to/bar/file2.txt
    
    		  # Erstellt eine neue ConfigMap mit dem Namen my-config mit key1=config1 und key2=config2
    		  kubectl create configmap my-config --from-literal=key1=config1 --from-literal=key2=config2

en: 
    		  # If you don't already have a .dockercfg file, you can create a dockercfg secret directly by using:
    		  kubectl create secret docker-registry my-secret --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL
de_DE: 
    		  # Wenn keine .dockercfg Datei existiert, kann direkt ein dockercfg Secret erstellen mit:
    		  kubectl create secret docker-registry my-secret --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL

en: 
    		  # Show metrics for all nodes
    		  kubectl top node
    
    		  # Show metrics for a given node
    		  kubectl top node NODE_NAME
de_DE: 
    		  # Zeige Metriken für alle Nodes
    		  kubectl top node
    
    		  # Zeige Metriken für den gegebenen Node
    		  kubectl top node NODE_NAME

en: 
    		# Apply the configuration in pod.json to a pod.
    		kubectl apply -f ./pod.json
    
    		# Apply the JSON passed into stdin to a pod.
    		cat pod.json | kubectl apply -f -
    
    		# Note: --prune is still in Alpha
    		# Apply the configuration in manifest.yaml that matches label app=nginx and delete all the other resources that are not in the file and match label app=nginx.
    		kubectl apply --prune -f manifest.yaml -l app=nginx
    
    		# Apply the configuration in manifest.yaml and delete all the other configmaps that are not in the file.
    		kubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/ConfigMap
de_DE: 
    		# Wende die Konfiguration in pod.json auf einen Pod an.
    		kubectl apply -f ./pod.json
    
    		# Wende die JSON-Daten von stdin auf einen Pod an.
    		cat pod.json | kubectl apply -f -
    
    		# Hinweis: --prune ist noch in Alpha
    		# Wende die Konfiguration, mit dem Label app=nginx, im manifest.yaml an und lösche alle Resourcen, die nicht in der Datei sind oder nicht das Label app=nginx besitzen.
    		kubectl apply --prune -f manifest.yaml -l app=nginx
    
    		# Wende die Konfiguration im manifest.yaml an und lösche alle ConfigMaps, die nicht in der Datei sind.
    		kubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/ConfigMap

en: 
    		# Auto scale a deployment "foo", with the number of pods between 2 and 10, no target CPU utilization specified so a default autoscaling policy will be used:
    		kubectl autoscale deployment foo --min=2 --max=10
    
    		# Auto scale a replication controller "foo", with the number of pods between 1 and 5, target CPU utilization at 80%:
    		kubectl autoscale rc foo --max=5 --cpu-percent=80
de_DE: 
    		# Auto-skaliere ein Deployment "foo", mit einer Anzahl an Pods zwischen 2 und 10, eine Ziel-CPU-Auslastung ist angegeben, sodass eine Standard-autoskalierungsregel verwendet wird:
    		kubectl autoscale deployment foo --min=2 --max=10
    
    		# Auto-skaliere einen Replication-Controller "foo", mit einer Anzahl an Pods zwischen 1 und 5, mit einer Ziel-CPU-Auslastung von 80%:
    		kubectl autoscale rc foo --max=5 --cpu-percent=80

en: 
    		# Convert 'pod.yaml' to latest version and print to stdout.
    		kubectl convert -f pod.yaml
    
    		# Convert the live state of the resource specified by 'pod.yaml' to the latest version
    		# and print to stdout in json format.
    		kubectl convert -f pod.yaml --local -o json
    
    		# Convert all files under current directory to latest version and create them all.
    		kubectl convert -f . | kubectl create -f -
de_DE: 
    		# Konvertiere 'pod.yaml' zur neuesten Version und schreibe auf stdout.
    		kubectl convert -f pod.yaml
    
    		# Konvertiere den aktuellen Zustand der Resource, die in 'pod.yaml' angegeben ist, zur neuesten Version
    		# und schreibe auf stdout im JSON-Format.
    		kubectl convert -f pod.yaml --local -o json
    
    		# Konvertiere alle Dateien im aktuellen Ordner zur neuesten Version und erstelle sie.
    		kubectl convert -f . | kubectl create -f -

en: 
    		# Create a ClusterRole named "pod-reader" that allows user to perform "get", "watch" and "list" on pods
    		kubectl create clusterrole pod-reader --verb=get,list,watch --resource=pods
    
    		# Create a ClusterRole named "pod-reader" with ResourceName specified
    		kubectl create clusterrole pod-reader --verb=get,list,watch --resource=pods --resource-name=readablepod
de_DE: 
    		# Erstellt eine ClusterRole "pod-reader", die es Nutzern erlaubt "get", "watch" und "list" auf den Pods auszuführen
    		kubectl create clusterrole pod-reader --verb=get,list,watch --resource=pods
    
    		# Erstellt eine ClusterRole "pod-reader" mit dem angegebenen ResourceName
    		kubectl create clusterrole pod-reader --verb=get,list,watch --resource=pods --resource-name=readablepod

en: 
    		# Create a Role named "pod-reader" that allows user to perform "get", "watch" and "list" on pods
    		kubectl create role pod-reader --verb=get --verb=list --verb=watch --resource=pods
    
    		# Create a Role named "pod-reader" with ResourceName specified
    		kubectl create role pod-reader --verb=get --verg=list --verb=watch --resource=pods --resource-name=readablepod
de_DE: 
    		# Erstellt eine Role "pod-reader", die es dem Nutzer erlaubt "get", "watch" und "list" auf den Pods auszuführen
    		kubectl create role pod-reader --verb=get --verb=list --verb=watch --resource=pods
    
    		# Erstellt eine Role "pod-reader" mit dem angegebenen ResourceName
    		kubectl create role pod-reader --verb=get --verg=list --verb=watch --resource=pods --resource-name=readablepod

en: 
    		# Create a new resourcequota named my-quota
    		kubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,replicationcontrollers=2,resourcequotas=1,secrets=5,persistentvolumeclaims=10
    
    		# Create a new resourcequota named best-effort
    		kubectl create quota best-effort --hard=pods=100 --scopes=BestEffort
de_DE: 
    		# Erstellt eine neue ResourceQuota my-quota
    		kubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,replicationcontrollers=2,resourcequotas=1,secrets=5,persistentvolumeclaims=10
    
    		# Erstellt eine neue ResourceQuota best-effort
    		kubectl create quota best-effort --hard=pods=100 --scopes=BestEffort

en: 
    		# Create a pod disruption budget named my-pdb that will select all pods with the app=rails label
    		# and require at least one of them being available at any point in time.
    		kubectl create poddisruptionbudget my-pdb --selector=app=rails --min-available=1
    
    		# Create a pod disruption budget named my-pdb that will select all pods with the app=nginx label
    		# and require at least half of the pods selected to be available at any point in time.
    		kubectl create pdb my-pdb --selector=app=nginx --min-available=50%
de_DE: 
    		# Erstellt ein Pod-Disruption-Budget my-pdb, dass alle Pods mit dem Label app=rails auswählt
    		# und sicherstellt, dass mindestens einer von ihnen zu jedem Zeitpunkt verfügbar ist.
    		kubectl create poddisruptionbudget my-pdb --selector=app=rails --min-available=1
    
    		# Erstellt ein Pod-Disruption-Budget my-pdb, dass alle Pods mit dem Label app=nginx auswählt
    		# und sicherstellt, dass mindestens die Hälfte der gewählten Pods zu jedem Zeitpunkt verfügbar ist.
    		kubectl create pdb my-pdb --selector=app=nginx --min-available=50%

en: 
    		# Create a pod using the data in pod.json.
    		kubectl create -f ./pod.json
    
    		# Create a pod based on the JSON passed into stdin.
    		cat pod.json | kubectl create -f -
    
    		# Edit the data in docker-registry.yaml in JSON using the v1 API format then create the resource using the edited data.
    		kubectl create -f docker-registry.yaml --edit --output-version=v1 -o json
de_DE: 
    		# Erstellt einen Pod mit den Daten in pod.json.
    		kubectl create -f ./pod.json
    
    		# Erstellt einen Pod basierend auf den JSON-Daten von stdin.
    		cat pod.json | kubectl create -f -
    
    		# Verändert die Daten in docker-registry.yaml in JSON mit dem v1 API Format und erstellt eine Resource mit den veränderten Daten.
    		kubectl create -f docker-registry.yaml --edit --output-version=v1 -o json

en: 
    		# Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000.
    		kubectl expose rc nginx --port=80 --target-port=8000
    
    		# Create a service for a replication controller identified by type and name specified in "nginx-controller.yaml", which serves on port 80 and connects to the containers on port 8000.
    		kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000
    
    		# Create a service for a pod valid-pod, which serves on port 444 with the name "frontend"
    		kubectl expose pod valid-pod --port=444 --name=frontend
    
    		# Create a second service based on the above service, exposing the container port 8443 as port 443 with the name "nginx-https"
    		kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https
    
    		# Create a service for a replicated streaming application on port 4100 balancing UDP traffic and named 'video-stream'.
    		kubectl expose rc streamer --port=4100 --protocol=udp --name=video-stream
    
    		# Create a service for a replicated nginx using replica set, which serves on port 80 and connects to the containers on port 8000.
    		kubectl expose rs nginx --port=80 --target-port=8000
    
    		# Create a service for an nginx deployment, which serves on port 80 and connects to the containers on port 8000.
    		kubectl expose deployment nginx --port=80 --target-port=8000
de_DE: 
    		# Erstellt einen Service für einen replizierten nginx, der auf Port 80 hört und verbindet sich mit den Containern auf Port 8000.
    		kubectl expose rc nginx --port=80 --target-port=8000
    
    		# Erstellt einen Service für einen Replication-Controller, der über type und name in "nginx-controller.yaml" identifiziert wird, auf Port 80 hört und verbindet sich mit den Containern auf Port 8000.
    		kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000
    
    		# Erstellt einen Service, mit dem Namen "frontend", für einen Pod valid-pod, der auf port 444 hört
    		kubectl expose pod valid-pod --port=444 --name=frontend
    
    		# Erstellt einen zweiten Service basierend auf dem vorherigen Service, der den Container Port 8443 auf Port 443 mit dem Namen "nginx-https" anbietet
    		kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https
    
    		# Erstellt einen Service für eine Replicated-Streaming-Application auf Port 4100, die UDP-Traffic verarbeitet und 'video-stream' heißt.
    		kubectl expose rc streamer --port=4100 --protocol=udp --name=video-stream
    
    		# Erstellt einen Service für einen replizierten nginx mit einem Replica-Set, dass auf Port 80 hört und verbindet sich mit den Containern auf Port 8000.
    		kubectl expose rs nginx --port=80 --target-port=8000
    
    		# Erstellt einen Service für ein nginx Deployment, dass auf Port 80 hört und verbindet sich mit den Containern auf Port 8000.
    		kubectl expose deployment nginx --port=80 --target-port=8000

en: 
    		# Delete a pod using the type and name specified in pod.json.
    		kubectl delete -f ./pod.json
    
    		# Delete a pod based on the type and name in the JSON passed into stdin.
    		cat pod.json | kubectl delete -f -
    
    		# Delete pods and services with same names "baz" and "foo"
    		kubectl delete pod,service baz foo
    
    		# Delete pods and services with label name=myLabel.
    		kubectl delete pods,services -l name=myLabel
    
    		# Delete a pod with minimal delay
    		kubectl delete pod foo --now
    
    		# Force delete a pod on a dead node
    		kubectl delete pod foo --grace-period=0 --force
    
    		# Delete all pods
    		kubectl delete pods --all
de_DE: 
    		# Löscht einen Pod mit type und name aus pod.json.
    		kubectl delete -f ./pod.json
    
    		# Löscht einen Pod mit dem type und name aus den JSON-Daten von stdin.
    		cat pod.json | kubectl delete -f -
    
    		# Löscht Pods und Services mit den Namen "baz" und "foo"
    		kubectl delete pod,service baz foo
    
    		# Löscht Pods und Services mit dem Label name=myLabel.
    		kubectl delete pods,services -l name=myLabel
    
    		# Löscht einen Pod mit minimaler Verzögerung
    		kubectl delete pod foo --now
    
    		# Erzwingt das Löschen eines Pods auf einem toten Node
    		kubectl delete pod foo --grace-period=0 --force
    
    		# Löscht alle Pods
    		kubectl delete pods --all

en: 
    		# Describe a node
    		kubectl describe nodes kubernetes-node-emt8.c.myproject.internal
    
    		# Describe a pod
    		kubectl describe pods/nginx
    
    		# Describe a pod identified by type and name in "pod.json"
    		kubectl describe -f pod.json
    
    		# Describe all pods
    		kubectl describe pods
    
    		# Describe pods by label name=myLabel
    		kubectl describe po -l name=myLabel
    
    		# Describe all pods managed by the 'frontend' replication controller (rc-created pods
    		# get the name of the rc as a prefix in the pod the name).
    		kubectl describe pods frontend
de_DE: 
    		# Beschreibt einen Knoten
    		kubectl describe nodes kubernetes-node-emt8.c.myproject.internal
    
    		# Beschreibt einen Pod
    		kubectl describe pods/nginx
    
    		# Beschreibt einen Pod mit type und name aus "pod.json"
    		kubectl describe -f pod.json
    
    		# Beschreibt alle Pods
    		kubectl describe pods
    
    		# Beschreibt Pods mit dem Label name=myLabel
    		kubectl describe po -l name=myLabel
    
    		# Beschreibt alle Pods, die vom ReplicationController 'frontend' verwaltet werden (rc-erstellte Pods
    		# bekommen den Namen des rc als Prefix im Podnamen).
    		kubectl describe pods frontend

en: 
    		# Drain node "foo", even if there are pods not managed by a ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet on it.
    		$ kubectl drain foo --force
    
    		# As above, but abort if there are pods not managed by a ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet, and use a grace period of 15 minutes.
    		$ kubectl drain foo --grace-period=900
de_DE: 
    		# Leere den Knoten "foo", selbst wenn er Pods enthält, die nicht von einem ReplicationController, ReplicaSet, Job, DaemonSet oder StatefulSet verwaltet werden.
    		$ kubectl drain foo --force
    
    		# Wie zuvor, aber es wird abgebrochen, wenn er Pods enthält, die nicht von einem ReplicationController, ReplicaSet, Job, DaemonSet oder StatefulSet verwaltet werden und mit einer Schonfrist von 15 Minuten.
    		$ kubectl drain foo --grace-period=900

en: 
    		# Edit the service named 'docker-registry':
    		kubectl edit svc/docker-registry
    
    		# Use an alternative editor
    		KUBE_EDITOR="nano" kubectl edit svc/docker-registry
    
    		# Edit the job 'myjob' in JSON using the v1 API format:
    		kubectl edit job.v1.batch/myjob -o json
    
    		# Edit the deployment 'mydeployment' in YAML and save the modified config in its annotation:
    		kubectl edit deployment/mydeployment -o yaml --save-config
de_DE: 
    		# Bearbeite den Service 'docker-registry':
    		kubectl edit svc/docker-registry
    
    		# Benutze einen anderen Editor
    		KUBE_EDITOR="nano" kubectl edit svc/docker-registry
    
    		# Bearbeite den Job 'myjob' in JSON mit dem v1 API Format:
    		kubectl edit job.v1.batch/myjob -o json
    
    		# Bearbeite das Deployment 'mydeployment' in YAML und speichere die veränderte Konfiguration in ihrer Annotation:
    		kubectl edit deployment/mydeployment -o yaml --save-config

en: 
    		# Get output from running 'date' from pod 123456-7890, using the first container by default
    		kubectl exec 123456-7890 date
    
    		# Get output from running 'date' in ruby-container from pod 123456-7890
    		kubectl exec 123456-7890 -c ruby-container date
    
    		# Switch to raw terminal mode, sends stdin to 'bash' in ruby-container from pod 123456-7890
    		# and sends stdout/stderr from 'bash' back to the client
    		kubectl exec 123456-7890 -c ruby-container -i -t -- bash -il
de_DE: 
    		# Erhalte die Ausgabe vom Aufruf von 'date' auf dem Pod 123456-7890, mit dem ersten Container als Standard
    		kubectl exec 123456-7890 date
    
    		# Erhalte die Ausgabe vom Aufruf von 'date' im Ruby-Container aus dem Pod 123456-7890
    		kubectl exec 123456-7890 -c ruby-container date
    
    		# Wechsle in den Terminal-Modus und sende stdin zu 'bash' im Ruby-Container aus dem Pod 123456-7890
    		# und sende stdout/stderr von 'bash' zurück zum Client
    		kubectl exec 123456-7890 -c ruby-container -i -t -- bash -il

en: 
    		# Get output from running pod 123456-7890, using the first container by default
    		kubectl attach 123456-7890
    
    		# Get output from ruby-container from pod 123456-7890
    		kubectl attach 123456-7890 -c ruby-container
    
    		# Switch to raw terminal mode, sends stdin to 'bash' in ruby-container from pod 123456-7890
    		# and sends stdout/stderr from 'bash' back to the client
    		kubectl attach 123456-7890 -c ruby-container -i -t
    
    		# Get output from the first pod of a ReplicaSet named nginx
    		kubectl attach rs/nginx
de_DE: 
    		# Erhalte die Ausgabe vom laufenden Pod 123456-7890, mit dem ersten Container als Standard
    		kubectl attach 123456-7890
    
    		# Erhalte die Ausgabe vom Ruby-Container aus dem Pod 123456-7890
    		kubectl attach 123456-7890 -c ruby-container
    
    		# Wechsle in den Terminal-Modus und sende stdin zu 'bash' im Ruby-Container aus dem Pod 123456-7890
    		# und sende stdout/stderr von 'bash' zurück zum Client
    		kubectl attach 123456-7890 -c ruby-container -i -t
    
    		# Erhalte die Ausgabe vom ersten Pod eines ReplicaSets nginx
    		kubectl attach rs/nginx

en: 
    		# Get the documentation of the resource and its fields
    		kubectl explain pods
    
    		# Get the documentation of a specific field of a resource
    		kubectl explain pods.spec.containers
de_DE: 
    		# Erhalte die Dokumentation einer Resource und ihrer Felder
    		kubectl explain pods
    
    		# Erhalte die Dokumentation eines speziellen Felds einer Resource
    		kubectl explain pods.spec.containers

en: 
    		# Install bash completion on a Mac using homebrew
    		brew install bash-completion
    		printf "
    # Bash completion support
    source $(brew --prefix)/etc/bash_completion
    " >> $HOME/.bash_profile
    		source $HOME/.bash_profile
    
    		# Load the kubectl completion code for bash into the current shell
    		source <(kubectl completion bash)
    
    		# Write bash completion code to a file and source if from .bash_profile
    		kubectl completion bash > ~/.kube/completion.bash.inc
    		printf "
    # Kubectl shell completion
    source '$HOME/.kube/completion.bash.inc'
    " >> $HOME/.bash_profile
    		source $HOME/.bash_profile
    
    		# Load the kubectl completion code for zsh[1] into the current shell
    		source <(kubectl completion zsh)
de_DE: 
    		# Installiere bash completion auf einem Mac mit homebrew
    		brew install bash-completion
    		printf "
    # Bash completion support
    source $(brew --prefix)/etc/bash_completion
    " >> $HOME/.bash_profile
    		source $HOME/.bash_profile
    
    		# Lade den kubectl-Completion-Code für bash in der aktuellen Shell
    		source <(kubectl completion bash)
    
    		# Schreibe den Bash-Completion-Code in eine Datei und source sie im .bash_profile
    		kubectl completion bash > ~/.kube/completion.bash.inc
    		printf "
    # Kubectl shell completion
    source '$HOME/.kube/completion.bash.inc'
    " >> $HOME/.bash_profile
    		source $HOME/.bash_profile
    
    		# Lade den kubectl-Completion-Code für zsh[1] in die aktuelle Shell
    		source <(kubectl completion zsh)

en: 
    		# List all pods in ps output format.
    		kubectl get pods
    
    		# List all pods in ps output format with more information (such as node name).
    		kubectl get pods -o wide
    
    		# List a single replication controller with specified NAME in ps output format.
    		kubectl get replicationcontroller web
    
    		# List a single pod in JSON output format.
    		kubectl get -o json pod web-pod-13je7
    
    		# List a pod identified by type and name specified in "pod.yaml" in JSON output format.
    		kubectl get -f pod.yaml -o json
    
    		# Return only the phase value of the specified pod.
    		kubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}
    
    		# List all replication controllers and services together in ps output format.
    		kubectl get rc,services
    
    		# List one or more resources by their type and names.
    		kubectl get rc/web service/frontend pods/web-pod-13je7
    
    		# List all resources with different types.
    		kubectl get all
de_DE: 
    		# Liste alle Pods im ps-Format auf.
    		kubectl get pods
    
    		# Liste alle Pods im ps-Format mit zusätzlichen Informationen (wie dem Knotennamen) auf.
    		kubectl get pods -o wide
    
    		# Liste alle einzelnen ReplicationController mit dem angegebenen Namen im ps-Format auf.
    		kubectl get replicationcontroller web
    
    		# Liste einen einzelnen Pod im JSON-Format auf.
    		kubectl get -o json pod web-pod-13je7
    
    		# Liste einen Pod mit Typ und Namen aus "pod.yaml" im JSON-Format auf.
    		kubectl get -f pod.yaml -o json
    
    		# Gib nur den phase-Wert des angegebenen Pods zurück.
    		kubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}
    
    		# Liste alle ReplicationController und Services im ps-Format auf.
    		kubectl get rc,services
    
    		# Liste eine oder mehrere Resourcen über ihren Typ und Namen auf.
    		kubectl get rc/web service/frontend pods/web-pod-13je7
    
    		# Liste alle Resourcen mit verschiedenen Typen auf.
    		kubectl get all

en: 
    		# Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in the pod
    		kubectl port-forward mypod 5000 6000
    
    		# Listen on port 8888 locally, forwarding to 5000 in the pod
    		kubectl port-forward mypod 8888:5000
    
    		# Listen on a random port locally, forwarding to 5000 in the pod
    		kubectl port-forward mypod :5000
    
    		# Listen on a random port locally, forwarding to 5000 in the pod
    		kubectl port-forward mypod 0:5000
de_DE: 
    		# Hört lokal auf Port 5000 und 6000 und leitet Daten zum/vom Port 5000 und 6000 weiter an den Pod
    		kubectl port-forward mypod 5000 6000
    
    		# Hört lokal auf Port 8888 und leitet an Port 5000 des Pods weiter
    		kubectl port-forward mypod 8888:5000
    
    		# Hört auf einen zufälligen lokalen Port und leitet an Port 5000 des Pods weiter
    		kubectl port-forward mypod :5000
    
    		# Hört auf einen zufälligen lokalen Port und leitet an Port 5000 des Pods weiter
    		kubectl port-forward mypod 0:5000

en: 
    		# Mark node "foo" as schedulable.
    		$ kubectl uncordon foo
de_DE: 
    		# Markiere Knoten "foo" als schedulable.
    		$ kubectl uncordon foo

en: 
    		# Mark node "foo" as unschedulable.
    		kubectl cordon foo
de_DE: 
    		# Markiere Knoten "foo" als unschedulable.
    		kubectl cordon foo

en: 
    		# Partially update a node using strategic merge patch
    		kubectl patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}'
    
    		# Partially update a node identified by the type and name specified in "node.json" using strategic merge patch
    		kubectl patch -f node.json -p '{"spec":{"unschedulable":true}}'
    
    		# Update a container's image; spec.containers[*].name is required because it's a merge key
    		kubectl patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'
    
    		# Update a container's image using a json patch with positional arrays
    		kubectl patch pod valid-pod --type='json' -p='[{"op": "replace", "path": "/spec/containers/0/image", "value":"new image"}]'
de_DE: 
    		# Aktualisiere einen Knoten teilweise mit einem Strategic-Merge-Patch
    		kubectl patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}'
    
    		# Aktualisiere einen Knoten, mit type und name aus "node.json", mit einem Strategic-Merge-Patch
    		kubectl patch -f node.json -p '{"spec":{"unschedulable":true}}'
    
    		# Aktualisiere das Image eines Containers; spec.containers[*].name ist erforderlich, da es der Merge-Key ist
    		kubectl patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'
    
    		# Aktualisiere das Image eines Containers mit einem JSON-Patch mit Positional-Arrays
    		kubectl patch pod valid-pod --type='json' -p='[{"op": "replace", "path": "/spec/containers/0/image", "value":"new image"}]'

en: 
    		# Print flags inherited by all commands
    		kubectl options
de_DE: 
    		# Gebe Optionen aus, die an alle Kommandos vererbt werden
    		kubectl options

en: 
    		# Print the address of the master and cluster services
    		kubectl cluster-info
de_DE: 
    		# Gebe die Adresse des Masters und des Cluster-Services aus
    		kubectl cluster-info

en: 
    		# Print the client and server versions for the current context
    		kubectl version
de_DE: 
    		# Gebe die Client- und Server-Versionen des aktuellen Kontexts aus
    		kubectl version

en: 
    		# Print the supported API versions
    		kubectl api-versions
de_DE: 
    		# Gebe die unterstützten API Versionen aus
    		kubectl api-versions

en: 
    		# Replace a pod using the data in pod.json.
    		kubectl replace -f ./pod.json
    
    		# Replace a pod based on the JSON passed into stdin.
    		cat pod.json | kubectl replace -f -
    
    		# Update a single-container pod's image version (tag) to v4
    		kubectl get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/:v4/' | kubectl replace -f -
    
    		# Force replace, delete and then re-create the resource
    		kubectl replace --force -f ./pod.json
de_DE: 
    		# Ersetze einen Pod mit den Daten aus pod.json.
    		kubectl replace -f ./pod.json
    
    		# Ersetze einen Pod mit den JSON-Daten von stdin.
    		cat pod.json | kubectl replace -f -
    
    		# Setze die Pod-Image-Version (tag) eines einzelnen Containers zu v4
    		kubectl get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/:v4/' | kubectl replace -f -
    
    		# Erzwinge das Ersetzen, Löschen und Neu-Erstellen der Resource
    		kubectl replace --force -f ./pod.json

en: 
    		# Return snapshot logs from pod nginx with only one container
    		kubectl logs nginx
    
    		# Return snapshot logs for the pods defined by label app=nginx
    		kubectl logs -lapp=nginx
    
    		# Return snapshot of previous terminated ruby container logs from pod web-1
    		kubectl logs -p -c ruby web-1
    
    		# Begin streaming the logs of the ruby container in pod web-1
    		kubectl logs -f -c ruby web-1
    
    		# Display only the most recent 20 lines of output in pod nginx
    		kubectl logs --tail=20 nginx
    
    		# Show all logs from pod nginx written in the last hour
    		kubectl logs --since=1h nginx
    
    		# Return snapshot logs from first container of a job named hello
    		kubectl logs job/hello
    
    		# Return snapshot logs from container nginx-1 of a deployment named nginx
    		kubectl logs deployment/nginx -c nginx-1
de_DE: 
    		# Gib die Snapshot-Logs des Pods nginx mit nur einem Container zurück
    		kubectl logs nginx
    
    		# Gib die Snapshot-Logs für die Pods mit dem Label app=nginx zurück
    		kubectl logs -lapp=nginx
    
    		# Gib die Snapshot-Logs des zuvor gelöschten Ruby-Containers des Pods web-1 zurück
    		kubectl logs -p -c ruby web-1
    
    		# Starte das Streaming der Logs vom Ruby-Container im Pod web-1
    		kubectl logs -f -c ruby web-1
    
    		# Zeige die letzten 20 Zeilen der Ausgabe des Pods nginx
    		kubectl logs --tail=20 nginx
    
    		# Zeige alle Logs der letzten Stunde des Pods nginx an
    		kubectl logs --since=1h nginx
    
    		# Gib die Snapshot-Logs des ersten Containers des Jobs hello zurück
    		kubectl logs job/hello
    
    		# Gib die Snapshot-Logs des Containers nginx-1 eines Deployments nginx zurück
    		kubectl logs deployment/nginx -c nginx-1

en: 
    		# Run a proxy to kubernetes apiserver on port 8011, serving static content from ./local/www/
    		kubectl proxy --port=8011 --www=./local/www/
    
    		# Run a proxy to kubernetes apiserver on an arbitrary local port.
    		# The chosen port for the server will be output to stdout.
    		kubectl proxy --port=0
    
    		# Run a proxy to kubernetes apiserver, changing the api prefix to k8s-api
    		# This makes e.g. the pods api available at localhost:8001/k8s-api/v1/pods/
    		kubectl proxy --api-prefix=/k8s-api
de_DE: 
    		# Starte einen Proxy zum Kubernetes-Apiserver auf Port 8011 und sende statische Inhalte von ./local/www/
    		kubectl proxy --port=8011 --www=./local/www/
    
    		# Starte einen Proxy zum Kubernetes-Apiserver auf einem zufälligen lokalen Port.
    		# Der gewählte Port für den Server wird im stdout zurückgegeben.
    		kubectl proxy --port=0
    
    		# Starte einen Proxy zum Kubernetes-Apiserver und ändere das API-Prefix zu k8s-api
    		# Damit ist die Pods-API bspw. unter localhost:8001/k8s-api/v1/pods/ erreichbar
    		kubectl proxy --api-prefix=/k8s-api

en: 
    		# Scale a replicaset named 'foo' to 3.
    		kubectl scale --replicas=3 rs/foo
    
    		# Scale a resource identified by type and name specified in "foo.yaml" to 3.
    		kubectl scale --replicas=3 -f foo.yaml
    
    		# If the deployment named mysql's current size is 2, scale mysql to 3.
    		kubectl scale --current-replicas=2 --replicas=3 deployment/mysql
    
    		# Scale multiple replication controllers.
    		kubectl scale --replicas=5 rc/foo rc/bar rc/baz
    
    		# Scale job named 'cron' to 3.
    		kubectl scale --replicas=3 job/cron
de_DE: 
    		# Skaliere ein ReplicaSet 'foo' auf 3.
    		kubectl scale --replicas=3 rs/foo
    
    		# Skaliere eine Resource mit type und name aus "foo.yaml" auf 3.
    		kubectl scale --replicas=3 -f foo.yaml
    
    		# Wenn die aktuelle Größe des Deployments mysql 2 ist, skaliere mysql auf 3.
    		kubectl scale --current-replicas=2 --replicas=3 deployment/mysql
    
    		# Skaliere mehrere MultiplicationController.
    		kubectl scale --replicas=5 rc/foo rc/bar rc/baz
    
    		# Skaliere den Job cron auf 3.
    		kubectl scale --replicas=3 job/cron

en: 
    		# Set the last-applied-configuration of a resource to match the contents of a file.
    		kubectl apply set-last-applied -f deploy.yaml
    
    		# Execute set-last-applied against each configuration file in a directory.
    		kubectl apply set-last-applied -f path/
    
    		# Set the last-applied-configuration of a resource to match the contents of a file, will create the annotation if it does not already exist.
    		kubectl apply set-last-applied -f deploy.yaml --create-annotation=true
de_DE: 
    		# Setze die Last-Applied-Configuration einer Resource auf den Inhalt einer Datei.
    		kubectl apply set-last-applied -f deploy.yaml
    
    		# Führe Set-Last-Applied auf jeder Konfigurationsdatei in einem Ordner aus.
    		kubectl apply set-last-applied -f path/
    
    		# Setze die Last-Applied-Configuration einer Resource auf den Inhalt einer Datei; erstellt die Annotation, wenn sie noch nicht existiert.
    		kubectl apply set-last-applied -f deploy.yaml --create-annotation=true

en: 
    		# Show metrics for all pods in the default namespace
    		kubectl top pod
    
    		# Show metrics for all pods in the given namespace
    		kubectl top pod --namespace=NAMESPACE
    
    		# Show metrics for a given pod and its containers
    		kubectl top pod POD_NAME --containers
    
    		# Show metrics for the pods defined by label name=myLabel
    		kubectl top pod -l name=myLabel
de_DE: 
    		# Zeige Metriken für alle Pods im Namespace default
    		kubectl top pod
    
    		# Zeige Metriken für alle Pods im gegebenen namespace
    		kubectl top pod --namespace=NAMESPACE
    
    		# Zeige Metriken für den gebenen Pod und seine Container
    		kubectl top pod POD_NAME --containers
    
    		# Zeige Metriken für Pods mit dem Label name=myLabel
    		kubectl top pod -l name=myLabel

en: 
    		# Shut down foo.
    		kubectl stop replicationcontroller foo
    
    		# Stop pods and services with label name=myLabel.
    		kubectl stop pods,services -l name=myLabel
    
    		# Shut down the service defined in service.json
    		kubectl stop -f service.json
    
    		# Shut down all resources in the path/to/resources directory
    		kubectl stop -f path/to/resources
de_DE: 
    		# Stoppe foo.
    		kubectl stop replicationcontroller foo
    
    		# Stoppe Pods und Services mit dem Label name=myLabel.
    		kubectl stop pods,services -l name=myLabel
    
    		# Stoppe den in service.json definierten Service
    		kubectl stop -f service.json
    
    		# Stoppe alle Resourcen im Ordner path/to/resources
    		kubectl stop -f path/to/resources

en: 
    		# Start a single instance of nginx.
    		kubectl run nginx --image=nginx
    
    		# Start a single instance of hazelcast and let the container expose port 5701 .
    		kubectl run hazelcast --image=hazelcast --port=5701
    
    		# Start a single instance of hazelcast and set environment variables "DNS_DOMAIN=cluster" and "POD_NAMESPACE=default" in the container.
    		kubectl run hazelcast --image=hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"
    
    		# Start a replicated instance of nginx.
    		kubectl run nginx --image=nginx --replicas=5
    
    		# Dry run. Print the corresponding API objects without creating them.
    		kubectl run nginx --image=nginx --dry-run
    
    		# Start a single instance of nginx, but overload the spec of the deployment with a partial set of values parsed from JSON.
    		kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'
    
    		# Start a pod of busybox and keep it in the foreground, don't restart it if it exits.
    		kubectl run -i -t busybox --image=busybox --restart=Never
    
    		# Start the nginx container using the default command, but use custom arguments (arg1 .. argN) for that command.
    		kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>
    
    		# Start the nginx container using a different command and custom arguments.
    		kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>
    
    		# Start the perl container to compute π to 2000 places and print it out.
    		kubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'
    
    		# Start the cron job to compute π to 2000 places and print it out every 5 minutes.
    		kubectl run pi --schedule="0/5 * * * ?" --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'
de_DE: 
    		# Starte eine einzelne Instanz von nginx.
    		kubectl run nginx --image=nginx
    
    		# Starte eine einzelne Instanz von hazelcast und öffne Port 5701 auf dem Container.
    		kubectl run hazelcast --image=hazelcast --port=5701
    
    		# Starte eine einzelne Instanz von hazelcast und setze die Umgebungs-variablen "DNS_DOMAIN=cluster" und "POD_NAMESPACE=default" im Container.
    		kubectl run hazelcast --image=hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"
    
    		# Starte eine replizierte Instanz von nginx.
    		kubectl run nginx --image=nginx --replicas=5
    
    		# Testlauf. Zeige die zugehörigen API Objekte ohne sie zu erstellen.
    		kubectl run nginx --image=nginx --dry-run
    
    		# Starte eine einzelne Instanz von nginx, aber überlade die Spec des Deployments mit einer Teilmenge von JSON-Werten.
    		kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'
    
    		# Starte einen busybox Pod und lass ihn im Vordergrund laufen; starte ihn nicht neu, wenn er existiert.
    		kubectl run -i -t busybox --image=busybox --restart=Never
    
    		# Starte einen nginx-Container mit dem Standardkommando, aber übergebe die Parameter (arg1 .. argN) an das Kommando.
    		kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>
    
    		# Starte den nginx-Container mit einem anderen Kommando und Parametern.
    		kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>
    
    		# Starte den perl-Container, um π auf 2000 Stellen zu berechnen und gib es aus.
    		kubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'
    
    		# Starte den cron-Job, um π auf 2000 Stellen zu berechnen und gib sie alle 5 Minuten aus.
    		kubectl run pi --schedule="0/5 * * * ?" --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'

en: 
    		# Update node 'foo' with a taint with key 'dedicated' and value 'special-user' and effect 'NoSchedule'.
    		# If a taint with that key and effect already exists, its value is replaced as specified.
    		kubectl taint nodes foo dedicated=special-user:NoSchedule
    
    		# Remove from node 'foo' the taint with key 'dedicated' and effect 'NoSchedule' if one exists.
    		kubectl taint nodes foo dedicated:NoSchedule-
    
    		# Remove from node 'foo' all the taints with key 'dedicated'
    		kubectl taint nodes foo dedicated-
de_DE: 
    		# Aktualisiere Knoten 'foo' mit einem Taint mit dem Key 'dedicated', dem Value 'special-user' und dem Effect 'NoSchedule'.
    		# Wenn ein Taint mit dem Key und Effect schon existiert, wird sein Value mit den gegebenen Werten ersetzt.
    		kubectl taint nodes foo dedicated=special-user:NoSchedule
    
    		# Entferne vom Knoten 'foo' den Taint mit dem Key 'dedicated' und dem Effect 'NoSchedule', wenn er existiert.
    		kubectl taint nodes foo dedicated:NoSchedule-
    
    		# Entferne vom Knoten 'foo' alle Tains mit dem Key 'dedicated'
    		kubectl taint nodes foo dedicated-

en: 
    		# Update pod 'foo' with the label 'unhealthy' and the value 'true'.
    		kubectl label pods foo unhealthy=true
    
    		# Update pod 'foo' with the label 'status' and the value 'unhealthy', overwriting any existing value.
    		kubectl label --overwrite pods foo status=unhealthy
    
    		# Update all pods in the namespace
    		kubectl label pods --all status=unhealthy
    
    		# Update a pod identified by the type and name in "pod.json"
    		kubectl label -f pod.json status=unhealthy
    
    		# Update pod 'foo' only if the resource is unchanged from version 1.
    		kubectl label pods foo status=unhealthy --resource-version=1
    
    		# Update pod 'foo' by removing a label named 'bar' if it exists.
    		# Does not require the --overwrite flag.
    		kubectl label pods foo bar-
de_DE: 
    		# Aktualisiere den Pod 'foo' mit dem Label 'unhealthy' und dem Value 'true'.
    		kubectl label pods foo unhealthy=true
    
    		# Aktualisiere den Pod 'foo' mit dem Label 'status' und dem Value 'unhealthy' und überschreibe alle bisherigen Values.
    		kubectl label --overwrite pods foo status=unhealthy
    
    		# Aktualisiere alle Pods im Namespace
    		kubectl label pods --all status=unhealthy
    
    		# Aktualisiere den Pod mit type und name aus "pod.json"
    		kubectl label -f pod.json status=unhealthy
    
    		# Aktualisiere den Pod 'foo', wenn die Resource sich nicht von version 1 unterscheidet.
    		kubectl label pods foo status=unhealthy --resource-version=1
    
    		# Aktualisiere den Pod 'foo', indem das Label 'bar' gelöscht wird, wenn es existiert.
    		# Benötigt kein --overwrite flag.
    		kubectl label pods foo bar-

en: 
    		# Update pods of frontend-v1 using new replication controller data in frontend-v2.json.
    		kubectl rolling-update frontend-v1 -f frontend-v2.json
    
    		# Update pods of frontend-v1 using JSON data passed into stdin.
    		cat frontend-v2.json | kubectl rolling-update frontend-v1 -f -
    
    		# Update the pods of frontend-v1 to frontend-v2 by just changing the image, and switching the
    		# name of the replication controller.
    		kubectl rolling-update frontend-v1 frontend-v2 --image=image:v2
    
    		# Update the pods of frontend by just changing the image, and keeping the old name.
    		kubectl rolling-update frontend --image=image:v2
    
    		# Abort and reverse an existing rollout in progress (from frontend-v1 to frontend-v2).
    		kubectl rolling-update frontend-v1 frontend-v2 --rollback
de_DE: 
    		# Aktualisiere die Pods in frontend-v1 mit den neuen Replication-Controller Daten in frontend-v2.json.
    		kubectl rolling-update frontend-v1 -f frontend-v2.json
    
    		# Aktualisiere die Pods in frontend-v1 mit den JSON-Daten von stdin.
    		cat frontend-v2.json | kubectl rolling-update frontend-v1 -f -
    
    		# Aktualisiere die Pods von frontend-v1 auf frontend-v2, indem das Image geändert wird und
    		# der Name des ReplicationControllers.
    		kubectl rolling-update frontend-v1 frontend-v2 --image=image:v2
    
    		# Aktualisiere die Pods in frontend, indem das Image geändert, aber der alte Name beibehalten wird.
    		kubectl rolling-update frontend --image=image:v2
    
    		# Breche ein laufendes Rollout (von frontend-v1 zu frontend-v2) ab und mache es rückgängig.
    		kubectl rolling-update frontend-v1 frontend-v2 --rollback

en: 
    		# View the last-applied-configuration annotations by type/name in YAML.
    		kubectl apply view-last-applied deployment/nginx
    
    		# View the last-applied-configuration annotations by file in JSON
    		kubectl apply view-last-applied -f deploy.yaml -o json
de_DE: 
    		# Zeige die Annotation Last-Applied-Configuration mit type/name in YAML an.
    		kubectl apply view-last-applied deployment/nginx
    
    		# Zeige die Annotation Last-applied-configuration mit der Datei in JSON an
    		kubectl apply view-last-applied -f deploy.yaml -o json

en: 
    		Apply a configuration to a resource by filename or stdin.
    		This resource will be created if it doesn't exist yet.
    		To use 'apply', always create the resource initially with either 'apply' or 'create --save-config'.
    
    		JSON and YAML formats are accepted.
    
    		Alpha Disclaimer: the --prune functionality is not yet complete. Do not use unless you are aware of what the current state is. See https://issues.k8s.io/34274.
de_DE: 
    		Wende eine Konfiguration auf eine Resource mit Dateinamen oder stdin an.
    		Die Resource wird erstellt, wenn sie noch nicht existiert.
    		Um 'apply' zu benutzen, muss die Resource initital mit 'apply' oder 'create --save-config' erstellt werden.
    
    		JSON- und YAML-Formate werden akzeptiert.
    
    		Alpha Disclaimer: Die --prune Funktion ist noch nicht fertig. Benutze sie nicht, wenn der aktuelle Zustand nicht bekannt ist. Siehe https://issues.k8s.io/34274.

en: 
    		Convert config files between different API versions. Both YAML
    		and JSON formats are accepted.
    
    		The command takes filename, directory, or URL as input, and convert it into format
    		of version specified by --output-version flag. If target version is not specified or
    		not supported, convert to latest version.
    
    		The default output will be printed to stdout in YAML format. One can use -o option
    		to change to output destination.
de_DE: 
    		Konvertiere Konfigurationsdateien zwischen API Versionen. Sowohl YAML-
    		alsauch JSON-Formate werden akzeptiert.
    
    		Der Befehlt akzeptiert Dateinamen, Ordner  oder URL als Parameter und konvertiert es ins Format
    		der mit --output-version gegebenen Version. Wenn die Zielversion nicht 
    		angegeben wird oder ungültig ist, wird die neueste Version verwendet.
    
    		Die Standardausgabe wird auf stdout im YAML-Format ausgegeben. Man kann die Option -o verwenden,
    		um das Ausgabeziel festzulegen.

en: 
    		Create a ClusterRole.
de_DE: 
    		Erstelle eine ClusterRole.

en: 
    		Create a ClusterRoleBinding for a particular ClusterRole.
de_DE: 
    		Erstelle ein ClusterRoleBinding für eine bestimmte ClusterRole.

en: 
    		Create a RoleBinding for a particular Role or ClusterRole.
de_DE: 
    		Erstelle ein RoleBinding für eine bestimmte ClusterRole.

en: 
    		Create a TLS secret from the given public/private key pair.
    
    		The public/private key pair must exist before hand. The public key certificate must be .PEM encoded and match the given private key.
de_DE: 
    		Erstelle ein TLS-Secret vom gegebenen Public/Private-Schlüsselpaar.
    
    		Das Public/Private-Schlüsselpaar muss vorab bestehen. Das Public-Key-Zertifikat muss im PEM-Format sein und zum gegebenen Private-Key passen.

en: 
    		Create a configmap based on a file, directory, or specified literal value.
    
    		A single configmap may package one or more key/value pairs.
    
    		When creating a configmap based on a file, the key will default to the basename of the file, and the value will
    		default to the file content.  If the basename is an invalid key, you may specify an alternate key.
    
    		When creating a configmap based on a directory, each file whose basename is a valid key in the directory will be
    		packaged into the configmap.  Any directory entries except regular files are ignored (e.g. subdirectories,
    		symlinks, devices, pipes, etc).
de_DE: 
    		Erstelle eine ConfigMap basierend auf einer Datei, einem Order oder einem gegebenen Wert.
    
    		Eine einzelne ConfigMap kann eins oder mehr Key/Value-Paare beinhalten.
    
    		Wenn man eine ConfigMap von einer Datei erstellt, wird der Key standardmäßig der Name der Datei, und der Wert wird
    		standardmäßig der Dateiinhalt. Wenn der Dateiname ein ungültiger Key ist, kann ein anderer Key angegeben werden.
    
    		Wenn man eine ConfigMap von einem Ordner erstellt, wird jede Datei, deren Name ein gültiger Key ist
    		in die ConfigMap aufgenommen. Jegliche Einträge im Ordner, die keine regulären Dateien sind, werden ignoriert (z.B. SubDirectories, 
    		SymLinks, Devices, Pipes, usw).

en: 
    		Create a namespace with the specified name.
de_DE: 
    		Erstelle einen Namespace mit dem gegebenen Namen.

en: 
    		Create a new secret for use with Docker registries.
    
    		Dockercfg secrets are used to authenticate against Docker registries.
    
    		When using the Docker command line to push images, you can authenticate to a given registry by running
    
    		    $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.
    
        That produces a ~/.dockercfg file that is used by subsequent 'docker push' and 'docker pull' commands to
    		authenticate to the registry. The email address is optional.
    
    		When creating applications, you may have a Docker registry that requires authentication.  In order for the
    		nodes to pull images on your behalf, they have to have the credentials.  You can provide this information
    		by creating a dockercfg secret and attaching it to your service account.
de_DE: 
    		Erstelle ein Secret für die Benutzung mit Docker-Registries.
    
    		Dockercfg Secrets werden für die Authentifizierung bei Docker-Registries benutzt.
    
    		Wenn die Docker-command -line zum pushen von Images benutzt wird, kann man sich bei einer gegebenen Registry authentifizieren mit
    
    		    $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.
    
        Dies produziert eine ~/.dockercfg Datei, die für folgende 'docker push' und 'docker pull' Befehle genutzt wird,
    		um sich an der Registry zu authentifizieren. Die E-Mail-Adresse ist optional.
    
    		Bei der Erstellung von Applikationen, kann eine Docker-Registry eine Authentifizierung verlangen. Damit
    		deine Knoten in deinem Namen Images herunterladen können, benötigen sie die Credentials.  Man kann diese Information bereitstellen
    		indem man ein dockercfg secret erstellt und zu seinem ServiceAccount hinzufügt.

en: 
    		Create a pod disruption budget with the specified name, selector, and desired minimum available pods
de_DE: 
    		Erstelle ein Pod-Disruption-Budget mit dem gegebenen name, selector und der gewünschten Mindestanzahl verfügbarer Pods

en: 
    		Create a resource by filename or stdin.
    
    		JSON and YAML formats are accepted.
de_DE: 
    		Erstelle eine Resource mit Dateinamen oder stdin.
    
    		JSON- und YAML-Formate werden akzeptiert.

en: 
    		Create a resourcequota with the specified name, hard limits and optional scopes
de_DE: 
    		Erstelle eine ResourceQuota mit dem gegebenen name, hard limits und optional scopes

en: 
    		Create a role with single rule.
de_DE: 
    		Erstelle eine Role mit einer einzelnen Rule.

en: 
    		Create a secret based on a file, directory, or specified literal value.
    
    		A single secret may package one or more key/value pairs.
    
    		When creating a secret based on a file, the key will default to the basename of the file, and the value will
    		default to the file content.  If the basename is an invalid key, you may specify an alternate key.
    
    		When creating a secret based on a directory, each file whose basename is a valid key in the directory will be
    		packaged into the secret.  Any directory entries except regular files are ignored (e.g. subdirectories,
    		symlinks, devices, pipes, etc).
de_DE: 
    		Erstelle ein Secret basierend auf einer Datei, einem Ordner oder einem gegebenen Wert.
    
    		Ein einzelnes Secret kann eins oder mehr Key/Value-Paare beinhalten.
    
    		Wenn man ein Secret von einer Datei erstellt, wird der Key standardmäßig der Name der Datei, und der Wert wird
    		standardmäßig der Dateiinhalt. Wenn der Dateiname ein ungültiger Key ist, kann ein anderer Key angegeben werden.
    
    		Wenn man ein Secret von einem Ordner erstellt, wird jede Datei, deren Name ein gültiger Key ist
    		in das Secret aufgenommen. Jegliche Einträge im Ordner, die keine regulären Dateien sind, werden ignoriert (z.B. SubDirectories, 
    		SymLinks, Devices, Pipes, usw).

en: 
    		Create a service account with the specified name.
de_DE: 
    		Erstelle einen ServiceAccount mit dem gegebenen Namen.

en: 
    		Create and run a particular image, possibly replicated.
    
    		Creates a deployment or job to manage the created container(s).
de_DE: 
    		Erstelle und starte ein bestimmtes Image, möglicherweise repliziert.
    
    		Erstellt ein Deployment oder Job, um den/die erstellten Container zu verwalten.

en: 
    		Creates an autoscaler that automatically chooses and sets the number of pods that run in a kubernetes cluster.
    
    		Looks up a Deployment, ReplicaSet, or ReplicationController by name and creates an autoscaler that uses the given resource as a reference.
    		An autoscaler can automatically increase or decrease number of pods deployed within the system as needed.
de_DE: 
    		Erstellt einen AutoScaler der die Anzahl der Pods, die im Kubernetes-Cluster laufen, automatisch wählt und anpasst.
    
    		Sucht ein Deployment, ReplicaSet oder ReplicationController mit Namen name und erstellt einen AutoScaler, der die Resource als Referenz nimmt.
    		Ein AutoScaler kann die Anzahl der im System deployten Pods nach Bedarf erhöhen oder verringern.

en: 
    		Delete resources by filenames, stdin, resources and names, or by resources and label selector.
    
    		JSON and YAML formats are accepted. Only one type of the arguments may be specified: filenames,
    		resources and names, or resources and label selector.
    
    		Some resources, such as pods, support graceful deletion. These resources define a default period
    		before they are forcibly terminated (the grace period) but you may override that value with
    		the --grace-period flag, or pass --now to set a grace-period of 1. Because these resources often
    		represent entities in the cluster, deletion may not be acknowledged immediately. If the node
    		hosting a pod is down or cannot reach the API server, termination may take significantly longer
    		than the grace period. To force delete a resource,	you must pass a grace	period of 0 and specify
    		the --force flag.
    
    		IMPORTANT: Force deleting pods does not wait for confirmation that the pod's processes have been
    		terminated, which can leave those processes running until the node detects the deletion and
    		completes graceful deletion. If your processes use shared storage or talk to a remote API and
    		depend on the name of the pod to identify themselves, force deleting those pods may result in
    		multiple processes running on different machines using the same identification which may lead
    		to data corruption or inconsistency. Only force delete pods when you are sure the pod is
    		terminated, or if your application can tolerate multiple copies of the same pod running at once.
    		Also, if you force delete pods the scheduler may place new pods on those nodes before the node
    		has released those resources and causing those pods to be evicted immediately.
    
    		Note that the delete command does NOT do resource version checks, so if someone
    		submits an update to a resource right when you submit a delete, their update
    		will be lost along with the rest of the resource.
de_DE: 
    		Löscht die Resourcen mit Dateinamen, stdin, resources- und names- oder mit resources- und label-Selektor.
    
    		JSON- und YAML-Formate werden akzeptiert. Nur einer der Parameter darf verwendet werden: Dateiname,
    		resources- und names-, oder resources- und label-Selektor.
    
    		Manche Resourcen, zum Beispiel Pods, unterstützen graziöses Löschen. Sie definieren einen Standardzeitraum
    		bevor das Löschen erzwungen wird (grace-period), aber dieser Wert kann überschrieben werden mit
    		der --grace-period Option, oder mit --now, das die grace-period auf 1 setzt. Da diese Resourcen
    		häufig Einheiten im Cluster sind, kann das Löschen nicht immer direkt bestätigt werden. Wenn der Knoten
    		auf dem der Pod läuft nicht verfügbar ist, oder den API Server nicht erreichen kann, kann das Löschen bedeutend länger dauern
    		als die grace-period. Um das Löschen zu erzwingen, muss eine grace-period von 0 übergeben werden
    		und die --force Option gesetzt sein.
    
    		WICHTIG: Ein erzwungenes Löschen wartet nicht auf die Bestätigung, dass der Prozess
    		beendet wurde, was den Prozess am Leben erhalten kann, bis der Knoten die Löschung erkennt
    		und das graziöse Löschen beendet. Wenn Prozesse Shared-Storage oder eine Remote-API verwenden und
    		den Namen des Pods brauchen, um sich selbst zu identifizieren, kann das erzwungene Löschen dazu führen, dass
    		mehrere Prozesse auf der gleichen Maschine die gleiche Identität verwenden, was zu
    		Datenkorruption oder Inkonsistenz führen kann. Erzwinge nur ein Löschen, wenn sichergestellt ist, dass der Pod
    		gelöscht ist, oder wenn die Anwendung mehrere gleichzeitig laufende Kopien verarbeiten kann.
    		Außerdem kann es passieren, dass der Scheduler neue Pods auf dem Knoten plaziert, bevor der Knoten
    		die Resourcen freigegeben hat, sodass diese Pods direkt entfernt werden.
    
    		Berücksichtige außerdem, dass der Delete-Befehl KEINE versionen prüft, sodass, wenn jemand
    		ein Update einer Resource gleichzeitig mit Deinem delete anstößt, dessen Update
    		mit dem Rest der Resource entfernt wird.

en: 
    		Deprecated: Gracefully shut down a resource by name or filename.
    
    		The stop command is deprecated, all its functionalities are covered by delete command.
    		See 'kubectl delete --help' for more details.
    
    		Attempts to shut down and delete a resource that supports graceful termination.
    		If the resource is scalable it will be scaled to 0 before deletion.
de_DE: 
    		Veraltet: Fahre eine Resource mit Namen oder Dateinamen graziös heruter.
    
    		Der Stop-Befehl ist veraltet und alle Funktioneren werden mit dem Delete-Befehl abgedeckt.
    		Siehe 'kubectl delete --help' für mehr Details.
    
    		Versucht eine Resource, die graziöses Löschen unterstützt, herunterzufahren und zu löschen.
    		Wenn die Resource skaliert werden kann, wird sie vor dem Löschen auf 0 skaliert.

en: 
    		Display Resource (CPU/Memory/Storage) usage of nodes.
    
    		The top-node command allows you to see the resource consumption of nodes.
de_DE: 
    		Zeigt die Resourcennutzung (CPU/Memory/Storage) von Knoten.
    
    		Der top-node-Befehl erlaubt es, die Resourcennutzung von Knoten zu betrachten.

en: 
    		Display Resource (CPU/Memory/Storage) usage of pods.
    
    		The 'top pod' command allows you to see the resource consumption of pods.
    
    		Due to the metrics pipeline delay, they may be unavailable for a few minutes
    		since pod creation.
de_DE: 
    		Zeigt die Resourcennutzung (CPU/Memory/Storage) von Pods.
    
    		Der 'top pod'-Befehl erlaubt es, die Resourcennutzung von Pods zu betrachten.
    
    		Aufgrund der Metrik-Pipeline-Verzögerung, können sie für ein paar Minuten nicht verfügbar sein,
    		nach der Pod-Erstellung.

en: 
    		Display Resource (CPU/Memory/Storage) usage.
    
    		The top command allows you to see the resource consumption for nodes or pods.
    
    		This command requires Heapster to be correctly configured and working on the server.
de_DE: 
    		Zeige Resourcennutzung (CPU/Memory/Storage).
    
    		Der top-Befehl erlaubt es, die Resourcennutzung von Knoten oder Pods zu betrachten.
    
    		Dieser Befehl benötigt eine korrekt konfigurierte und funktionierende Heapster-Installation auf dem Server.

en: 
    		Drain node in preparation for maintenance.
    
    		The given node will be marked unschedulable to prevent new pods from arriving.
    		'drain' evicts the pods if the APIServer supports eviction
    		(http://kubernetes.io/docs/admin/disruptions/). Otherwise, it will use normal DELETE
    		to delete the pods.
    		The 'drain' evicts or deletes all pods except mirror pods (which cannot be deleted through
    		the API server).  If there are DaemonSet-managed pods, drain will not proceed
    		without --ignore-daemonsets, and regardless it will not delete any
    		DaemonSet-managed pods, because those pods would be immediately replaced by the
    		DaemonSet controller, which ignores unschedulable markings.  If there are any
    		pods that are neither mirror pods nor managed by ReplicationController,
    		ReplicaSet, DaemonSet, StatefulSet or Job, then drain will not delete any pods unless you
    		use --force.  --force will also allow deletion to proceed if the managing resource of one
    		or more pods is missing.
    
    		'drain' waits for graceful termination. You should not operate on the machine until
    		the command completes.
    
    		When you are ready to put the node back into service, use kubectl uncordon, which
    		will make the node schedulable again.
    
    		![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)
de_DE: 
    		Leere Knoten, um eine Wartung vorzubereiten.
    
    		Der gegebene Knoten wird als unschedulable markiert, um die Zuordnung von neuen Pods zu verhindern.
    		'drain' entfernt den Pod, falls der API-Server die Entfernung unterstützt
    		(http://kubernetes.io/docs/admin/disruptions/). Wenn nicht, wird ein normales DELETE verwendet,
    		um die Pods zu löschen.
    		'drain' entfernt oder löscht alle Pods mit der Ausnahme von Mirror-Pods (welche vom API Server nicht gelöscht werden können)
    		Wenn DaemonSet-verwaltete Pods existieren, wird 'drain' nicht fortgesetzt
    		ohne die --ignore-daemonsets Option, und es wird in keinem Fall
    		DaemonSet-verwaltete Pods löschen, weil diese Pods direkt ersetzt würden durch den
    		DaemonSet-Controller, der unschedulable Markierungen ignoriert.  Wenn es irgendwelche
    		Pods gibt, die weder Mirror-Pods sind, noch von einem ReplicationController,
    		ReplicaSet, DaemonSet, StatefulSet oder Job verwaltet werden, wird drain keine Pods löschen, außer die
    		--force Option ist gesetzt.  --force lässt das Löschen selbst zu, wenn die verwaltende Resource von einem
    		oder mehreren Pods fehlt.
    
    		'drain' wartet auf eine graziöse Löschung. Man sollte auf der Maschine nichts tun, während
    		der Befehl läuft.
    
    		Wenn der Knoten wieder bereit ist die Arbeit aufzunehmen, benutze kubectl uncordon,
    		was den Knoten als schedulable markiert.
    
    		![Workflow](http://kubernetes.io/images/docs/kubectl_drain.svg)

en: 
    		Edit a resource from the default editor.
    
    		The edit command allows you to directly edit any API resource you can retrieve via the
    		command line tools. It will open the editor defined by your KUBE_EDITOR, or EDITOR
    		environment variables, or fall back to 'vi' for Linux or 'notepad' for Windows.
    		You can edit multiple objects, although changes are applied one at a time. The command
    		accepts filenames as well as command line arguments, although the files you point to must
    		be previously saved versions of resources.
    
    		Editing is done with the API version used to fetch the resource.
    		To edit using a specific API version, fully-qualify the resource, version, and group.
    
    		The default format is YAML. To edit in JSON, specify "-o json".
    
    		The flag --windows-line-endings can be used to force Windows line endings,
    		otherwise the default for your operating system will be used.
    
    		In the event an error occurs while updating, a temporary file will be created on disk
    		that contains your unapplied changes. The most common error when updating a resource
    		is another editor changing the resource on the server. When this occurs, you will have
    		to apply your changes to the newer version of the resource, or update your temporary
    		saved copy to include the latest resource version.
de_DE: 
    		Bearbeite eine Resource mit dem Standardeditor.
    
    		Der edit-Befehl erlaubt es jede API Resource direkt zu bearbeiten, wenn sie mit den
    		Command-Line-Tools erreichbar ist. Er öffnet den Editor, der in der KUBE_EDITOR oder EDITOR
    		Umgebunsvariable festgelegt ist, oder 'vi' auf Linux und 'notepad' auf Windows.
    		Es ist möglich mehrere Objekte zu bearbeiten, aber die Änderungen werden nacheinander angewendet. Der Befehl
    		akzeptiert Dateinamen und Command-Line-Parameter, aber die verwendeten Dateien müssen
    		vorab gespeicherte Versionen von Resourcen sein.
    
    		Die Bearbeitung verwendet die API Version, die genutzt wurde, um die Resource zu lesen.
    		Um eine spezifische API Version zu verwenden, muss die vollständige Resource, Version und Group angegeben werden.
    
    		Das Standardformat ist YAML. Um mit JSON zu arbeiten, setze "-o json".
    
    		Die Option --windows-line-endings kann benutzt werden, um Windows Zeilen-umbrüche zu verwenden,
    		ansonsten wird der Standard des Betriebssystems verwendet.
    
    		Falls beim Update ein Fehler auftritt, wird eine temporäre Datei auf der Festplatte angelegt,
    		die die nicht verarbeiteten Änderungen enthält. Der häufigste Fehler beim Bearbeiten einer Resource
    		ist ein anderer Editor, der die Resource auf dem Server ändert. Wenn das auftritt, muss man
    		seine Änderungen auf die neue Version anwenden oder seine temporäre
    		gespeicherte Kopie mit der neuesten Resourcenversion aktualisieren.

en: 
    		Mark node as schedulable.
de_DE: 
    		Markiere Knoten als schedulable.

en: 
    		Mark node as unschedulable.
de_DE: 
    		Markiere Knoten als unschedulable.

en: 
    		Output shell completion code for the specified shell (bash or zsh).
    		The shell code must be evaluated to provide interactive
    		completion of kubectl commands.  This can be done by sourcing it from
    		the .bash_profile.
    
    		Note: this requires the bash-completion framework, which is not installed
    		by default on Mac.  This can be installed by using homebrew:
    
    		    $ brew install bash-completion
    
    		Once installed, bash_completion must be evaluated.  This can be done by adding the
    		following line to the .bash_profile
    
    		    $ source $(brew --prefix)/etc/bash_completion
    
    		Note for zsh users: [1] zsh completions are only supported in versions of zsh >= 5.2
de_DE: 
    		Gibt den Shell-Completion-Code für die angegebene Shell aus (bash oder zsh).
    		Der Shell-Code muss für eine interaktive Vervollständigung von kubectl 
    		ausgewertet werden. Das ist möglich, indem man
    		die .bash_profile Datei sourcet.
    
    		Hinweis: Dies setzt das Bash-Completion-Framework voraus, das auf dem Mac nicht standardmäßig installiert ist. 
    		Es kann mit homebrew installiert werden:
    
    		    $ brew install bash-completion
    
    		Sobald es installiert ist, muss bash_completion ausgewertet werden. Dies wird erreicht, indem man
    		die folgende Zeile zur .bash_profile-Datei hinzufügt
    
    		    $ source $(brew --prefix)/etc/bash_completion
    
    		Hinweis für zsh Nutzer: [1] zsh completions werden nur in Versionen von zsh >= 5.2 unterstützt

en: 
    		Perform a rolling update of the given ReplicationController.
    
    		Replaces the specified replication controller with a new replication controller by updating one pod at a time to use the
    		new PodTemplate. The new-controller.json must specify the same namespace as the
    		existing replication controller and overwrite at least one (common) label in its replicaSelector.
    
    		![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate.svg)
de_DE: 
    		Führe ein Rolling-Update des gegebenen ReplicationControllers aus.
    
    		Ersetzt den gegebenen ReplicationController mit einem neuen Replication-Controller, indem die neue PodTampleta Pod für Pod
    		angewendet wird. Die new-controller.json muss den gleichen Namespace wie
    		der aktuelle ReplicationController besitzen und mindestens ein gemeinsames Label im ReplicaSelector überschreiben.
    
    		![Workflow](http://kubernetes.io/images/docs/kubectl_rollingupdate.svg)

en: 
    		Replace a resource by filename or stdin.
    
    		JSON and YAML formats are accepted. If replacing an existing resource, the
    		complete resource spec must be provided. This can be obtained by
    
    		    $ kubectl get TYPE NAME -o yaml
    
    		Please refer to the models in https://htmlpreview.github.io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html to find if a field is mutable.
de_DE: 
    		Ersetze eine Resource mit Dateinamen oder stdin.
    
    		JSON- and YAML-Formate werden akzeptiert. Wenn eine existierende Resource ersetzt wird,
    		muss die vollständige spSpecec mitgegeben werden. Diese kann hiermit ausgelesen werden
    
    		    $ kubectl get TYPE NAME -o yaml
    
    		Bitte konsultiere https://htmlpreview.github.io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html um zu erfahren, ob ein Feld verändert werden darf.

en: 
    		Set a new size for a Deployment, ReplicaSet, Replication Controller, or Job.
    
    		Scale also allows users to specify one or more preconditions for the scale action.
    
    		If --current-replicas or --resource-version is specified, it is validated before the
    		scale is attempted, and it is guaranteed that the precondition holds true when the
    		scale is sent to the server.
de_DE: 
    		Setze eine neue Größe für ein Deployment, ReplicaSet, Replication-Contoller oder Job.
    
    		Scale erlaubt es Nutzern eine oder mehr Voraussetzungen für die Aktion festzulegen.
    
    		Wenn --current-replicas oder --resource-version gegeben ist, wird es validiert, bevor
    		scale versucht wird, und es wird garantiert, dass die Voraussetzungen erfüllt sind, wenn
    		scale zum Server geschickt wird.

en: 
    		Set the latest last-applied-configuration annotations by setting it to match the contents of a file.
    		This results in the last-applied-configuration being updated as though 'kubectl apply -f <file>' was run,
    		without updating any other parts of the object.
de_DE: 
    		Setze die aktuelle Annotation Last-Applied-Configuration auf den Inhalt der Datei.
    		Das bedeutet, dass Last-Applied-Configuration aktualisiert wird, als ob 'kubectl apply -f <file>' ausgeführt wurde,
    		ohne andere Teile des Objekts zu aktualisieren.

en: 
    		To proxy all of the kubernetes api and nothing else, use:
    
    		    $ kubectl proxy --api-prefix=/
    
    		To proxy only part of the kubernetes api and also some static files:
    
    		    $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/
    
    		The above lets you 'curl localhost:8001/api/v1/pods'.
    
    		To proxy the entire kubernetes api at a different root, use:
    
    		    $ kubectl proxy --api-prefix=/custom/
    
    		The above lets you 'curl localhost:8001/custom/api/v1/pods'
de_DE: 
    		Proxy alle Teile der Kubernetes-API und sonst nichts:
    
    		    $ kubectl proxy --api-prefix=/
    
    		Proxy nur bestimmte Teile der Kubernetes-API und einige statische Dateien:
    
    		    $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/
    
    		Der Befehl oben lässt dich 'curl localhost:8001/api/v1/pods' aufrufen.
    
    		Proxy alle Teile der Kubernetes-API auf einem anderen root:
    
    		    $ kubectl proxy --api-prefix=/custom/
    
    		Der Befehl oben lässt dich 'curl localhost:8001/custom/api/v1/pods' aufrufen

en: 
    		Update field(s) of a resource using strategic merge patch
    
    		JSON and YAML formats are accepted.
    
    		Please refer to the models in https://htmlpreview.github.io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html to find if a field is mutable.
de_DE: 
    		Aktualisiere Felder einer Resource mit einem Strategic-Merge-Patch
    
    		JSON- und YAML-Formate werden akzeptiert.
    
    		Bitte konsultiere https://htmlpreview.github.io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html um zu erfahren, ob ein Feld mutable ist.

en: 
    	  # Create a new TLS secret named tls-secret with the given key pair:
    	  kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/to/tls.key
de_DE: 
    	  # Erstelle ein neues TLS Secret tl-secret mit dem gegebenen Schlüsselpaar:
    	  kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/to/tls.key

en: 
    	  # Create a new namespace named my-namespace
    	  kubectl create namespace my-namespace
de_DE: 
    	  # Erstelle einen neuen Namespace my-namespace
    	  kubectl create namespace my-namespace

en: 
    	  # Create a new secret named my-secret with keys for each file in folder bar
    	  kubectl create secret generic my-secret --from-file=path/to/bar
    
    	  # Create a new secret named my-secret with specified keys instead of names on disk
    	  kubectl create secret generic my-secret --from-file=ssh-privatekey=~/.ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub
    
    	  # Create a new secret named my-secret with key1=supersecret and key2=topsecret
    	  kubectl create secret generic my-secret --from-literal=key1=supersecret --from-literal=key2=topsecret
de_DE: 
    	  # Erstelle ein neues Secret my-secret mit einem Key für jede Datei im Ordner bar
    	  kubectl create secret generic my-secret --from-file=path/to/bar
    
    	  # Erstelle ein neues Secret my-secret mit den gegebenen Keys statt der Namen auf der Festplatte
    	  kubectl create secret generic my-secret --from-file=ssh-privatekey=~/.ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub
    
    	  # Erstelle ein neues Scret my-secret mit key1=supersecret und key2=topsecret
    	  kubectl create secret generic my-secret --from-literal=key1=supersecret --from-literal=key2=topsecret

en: 
    	  # Create a new service account named my-service-account
    	  kubectl create serviceaccount my-service-account
de_DE: 
    	  # Erstelle einen neuen ServiceAccount my-service-account
    	  kubectl create serviceaccount my-service-account

en: 
    	# Create a new ExternalName service named my-ns 
    	kubectl create service externalname my-ns --external-name bar.com
de_DE: 
    	# Erstelle einen neuen ExternalName-Service my-ns 
    	kubectl create service externalname my-ns --external-name bar.com

en: 
    	Create an ExternalName service with the specified name.
    
    	ExternalName service references to an external DNS address instead of
    	only pods, which will allow application authors to reference services
    	that exist off platform, on other clusters, or locally.
de_DE: 
    	Erstelle einen ExternalName-Service mit den gegebenen Namen.
    
    	ExternalName service referenziert eine externe DNS Adresse statt
    	eines pods, was Anwendungsautoren erlaubt, einen Service zu referenzieren,
    	der abseits der Platform, auf anderen Clustern oder lokal exisiert.

en: 
    	Help provides help for any command in the application.
    	Simply type kubectl help [path to command] for full details.
de_DE: 
    	Help hilft bei jedem Befehl in der Anwendung.
    	Gib einfach kubectl help [path to command] für alle Details ein.

en: 
        # Create a new LoadBalancer service named my-lbs
        kubectl create service loadbalancer my-lbs --tcp=5678:8080
de_DE: 
        # Erstelle einen neuen LoadBalancer-Service my-lbs
        kubectl create service loadbalancer my-lbs --tcp=5678:8080

en: 
        # Create a new clusterIP service named my-cs
        kubectl create service clusterip my-cs --tcp=5678:8080
    
        # Create a new clusterIP service named my-cs (in headless mode)
        kubectl create service clusterip my-cs --clusterip="None"
de_DE: 
        # Erstelle einen neuen ClusterIP-Service my-cs
        kubectl create service clusterip my-cs --tcp=5678:8080
    
        # Erstelle einen neuen ClusterIP-Service my-cs (im headless-Modus)
        kubectl create service clusterip my-cs --clusterip="None"

en: 
        # Create a new deployment named my-dep that runs the busybox image.
        kubectl create deployment my-dep --image=busybox
de_DE: 
        # Erstelle ein neues Deployment my-dep, dass das busybox-Image nutzt.
        kubectl create deployment my-dep --image=busybox

en: 
        # Create a new nodeport service named my-ns
        kubectl create service nodeport my-ns --tcp=5678:8080
de_DE: 
        # Erstelle einen neuen NodePort-Service my-ns
        kubectl create service nodeport my-ns --tcp=5678:8080

en: 
        # Dump current cluster state to stdout
        kubectl cluster-info dump
    
        # Dump current cluster state to /path/to/cluster-state
        kubectl cluster-info dump --output-directory=/path/to/cluster-state
    
        # Dump all namespaces to stdout
        kubectl cluster-info dump --all-namespaces
    
        # Dump a set of namespaces to /path/to/cluster-state
        kubectl cluster-info dump --namespaces default,kube-system --output-directory=/path/to/cluster-state
de_DE: 
        # Schreibe den aktuellen Cluster-Zustand auf stdout
        kubectl cluster-info dump
    
        # Schreibe aktuellen Cluster-Zustand in /path/to/cluster-state
        kubectl cluster-info dump --output-directory=/path/to/cluster-state
    
        # Schreibe alle Namespaces auf stdout
        kubectl cluster-info dump --all-namespaces
    
        # Schreibe eine Menge an Namespaces in /path/to/cluster-state
        kubectl cluster-info dump --namespaces default,kube-system --output-directory=/path/to/cluster-state

en: 
        Create a LoadBalancer service with the specified name.
de_DE: 
        Erstelle einen LoadBalancer-Service mit dem gegebenen Namen.

en: 
        Create a clusterIP service with the specified name.
de_DE: 
        Erstelle einen ClusterIP-Service mit dem gegebenen Namen.

en: 
        Create a deployment with the specified name.
de_DE: 
        Erstelle ein Deployment mit dem gegebenen Namen.

en: 
        Create a nodeport service with the specified name.
de_DE: 
        Erstelle einen NodePort-Service mit dem gegebenen Namen.

en: 
      Display addresses of the master and services with label kubernetes.io/cluster-service=true
      To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
de_DE: 
      Zeigt Adressen des Master und von Services mit Label kubernetes.io/cluster-service=true
      Für das weitere Debugging und die Diagnose von Clusterproblemen nutze 'kubectl cluster-info dump'.

en: A comma-delimited set of quota scopes that must all match each object tracked by the quota.
de_DE: Eine komma-separierte Menge von Quota-Scopes, die zu jedem Object passen muss, dass von der Quota betroffen ist.

en: A comma-delimited set of resource=quantity pairs that define a hard limit.
de_DE: Eine komma-separierte Menge von resource=quantity Paaren, die ein hartes Limit definieren.

en: A label selector to use for this budget. Only equality-based selector requirements are supported.
de_DE: Ein Label-Selektor, der für das Budget benutzt werden kann. Nur gleichheits-basierte Auswahlkriterien werden unterstützt.

en: A label selector to use for this service. Only equality-based selector requirements are supported. If empty (the default) infer the selector from the replication controller or replica set.)
de_DE: Ein Label-Selektor, der für den Service benutzt werden kann. Nur gleichheits-basierte Auswahlkriterien werden unterstützt. Wenn er leer ist (standard), wird der Selektor vom ReplicationController oder ReplicaSet abgeleitet

en: A schedule in the Cron format the job should be run with.
de_DE: Ein Schedule im Cron Format, dass der Job nutzen soll.

en: Additional external IP address (not managed by Kubernetes) to accept for the service. If this IP is routed to a node, the service can be accessed by this IP in addition to its generated service IP.
de_DE: Zusätzliche, externe IP Adressen (die nicht von Kubernetes verwaltet werden), die der Service akzeptieren soll. Wenn diese IP zu einem Knoten gerouted wird, kann der Service über die IP angesprochen werden, zusätzlich zu seiner generierten Service-IP.

en: Apply a configuration to a resource by filename or stdin
de_DE: Wende eine Konfiguration auf eine Resource über den Dateinamen oder stdin an

en: Approve a certificate signing request
de_DE: Genehmige eine Certificate-Signing-Request

en: Assign your own ClusterIP or set to 'None' for a 'headless' service (no loadbalancing).
de_DE: Weise Deine eigene ClusterIP zu oder setze sie auf 'None' für einen 'headless'-Service (kein LoadBalancing).

en: Attach to a running container
de_DE: Weise einem laufenden Container zu

en: Auto-scale a Deployment, ReplicaSet, or ReplicationController
de_DE: Auto-skaliere ein Deployment, ReplicaSet oder ReplicationController

en: ClusterIP to be assigned to the service. Leave empty to auto-allocate, or set to 'None' to create a headless service.
de_DE: ClusterIP, die dem Service zugewiesen werden soll. Freilassen, für automatische Zuweisung oder auf 'None' setzen für einen headless-Service.

en: ClusterRole this ClusterRoleBinding should reference
de_DE: ClusterRole, die das ClusterRoleBinding referenzieren soll

en: ClusterRole this RoleBinding should reference
de_DE: ClusterRole, die das RoleBinding referenzieren soll

en: Container name which will have its image upgraded. Only relevant when --image is specified, ignored otherwise. Required when using --image on a multi-container pod
de_DE: Name des Containers dessen Image aktualisiert wird. Nur relevant, wenn --image angegeben ist, sonst ignoriert. Verpflichtend, wenn --image auf einem Multi-Container-Pod verwendet wird

en: Convert config files between different API versions
de_DE: Konvertiere Config-Dateien zwischen verschiedenen API Versionen

en: Copy files and directories to and from containers.
de_DE: Kopiere Dateien und Ordner aus/in Container(n).

en: Create a ClusterRoleBinding for a particular ClusterRole
de_DE: Erstelle ein ClusterRoleBinding für eine bestimmte ClusterRole

en: Create a LoadBalancer service.
de_DE: Erstelle einen LoadBalancer-Service.

en: Create a NodePort service.
de_DE: Erstelle einen NodePort-Service.

en: Create a RoleBinding for a particular Role or ClusterRole
de_DE: Erstelle ein RoleBinding für eine bestimmte Role oder ClusterRole

en: Create a TLS secret
de_DE: Erstelle ein TLS-Secret

en: Create a clusterIP service.
de_DE: Erstelle einen ClusterIP-Service

en: Create a configmap from a local file, directory or literal value
de_DE: Erstelle eine ConfigMap von einer Datei, einem Ordner oder einem festen Wert

en: Create a deployment with the specified name.
de_DE: Erstelle ein Deployment mit dem gegebenen Namen.

en: Create a namespace with the specified name
de_DE: Erstelle einen Namespace mit dem gegebenen Namen

en: Create a pod disruption budget with the specified name.
de_DE: Erstelle ein Pod-Disruption-Budget mit dem gegebenen Namen.

en: Create a quota with the specified name.
de_DE: Erstelle eine Quota mit dem gegebenen Namen.

en: Create a resource by filename or stdin
de_DE: Erstelle eine Resource von einer Datei oder stdin

en: Create a secret for use with a Docker registry
de_DE: Erstelle ein Secret für die Benutzung mit einer Docker-Registry

en: Create a secret from a local file, directory or literal value
de_DE: Erstelle ein Secret von einer lokalen Datei, einem Ordner oder einem festen Wert

en: Create a secret using specified subcommand
de_DE: Erstelle ein Secret mit dem angegebenen Sub-Befehl

en: Create a service account with the specified name
de_DE: Erstelle einen ServiceAccount mit dem gegebenen Namen

en: Create a service using specified subcommand.
de_DE: Erstelle einen Servuce mit dem angegebenen Sub-Befehl

en: Create an ExternalName service.
de_DE: Erstelle einen ExternalName-Service.

en: Delete resources by filenames, stdin, resources and names, or by resources and label selector
de_DE: Lösche Resourcen von einer Datei, stdin, resources- und names- oder mit resources- und label-Selektor

en: Delete the specified cluster from the kubeconfig
de_DE: Lösche das angegebene Cluster aus der kubeconfig

en: Delete the specified context from the kubeconfig
de_DE: Lösche den angegebenen Kontext aus der kubeconfig

en: Deny a certificate signing request
de_DE: Lehne eine Certificate-Signing-Request ab

en: Deprecated: Gracefully shut down a resource by name or filename
de_DE: Veraltet: Graziöses herunterfahren einer Resource über den Namen oder Dateinamen

en: Describe one or many contexts
de_DE: Beschreibe einen oder mehrere Kontexte

en: Display Resource (CPU/Memory) usage of nodes
de_DE: Zeige Resourcennutzung (CPU/Memory) von Knoten

en: Display Resource (CPU/Memory) usage of pods
de_DE: Zeige Resourcennutzung (CPU/Memory) von Pods

en: Display Resource (CPU/Memory) usage.
de_DE: Zeige Resourcennutzung (CPU/Memory).

en: Display cluster info
de_DE: Zeige Cluster-Info

en: Display clusters defined in the kubeconfig
de_DE: Zeige Cluster, die in der kubeconfig definiert sind

en: Display merged kubeconfig settings or a specified kubeconfig file
de_DE: Zeige vereinte kubeconfig-Einstellungen oder die angegebene kubeconfig-Datei

en: Display one or many resources
de_DE: Zeige eine oder mehrere Resourcen

en: Displays the current-context
de_DE: Zeige den aktuellen Kontext

en: Documentation of resources
de_DE: Dokumentation einer Resource

en: Drain node in preparation for maintenance
de_DE: Leere Knoten, um eine Wartung vorzubereiten

en: Dump lots of relevant info for debugging and diagnosis
de_DE: Zeige viele relevante Informationen für Debugging und Diagnose

en: Edit a resource on the server
de_DE: Bearbeite eine Resource auf dem Server

en: Email for Docker registry
de_DE: E-Mail für Docker-Registry

en: Execute a command in a container
de_DE: Führe einen Befehl im Container aus

en: Explicit policy for when to pull container images. Required when --image is same as existing image, ignored otherwise.
de_DE: Explizite Vorgabe, wann Container-Images gepullt werden. Verpflichtend, wenn --image ist gleich dem aktuellen Image ist - sonst ignoriert.

en: Forward one or more local ports to a pod
de_DE: Leite einen oder mehrere lokale Ports an einen Pod weiter

en: Help about any command
de_DE: Hilfe für jeden Befehl

en: IP to assign to the Load Balancer. If empty, an ephemeral IP will be created and used (cloud-provider specific).
de_DE: IP, die dem Load-Balancer zugewiesen wird. Falls leer, wird eine temporäre IP erstellt und verwendet (Cloud-Provider spezifisch)

en: Manage a deployment rollout
de_DE: Verwalte ein Deployment-Rollout

en: Mark node as schedulable
de_DE: Markiere Knoten als schedulable

en: Mark node as unschedulable
de_DE: Markiere Knoten als unschedulable

en: Mark the provided resource as paused
de_DE: Markiere die gegebene Resource als pausiert

en: Modify certificate resources.
de_DE: Verändere Certificate-Resources

en: Modify kubeconfig files
de_DE: Verändere kubeconfig Dateien

en: Name or number for the port on the container that the service should direct traffic to. Optional.
de_DE: Name oder Nummer des Ports in dem Container, zu dem der Service Daten leiten soll. Optional.

en: Only return logs after a specific date (RFC3339). Defaults to all logs. Only one of since-time / since may be used.
de_DE: Zeige nur Logs nach einem bestimmten Datum (RFC3339) an. Zeigt standardmäßig alle logs. Es kann entweder since-time oder since benutzt werden.

en: Output shell completion code for the specified shell (bash or zsh)
de_DE: Zeige Shell-Completion-Code für die angegebene Shell (bash oder zsh)

en: Password for Docker registry authentication
de_DE: Passwort für die Authentifizierung bei der Docker-Registry

en: Path to PEM encoded public key certificate.
de_DE: Pfad des Public-Key-Zertifikats im PEM-Format.

en: Path to private key associated with given certificate.
de_DE: Pfad zum Private-Key, der zum gegebenen Zertifikat passt.

en: Perform a rolling update of the given ReplicationController
de_DE: Führe ein Rolling-Update des gegebenen ReplicationControllers aus

en: Precondition for resource version. Requires that the current resource version match this value in order to scale.
de_DE: Vorbedingung für Resource-Version. Verlangt, dass die aktuelle Resource-Version diesen Wert erfüllt, um zu skalieren.

en: Print the client and server version information
de_DE: Schreibt die Client- und Server-Versionsinformation

en: Print the list of flags inherited by all commands
de_DE: Schreibt die Liste von Optionen, die alle Befehle erben

en: Print the logs for a container in a pod
de_DE: Schreibt die Logs für einen Container in einem Pod

en: Replace a resource by filename or stdin
de_DE: Ersetze eine Resource von einem Dateinamen oder stdin

en: Resume a paused resource
de_DE: Setze eine pausierte Resource fort

en: Role this RoleBinding should reference
de_DE: Role, die dieses RoleBinding referenzieren soll

en: Run a particular image on the cluster
de_DE: Starte ein bestimmtes Image auf dem Cluster

en: Run a proxy to the Kubernetes API server
de_DE: Starte einen Proxy zum Kubernetes-API-Server

en: Set a new size for a Deployment, ReplicaSet, Replication Controller, or Job
de_DE: Setze eine neue Größe für ein Deployment, ReplicaSet, ReplicationController oder Job

en: Set specific features on objects
de_DE: Setze bestimmte Features auf Objekten

en: Set the last-applied-configuration annotation on a live object to match the contents of a file.
de_DE: Setze die Annotation Last-Applied-Configuration auf einem Live-Objekt auf den Inhalt einer Datei.

en: Set the selector on a resource
de_DE: Setze den Selektor auf einer Resource

en: Sets a cluster entry in kubeconfig
de_DE: Setze einen Cluster-Eintrag in der kubeconfig

en: Sets a context entry in kubeconfig
de_DE: Setze einen Kontext-Eintrag in der kubeconfig

en: Sets a user entry in kubeconfig
de_DE: Setze einen User-Eintrag in der kubeconfig

en: Sets an individual value in a kubeconfig file
de_DE: Setze einen einzelnen Value in einer kubeconfig-Datei

en: Sets the current-context in a kubeconfig file
de_DE: Setze den aktuellen Kontext in einer kubeconfig-Datei

en: Show details of a specific resource or group of resources
de_DE: Zeige Details zu einer bestimmten Resource oder Gruppe von Resourcen

en: Show the status of the rollout
de_DE: Zeige den Status des Rollout

en: Synonym for --target-port
de_DE: Synonym für --target-port

en: Take a replication controller, service, deployment or pod and expose it as a new Kubernetes Service
de_DE: Nehme einen Replication Controller, Service, Deployment oder Pod und biete ihn als neuen Kubernetes-Service an

en: The image for the container to run.
de_DE: Das Image, dass auf dem Container gestartet werden soll.

en: The image pull policy for the container. If left empty, this value will not be specified by the client and defaulted by the server
de_DE: Die Image-Pull-Policy für den Container. Wenn leer, wird der Wert nicht vom Client gesetzt, sondern standardmäßig vom Server.

en: The minimum number or percentage of available pods this budget requires.
de_DE: Die minimale Anzahl oder Prozentzahl von verfügbaren Pods, die das Budget voraussetzt.

en: The name for the newly created object.
de_DE: Der Name des neu erstellten Objekts.

en: The name for the newly created object. If not specified, the name of the input resource will be used.
de_DE: Der Name des neu erstellten Objekts. Falls nicht angegeben, wird der Name der Input-Resource verwendet.

en: The name of the API generator to use, see http://kubernetes.io/docs/user-guide/kubectl-conventions/#generators for a list.
de_DE: Der Name des zu verwendenden API-Generators. Siehe http://kubernetes.io/docs/user-guide/kubectl-conventions/#generators für eine Übersicht.

en: The name of the API generator to use. Currently there is only 1 generator.
de_DE: Der Name des zu verwendenden API-Generators. Zur Zeit gibt es nur einen Generator.

en: The name of the API generator to use. There are 2 generators: 'service/v1' and 'service/v2'. The only difference between them is that service port in v1 is named 'default', while it is left unnamed in v2. Default is 'service/v2'.
de_DE: Der Name des zu verwendenden API-Generators. Es gibt zwei Generatoren: 'service/v1' und 'service/v2'. Der einzige Unterschied ist, dass der Serviceport in v1 'default' heißt, während er in v2 unbenannt bleibt. Standard ist 'service/v2'.

en: The name of the generator to use for creating a service.  Only used if --expose is true
de_DE: Der Name des zu verwendenden Generators, um einen Service zu erstellen. Wird nur benutzt, wenn --expose true ist

en: The network protocol for the service to be created. Default is 'TCP'.
de_DE: Das Netzwerkprotokoll, für den zu erstellenden Service. Standard ist 'TCP'.

en: The port that the service should serve on. Copied from the resource being exposed, if unspecified
de_DE: Der Port auf den der Service hören soll. Wird von der angebotenen Resource kopiert, falls nicht angegeben

en: The port that this container exposes.  If --expose is true, this is also the port used by the service that is created.
de_DE: Der Port, den der Container anbietet.  Wenn --expose true ist, ist es auch der Port, den der zu erstellende Service verwendet

en: The type of secret to create
de_DE: Der Typ des zu erstellenden Secrets

en: Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is 'ClusterIP'.
de_DE: Typ für diesen Service: ClusterIP, NodePort oder LoadBalancer. Standard ist 'ClusterIP'.

en: Undo a previous rollout
de_DE: Widerrufe ein vorheriges Rollout

en: Update field(s) of a resource using strategic merge patch
de_DE: Aktualisiere Felder einer Resource mit einem Strategic-Merge-Patch

en: Update image of a pod template
de_DE: Aktualisiere das Image einer Pod-Template

en: Update resource requests/limits on objects with pod templates
de_DE: Aktualisiere Resourcen requests/limits auf Objekten mit Pod-Templates

en: Update the annotations on a resource
de_DE: Aktualisiere die Annotationen auf einer Resource

en: Update the labels on a resource
de_DE: Aktualisiere die Labels auf einer Resource

en: Update the taints on one or more nodes
de_DE: Aktualisiere die Taints auf einem oder mehreren Knoten

en: Username for Docker registry authentication
de_DE: Username für Authentifizierung bei der Docker-Registry

en: View latest last-applied-configuration annotations of a resource/object
de_DE: Zeige die aktuelle Annotation Last-Applied-Configuration einer Resource / eines Object

en: View rollout history
de_DE: Zeige rollout-Verlauf

en: kubectl controls the Kubernetes cluster manager
de_DE: kubectl kontrolliert den Kubernetes-Cluster-Manager
