# Test translations for unit tests.
# Copyright (C) 2016
# This file is distributed under the same license as the Kubernetes package.
# FIRST AUTHOR brendan.d.burns@gmail.com, 2016.
#
msgid ""
msgstr ""
"Project-Id-Version: gettext-go-examples-hello\n"
"Report-Msgid-Bugs-To: EMAIL\n"
"POT-Creation-Date: 2021-07-07 20:15+0200\n"
"PO-Revision-Date: 2017-03-14 21:33-0800\n"
"Last-Translator: Brendan Burns <brendan.d.burns@gmail.com>\n"
"Language-Team: \n"
"Language: en\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 1.6.10\n"
"X-Poedit-SourceCharset: UTF-8\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:138
msgid ""
"\n"
"\t\t\t# Approve CSR 'csr-sqgzp'\n"
"\t\t\tkubectl certificate approve csr-sqgzp\n"
"\t\t"
msgstr ""
"\n"
"\t\t\t# Approve CSR 'csr-sqgzp'\n"
"\t\t\tkubectl certificate approve csr-sqgzp\n"
"\t\t"

#: staging/src/k8s.io/kubectl/pkg/cmd/certificates/certificates.go:182
msgid ""
"\n"
"\t\t\t# Deny CSR 'csr-sqgzp'\n"
"\t\t\tkubectl certificate deny csr-sqgzp\n"
"\t\t"
msgstr ""
"\n"
"\t\t\t# Deny CSR 'csr-sqgzp'\n"
"\t\t\tkubectl certificate deny csr-sqgzp\n"
"\t\t"

#: staging/src/k8s.io/kubectl/pkg/cmd/config/config.go:43
msgid ""
"\n"
"\t\t\tModify kubeconfig files using subcommands like \"kubectl config set "
"current-context my-context\"\n"
"\n"
"\t\t\tThe loading order follows these rules:\n"
"\n"
"\t\t\t1. If the --"
msgstr ""
"\n"
"\t\t\tModify kubeconfig files using subcommands like \"kubectl config set "
"current-context my-context\"\n"
"\n"
"\t\t\tThe loading order follows these rules:\n"
"\n"
"\t\t\t1. If the --"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrolebinding.go:44
msgid ""
"\n"
"\t\t  # Create a cluster role binding for user1, user2, and group1 using the "
"cluster-admin cluster role\n"
"\t\t  kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-"
"admin --user=user1 --user=user2 --group=group1"
msgstr ""
"\n"
"\t\t  # Create a cluster role binding for user1, user2, and group1 using the "
"cluster-admin cluster role\n"
"\t\t  kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-"
"admin --user=user1 --user=user2 --group=group1"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_configmap.go:58
msgid ""
"\n"
"\t\t  # Create a new config map named my-config based on folder bar\n"
"\t\t  kubectl create configmap my-config --from-file=path/to/bar\n"
"\n"
"\t\t  # Create a new config map named my-config with specified keys instead "
"of file basenames on disk\n"
"\t\t  kubectl create configmap my-config --from-file=key1=/path/to/bar/file1."
"txt --from-file=key2=/path/to/bar/file2.txt\n"
"\n"
"\t\t  # Create a new config map named my-config with key1=config1 and "
"key2=config2\n"
"\t\t  kubectl create configmap my-config --from-literal=key1=config1 --from-"
"literal=key2=config2\n"
"\n"
"\t\t  # Create a new config map named my-config from the key=value pairs in "
"the file\n"
"\t\t  kubectl create configmap my-config --from-file=path/to/bar\n"
"\n"
"\t\t  # Create a new config map named my-config from an env file\n"
"\t\t  kubectl create configmap my-config --from-env-file=path/to/bar.env"
msgstr ""
"\n"
"\t\t  # Create a new config map named my-config based on folder bar\n"
"\t\t  kubectl create configmap my-config --from-file=path/to/bar\n"
"\n"
"\t\t  # Create a new config map named my-config with specified keys instead "
"of file basenames on disk\n"
"\t\t  kubectl create configmap my-config --from-file=key1=/path/to/bar/file1."
"txt --from-file=key2=/path/to/bar/file2.txt\n"
"\n"
"\t\t  # Create a new config map named my-config with key1=config1 and "
"key2=config2\n"
"\t\t  kubectl create configmap my-config --from-literal=key1=config1 --from-"
"literal=key2=config2\n"
"\n"
"\t\t  # Create a new config map named my-config from the key=value pairs in "
"the file\n"
"\t\t  kubectl create configmap my-config --from-file=path/to/bar\n"
"\n"
"\t\t  # Create a new config map named my-config from an env file\n"
"\t\t  kubectl create configmap my-config --from-env-file=path/to/bar.env"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_rolebinding.go:43
msgid ""
"\n"
"\t\t  # Create a role binding for user1, user2, and group1 using the admin "
"cluster role\n"
"\t\t  kubectl create rolebinding admin --clusterrole=admin --user=user1 --"
"user=user2 --group=group1"
msgstr ""
"\n"
"\t\t  # Create a role binding for user1, user2, and group1 using the admin "
"cluster role\n"
"\t\t  kubectl create rolebinding admin --clusterrole=admin --user=user1 --"
"user=user2 --group=group1"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_secret_docker.go:56
msgid ""
"\n"
"\t\t  # If you don't already have a .dockercfg file, you can create a "
"dockercfg secret directly by using:\n"
"\t\t  kubectl create secret docker-registry my-secret --docker-"
"server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-"
"password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL\n"
"\n"
"\t\t  # Create a new secret named my-secret from ~/.docker/config.json\n"
"\t\t  kubectl create secret docker-registry my-secret --from-file=."
"dockerconfigjson=path/to/.docker/config.json"
msgstr ""
"\n"
"\t\t  # If you don't already have a .dockercfg file, you can create a "
"dockercfg secret directly by using:\n"
"\t\t  kubectl create secret docker-registry my-secret --docker-"
"server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-"
"password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL\n"
"\n"
"\t\t  # Create a new secret named my-secret from ~/.docker/config.json\n"
"\t\t  kubectl create secret docker-registry my-secret --from-file=."
"dockerconfigjson=path/to/.docker/config.json"

#: staging/src/k8s.io/kubectl/pkg/cmd/top/top_node.go:62
msgid ""
"\n"
"\t\t  # Show metrics for all nodes\n"
"\t\t  kubectl top node\n"
"\n"
"\t\t  # Show metrics for a given node\n"
"\t\t  kubectl top node NODE_NAME"
msgstr ""
"\n"
"\t\t  # Show metrics for all nodes\n"
"\t\t  kubectl top node\n"
"\n"
"\t\t  # Show metrics for a given node\n"
"\t\t  kubectl top node NODE_NAME"

#: staging/src/k8s.io/kubectl/pkg/cmd/cp/cp.go:45
msgid ""
"\n"
"\t\t# !!!Important Note!!!\n"
"\t\t# Requires that the 'tar' binary is present in your container\n"
"\t\t# image.  If 'tar' is not present, 'kubectl cp' will fail.\n"
"\t\t#\n"
"\t\t# For advanced use cases, such as symlinks, wildcard expansion or\n"
"\t\t# file mode preservation, consider using 'kubectl exec'.\n"
"\n"
"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace "
"<some-namespace>\n"
"\t\ttar cf - /tmp/foo | kubectl exec -i -n <some-namespace> <some-pod> -- "
"tar xf - -C /tmp/bar\n"
"\n"
"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n"
"\t\tkubectl exec -n <some-namespace> <some-pod> -- tar cf - /tmp/foo | tar "
"xf - -C /tmp/bar\n"
"\n"
"\t\t# Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in "
"the default namespace\n"
"\t\tkubectl cp /tmp/foo_dir <some-pod>:/tmp/bar_dir\n"
"\n"
"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific "
"container\n"
"\t\tkubectl cp /tmp/foo <some-pod>:/tmp/bar -c <specific-container>\n"
"\n"
"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace "
"<some-namespace>\n"
"\t\tkubectl cp /tmp/foo <some-namespace>/<some-pod>:/tmp/bar\n"
"\n"
"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n"
"\t\tkubectl cp <some-namespace>/<some-pod>:/tmp/foo /tmp/bar"
msgstr ""
"\n"
"\t\t# !!!Important Note!!!\n"
"\t\t# Requires that the 'tar' binary is present in your container\n"
"\t\t# image.  If 'tar' is not present, 'kubectl cp' will fail.\n"
"\t\t#\n"
"\t\t# For advanced use cases, such as symlinks, wildcard expansion or\n"
"\t\t# file mode preservation, consider using 'kubectl exec'.\n"
"\n"
"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace "
"<some-namespace>\n"
"\t\ttar cf - /tmp/foo | kubectl exec -i -n <some-namespace> <some-pod> -- "
"tar xf - -C /tmp/bar\n"
"\n"
"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n"
"\t\tkubectl exec -n <some-namespace> <some-pod> -- tar cf - /tmp/foo | tar "
"xf - -C /tmp/bar\n"
"\n"
"\t\t# Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in "
"the default namespace\n"
"\t\tkubectl cp /tmp/foo_dir <some-pod>:/tmp/bar_dir\n"
"\n"
"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific "
"container\n"
"\t\tkubectl cp /tmp/foo <some-pod>:/tmp/bar -c <specific-container>\n"
"\n"
"\t\t# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace "
"<some-namespace>\n"
"\t\tkubectl cp /tmp/foo <some-namespace>/<some-pod>:/tmp/bar\n"
"\n"
"\t\t# Copy /tmp/foo from a remote pod to /tmp/bar locally\n"
"\t\tkubectl cp <some-namespace>/<some-pod>:/tmp/foo /tmp/bar"

#: staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go:119
msgid ""
"\n"
"\t\t# Apply the configuration in pod.json to a pod\n"
"\t\tkubectl apply -f ./pod.json\n"
"\n"
"\t\t# Apply resources from a directory containing kustomization.yaml - e.g. "
"dir/kustomization.yaml\n"
"\t\tkubectl apply -k dir/\n"
"\n"
"\t\t# Apply the JSON passed into stdin to a pod\n"
"\t\tcat pod.json | kubectl apply -f -\n"
"\n"
"\t\t# Note: --prune is still in Alpha\n"
"\t\t# Apply the configuration in manifest.yaml that matches label app=nginx "
"and delete all other resources that are not in the file and match label "
"app=nginx\n"
"\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n"
"\n"
"\t\t# Apply the configuration in manifest.yaml and delete all the other "
"config maps that are not in the file\n"
"\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/"
"ConfigMap"
msgstr ""
"\n"
"\t\t# Apply the configuration in pod.json to a pod\n"
"\t\tkubectl apply -f ./pod.json\n"
"\n"
"\t\t# Apply resources from a directory containing kustomization.yaml - e.g. "
"dir/kustomization.yaml\n"
"\t\tkubectl apply -k dir/\n"
"\n"
"\t\t# Apply the JSON passed into stdin to a pod\n"
"\t\tcat pod.json | kubectl apply -f -\n"
"\n"
"\t\t# Note: --prune is still in Alpha\n"
"\t\t# Apply the configuration in manifest.yaml that matches label app=nginx "
"and delete all other resources that are not in the file and match label "
"app=nginx\n"
"\t\tkubectl apply --prune -f manifest.yaml -l app=nginx\n"
"\n"
"\t\t# Apply the configuration in manifest.yaml and delete all the other "
"config maps that are not in the file\n"
"\t\tkubectl apply --prune -f manifest.yaml --all --prune-whitelist=core/v1/"
"ConfigMap"

#: staging/src/k8s.io/kubectl/pkg/cmd/autoscale/autoscale.go:48
#, c-format
msgid ""
"\n"
"\t\t# 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\n"
"\t\tkubectl autoscale deployment foo --min=2 --max=10\n"
"\n"
"\t\t# Auto scale a replication controller \"foo\", with the number of pods "
"between 1 and 5, target CPU utilization at 80%\n"
"\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80"
msgstr ""
"\n"
"\t\t# 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\n"
"\t\tkubectl autoscale deployment foo --min=2 --max=10\n"
"\n"
"\t\t# Auto scale a replication controller \"foo\", with the number of pods "
"between 1 and 5, target CPU utilization at 80%\n"
"\t\tkubectl autoscale rc foo --max=5 --cpu-percent=80"

#: pkg/kubectl/cmd/convert/convert.go:51
msgid ""
"\n"
"\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n"
"\t\tkubectl convert -f pod.yaml\n"
"\n"
"\t\t# Convert the live state of the resource specified by 'pod.yaml' to the "
"latest version\n"
"\t\t# and print to stdout in JSON format.\n"
"\t\tkubectl convert -f pod.yaml --local -o json\n"
"\n"
"\t\t# Convert all files under current directory to latest version and create "
"them all.\n"
"\t\tkubectl convert -f . | kubectl create -f -"
msgstr ""
"\n"
"\t\t# Convert 'pod.yaml' to latest version and print to stdout.\n"
"\t\tkubectl convert -f pod.yaml\n"
"\n"
"\t\t# Convert the live state of the resource specified by 'pod.yaml' to the "
"latest version\n"
"\t\t# and print to stdout in JSON format.\n"
"\t\tkubectl convert -f pod.yaml --local -o json\n"
"\n"
"\t\t# Convert all files under current directory to latest version and create "
"them all.\n"
"\t\tkubectl convert -f . | kubectl create -f -"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_clusterrole.go:41
msgid ""
"\n"
"\t\t# Create a cluster role named \"pod-reader\" that allows user to perform "
"\"get\", \"watch\" and \"list\" on pods\n"
"\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --"
"resource=pods\n"
"\n"
"\t\t# Create a cluster role named \"pod-reader\" with ResourceName "
"specified\n"
"\t\tkubectl create clusterrole pod-reader --verb=get --resource=pods --"
"resource-name=readablepod --resource-name=anotherpod\n"
"\n"
"\t\t# Create a cluster role named \"foo\" with API Group specified\n"
"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=rs."
"extensions\n"
"\n"
"\t\t# Create a cluster role named \"foo\" with SubResource specified\n"
"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=pods,"
"pods/status\n"
"\n"
"\t\t# Create a cluster role name \"foo\" with NonResourceURL specified\n"
"\t\tkubectl create clusterrole \"foo\" --verb=get --non-resource-url=/logs/"
"*\n"
"\n"
"\t\t# Create a cluster role name \"monitoring\" with AggregationRule "
"specified\n"
"\t\tkubectl create clusterrole monitoring --aggregation-rule=\"rbac.example."
"com/aggregate-to-monitoring=true\""
msgstr ""
"\n"
"\t\t# Create a cluster role named \"pod-reader\" that allows user to perform "
"\"get\", \"watch\" and \"list\" on pods\n"
"\t\tkubectl create clusterrole pod-reader --verb=get,list,watch --"
"resource=pods\n"
"\n"
"\t\t# Create a cluster role named \"pod-reader\" with ResourceName "
"specified\n"
"\t\tkubectl create clusterrole pod-reader --verb=get --resource=pods --"
"resource-name=readablepod --resource-name=anotherpod\n"
"\n"
"\t\t# Create a cluster role named \"foo\" with API Group specified\n"
"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=rs."
"extensions\n"
"\n"
"\t\t# Create a cluster role named \"foo\" with SubResource specified\n"
"\t\tkubectl create clusterrole foo --verb=get,list,watch --resource=pods,"
"pods/status\n"
"\n"
"\t\t# Create a cluster role name \"foo\" with NonResourceURL specified\n"
"\t\tkubectl create clusterrole \"foo\" --verb=get --non-resource-url=/logs/"
"*\n"
"\n"
"\t\t# Create a cluster role name \"monitoring\" with AggregationRule "
"specified\n"
"\t\tkubectl create clusterrole monitoring --aggregation-rule=\"rbac.example."
"com/aggregate-to-monitoring=true\""

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_job.go:43
msgid ""
"\n"
"\t\t# Create a job\n"
"\t\tkubectl create job my-job --image=busybox\n"
"\n"
"\t\t# Create a job with a command\n"
"\t\tkubectl create job my-job --image=busybox -- date\n"
"\n"
"\t\t# Create a job from a cron job named \"a-cronjob\"\n"
"\t\tkubectl create job test-job --from=cronjob/a-cronjob"
msgstr ""
"\n"
"\t\t# Create a job\n"
"\t\tkubectl create job my-job --image=busybox\n"
"\n"
"\t\t# Create a job with a command\n"
"\t\tkubectl create job my-job --image=busybox -- date\n"
"\n"
"\t\t# Create a job from a cron job named \"a-cronjob\"\n"
"\t\tkubectl create job test-job --from=cronjob/a-cronjob"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_quota.go:44
msgid ""
"\n"
"\t\t# Create a new resource quota named my-quota\n"
"\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,"
"replicationcontrollers=2,resourcequotas=1,secrets=5,"
"persistentvolumeclaims=10\n"
"\n"
"\t\t# Create a new resource quota named best-effort\n"
"\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort"
msgstr ""
"\n"
"\t\t# Create a new resource quota named my-quota\n"
"\t\tkubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,"
"replicationcontrollers=2,resourcequotas=1,secrets=5,"
"persistentvolumeclaims=10\n"
"\n"
"\t\t# Create a new resource quota named best-effort\n"
"\t\tkubectl create quota best-effort --hard=pods=100 --scopes=BestEffort"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_pdb.go:44
#, c-format
msgid ""
"\n"
"\t\t# Create a pod disruption budget named my-pdb that will select all pods "
"with the app=rails label\n"
"\t\t# and require at least one of them being available at any point in time\n"
"\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-"
"available=1\n"
"\n"
"\t\t# Create a pod disruption budget named my-pdb that will select all pods "
"with the app=nginx label\n"
"\t\t# and require at least half of the pods selected to be available at any "
"point in time\n"
"\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%"
msgstr ""
"\n"
"\t\t# Create a pod disruption budget named my-pdb that will select all pods "
"with the app=rails label\n"
"\t\t# and require at least one of them being available at any point in time\n"
"\t\tkubectl create poddisruptionbudget my-pdb --selector=app=rails --min-"
"available=1\n"
"\n"
"\t\t# Create a pod disruption budget named my-pdb that will select all pods "
"with the app=nginx label\n"
"\t\t# and require at least half of the pods selected to be available at any "
"point in time\n"
"\t\tkubectl create pdb my-pdb --selector=app=nginx --min-available=50%"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create.go:76
msgid ""
"\n"
"\t\t# Create a pod using the data in pod.json\n"
"\t\tkubectl create -f ./pod.json\n"
"\n"
"\t\t# Create a pod based on the JSON passed into stdin\n"
"\t\tcat pod.json | kubectl create -f -\n"
"\n"
"\t\t# Edit the data in docker-registry.yaml in JSON then create the resource "
"using the edited data\n"
"\t\tkubectl create -f docker-registry.yaml --edit -o json"
msgstr ""
"\n"
"\t\t# Create a pod using the data in pod.json\n"
"\t\tkubectl create -f ./pod.json\n"
"\n"
"\t\t# Create a pod based on the JSON passed into stdin\n"
"\t\tcat pod.json | kubectl create -f -\n"
"\n"
"\t\t# Edit the data in docker-registry.yaml in JSON then create the resource "
"using the edited data\n"
"\t\tkubectl create -f docker-registry.yaml --edit -o json"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_priorityclass.go:43
msgid ""
"\n"
"\t\t# Create a priority class named high-priority\n"
"\t\tkubectl create priorityclass high-priority --value=1000 --description="
"\"high priority\"\n"
"\n"
"\t\t# Create a priority class named default-priority that is considered as "
"the global default priority\n"
"\t\tkubectl create priorityclass default-priority --value=1000 --global-"
"default=true --description=\"default priority\"\n"
"\n"
"\t\t# Create a priority class named high-priority that cannot preempt pods "
"with lower priority\n"
"\t\tkubectl create priorityclass high-priority --value=1000 --description="
"\"high priority\" --preemption-policy=\"Never\""
msgstr ""
"\n"
"\t\t# Create a priority class named high-priority\n"
"\t\tkubectl create priorityclass high-priority --value=1000 --description="
"\"high priority\"\n"
"\n"
"\t\t# Create a priority class named default-priority that is considered as "
"the global default priority\n"
"\t\tkubectl create priorityclass default-priority --value=1000 --global-"
"default=true --description=\"default priority\"\n"
"\n"
"\t\t# Create a priority class named high-priority that cannot preempt pods "
"with lower priority\n"
"\t\tkubectl create priorityclass high-priority --value=1000 --description="
"\"high priority\" --preemption-policy=\"Never\""

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_role.go:46
msgid ""
"\n"
"\t\t# Create a role named \"pod-reader\" that allows user to perform \"get"
"\", \"watch\" and \"list\" on pods\n"
"\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --"
"resource=pods\n"
"\n"
"\t\t# Create a role named \"pod-reader\" with ResourceName specified\n"
"\t\tkubectl create role pod-reader --verb=get --resource=pods --resource-"
"name=readablepod --resource-name=anotherpod\n"
"\n"
"\t\t# Create a role named \"foo\" with API Group specified\n"
"\t\tkubectl create role foo --verb=get,list,watch --resource=rs.extensions\n"
"\n"
"\t\t# Create a role named \"foo\" with SubResource specified\n"
"\t\tkubectl create role foo --verb=get,list,watch --resource=pods,pods/status"
msgstr ""
"\n"
"\t\t# Create a role named \"pod-reader\" that allows user to perform \"get"
"\", \"watch\" and \"list\" on pods\n"
"\t\tkubectl create role pod-reader --verb=get --verb=list --verb=watch --"
"resource=pods\n"
"\n"
"\t\t# Create a role named \"pod-reader\" with ResourceName specified\n"
"\t\tkubectl create role pod-reader --verb=get --resource=pods --resource-"
"name=readablepod --resource-name=anotherpod\n"
"\n"
"\t\t# Create a role named \"foo\" with API Group specified\n"
"\t\tkubectl create role foo --verb=get,list,watch --resource=rs.extensions\n"
"\n"
"\t\t# Create a role named \"foo\" with SubResource specified\n"
"\t\tkubectl create role foo --verb=get,list,watch --resource=pods,pods/status"

#: staging/src/k8s.io/kubectl/pkg/cmd/expose/expose.go:61
msgid ""
"\n"
"\t\t# Create a service for a replicated nginx, which serves on port 80 and "
"connects to the containers on port 8000\n"
"\t\tkubectl expose rc nginx --port=80 --target-port=8000\n"
"\n"
"\t\t# 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\n"
"\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n"
"\n"
"\t\t# Create a service for a pod valid-pod, which serves on port 444 with "
"the name \"frontend\"\n"
"\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n"
"\n"
"\t\t# Create a second service based on the above service, exposing the "
"container port 8443 as port 443 with the name \"nginx-https\"\n"
"\t\tkubectl expose service nginx --port=443 --target-port=8443 --name=nginx-"
"https\n"
"\n"
"\t\t# Create a service for a replicated streaming application on port 4100 "
"balancing UDP traffic and named 'video-stream'.\n"
"\t\tkubectl expose rc streamer --port=4100 --protocol=UDP --name=video-"
"stream\n"
"\n"
"\t\t# Create a service for a replicated nginx using replica set, which "
"serves on port 80 and connects to the containers on port 8000\n"
"\t\tkubectl expose rs nginx --port=80 --target-port=8000\n"
"\n"
"\t\t# Create a service for an nginx deployment, which serves on port 80 and "
"connects to the containers on port 8000\n"
"\t\tkubectl expose deployment nginx --port=80 --target-port=8000"
msgstr ""
"\n"
"\t\t# Create a service for a replicated nginx, which serves on port 80 and "
"connects to the containers on port 8000\n"
"\t\tkubectl expose rc nginx --port=80 --target-port=8000\n"
"\n"
"\t\t# 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\n"
"\t\tkubectl expose -f nginx-controller.yaml --port=80 --target-port=8000\n"
"\n"
"\t\t# Create a service for a pod valid-pod, which serves on port 444 with "
"the name \"frontend\"\n"
"\t\tkubectl expose pod valid-pod --port=444 --name=frontend\n"
"\n"
"\t\t# Create a second service based on the above service, exposing the "
"container port 8443 as port 443 with the name \"nginx-https\"\n"
"\t\tkubectl expose service nginx --port=443 --target-port=8443 --name=nginx-"
"https\n"
"\n"
"\t\t# Create a service for a replicated streaming application on port 4100 "
"balancing UDP traffic and named 'video-stream'.\n"
"\t\tkubectl expose rc streamer --port=4100 --protocol=UDP --name=video-"
"stream\n"
"\n"
"\t\t# Create a service for a replicated nginx using replica set, which "
"serves on port 80 and connects to the containers on port 8000\n"
"\t\tkubectl expose rs nginx --port=80 --target-port=8000\n"
"\n"
"\t\t# Create a service for an nginx deployment, which serves on port 80 and "
"connects to the containers on port 8000\n"
"\t\tkubectl expose deployment nginx --port=80 --target-port=8000"

#: staging/src/k8s.io/kubectl/pkg/cmd/create/create_ingress.go:64
msgid ""
"\n"
"\t\t# Create a single ingress called 'simple' that directs requests to foo."
"com/bar to svc\n"
"\t\t# svc1:8080 with a tls secret \"my-cert\"\n"
"\t\tkubectl create ingress simple --rule=\"foo.com/bar=svc1:8080,tls=my-cert"
"\"\n"
"\n"
"\t\t# Create a catch all ingress of \"/path\" pointing to service svc:port "
"and Ingress Class as \"otheringress\"\n"
"\t\tkubectl create ingress catch-all --class=otheringress --rule=\"/path=svc:"
"port\"\n"
"\n"
"\t\t# Create an ingress with two annotations: ingress.annotation1 and "
"ingress.annotations2\n"
"\t\tkubectl create ingress annotated --class=default --rule=\"foo.com/"
"bar=svc:port\" \\n\t\t\t--annotation ingress.annotation1=foo \\n\t\t\t--"
"annotation ingress.annotation2=bla\n"
"\n"
"\t\t# Create an ingress with the same host and multiple paths\n"
"\t\tkubectl create ingress multipath --class=default \\n\t\t\t--rule=\"foo."
"com/=svc:port\" \\n\t\t\t--rule=\"foo.com/admin/=svcadmin:portadmin\"\n"
"\n"
"\t\t# Create an ingress with multiple hosts and the pathType as Prefix\n"
"\t\tkubectl create ingress ingress1 --class=default \\n\t\t\t--rule=\"foo."
"com/path*=svc:8080\" \\n\t\t\t--rule=\"bar.com/admin*=svc2:http\"\n"
"\n"
"\t\t# Create an ingress with TLS enabled using the default ingress "
"certificate and different path types\n"
"\t\tkubectl create ingress ingtls --class=default \\n\t\t   --rule=\"foo.com/"
"=svc:https,tls\" \\n\t\t   --rule=\"foo.com/path/subpath*=othersvc:8080\"\n"
"\n"
"\t\t# Create an ingress with TLS enabled using a specific secret and "
"pathType as Prefix\n"
"\t\tkubectl create ingress ingsecret --class=default \\n\t\t   --rule=\"foo."
"com/*=svc:8080,tls=secret1\"\n"
"\n"
"\t\t# Create an ingress with a default backend\n"
"\t\tkubectl create ingress ingdefault --class=default \\n\t\t   --default-"
"backend=defaultsvc:http \\n\t\t   --rule=\"foo.com/*=svc:8080,tls=secret1\"\n"
"\n"
"\t\t"
msgstr ""
"\n"
"\t\t# Create a single ingress called 'simple' that directs requests to foo."
"com/bar to svc\n"
"\t\t# svc1:8080 with a tls secret \"my-cert\"\n"
"\t\tkubectl create ingress simple --rule=\"foo.com/bar=svc1:8080,tls=my-cert"
"\"\n"
"\n"
"\t\t# Create a catch all ingress of \"/path\" pointing to service svc:port "
"and Ingress Class as \"otheringress\"\n"
"\t\tkubectl create ingress catch-all --class=otheringress --rule=\"/path=svc:"
"port\"\n"
"\n"
"\t\t# Create an ingress with two annotations: ingress.annotation1 and "
"ingress.annotations2\n"
"\t\tkubectl create ingress annotated --class=default --rule=\"foo.com/"
"bar=svc:port\" \\n\t\t\t--annotation ingress.annotation1=foo \\n\t\t\t--"
"annotation ingress.annotation2=bla\n"
"\n"
"\t\t# Create an ingress with the same host and multiple paths\n"
"\t\tkubectl create ingress multipath --class=default \\n\t\t\t--rule=\"foo."
"com/=svc:port\" \\n\t\t\t--rule=\"foo.com/admin/=svcadmin:portadmin\"\n"
"\n"
"\t\t# Create an ingress with multiple hosts and the pathType as Prefix\n"
"\t\tkubectl create ingress ingress1 --class=default \\n\t\t\t--rule=\"foo."
"com/path*=svc:8080\" \\n\t\t\t--rule=\"bar.com/admin*=svc2:http\"\n"
"\n"
"\t\t# Create an ingress with TLS enabled using the default ingress "
"certificate and different path types\n"
"\t\tkubectl create ingress ingtls --class=default \\n\t\t   --rule=\"foo.com/"
"=svc:https,tls\" \\n\t\t   --rule=\"foo.com/path/subpath*=othersvc:8080\"\n"
"\n"
"\t\t# Create an ingress with TLS enabled using a specific secret and "
"pathType as Prefix\n"
"\t\tkubectl create ingress ingsecret --class=default \\n\t\t   --rule=\"foo."
"com/*=svc:8080,tls=secret1\"\n"
"\n"
"\t\t# Create an ingress with a default backend\n"
"\t\tkubectl create ingress ingdefault --class=default \\n\t\t   --default-"
"backend=defaultsvc:http \\n\t\t   --rule=\"foo.com/*=svc:8080,tls=secret1\"\n"
"\n"
"\t\t"

#: staging/src/k8s.io/kubectl/pkg/cmd/debug/debug.go:74
msgid ""
"\n"
"\t\t# Create an interactive debugging session in pod mypod and immediately "
"attach to it.\n"
"\t\tkubectl debug mypod -it --image=busybox\n"
"\n"
"\t\t# Create a debug container named debugger using a custom automated "
"debugging image.\n"
"\t\tkubectl debug --image=myproj/debug-tools -c debugger mypod\n"
"\n"
"\t\t# Create a copy of mypod adding a debug container and attach to it\n"
"\t\tkubectl debug mypod -it --image=busybox --copy-to=my-debugger\n"
"\n"
"\t\t# Create a copy of mypod changing the command of mycontainer\n"
"\t\tkubectl debug mypod -it --copy-to=my-debugger --container=mycontainer -- "
"sh\n"
"\n"
"\t\t# Create a copy of mypod changing all container images to busybox\n"
"\t\tkubectl debug mypod --copy-to=my-debugger --set-image=*=busybox\n"
"\n"
"\t\t# Create a copy of mypod adding a debug container and changing container "
"images\n"
"\t\tkubectl debug mypod -it --copy-to=my-debugger --image=debian --set-"
"image=app=app:debug,sidecar=sidecar:debug\n"
"\n"
"\t\t# Create an interactive debugging session on a node and immediately "
"attach to it.\n"
"\t\t# The container will run in the host namespaces and the host's "
"filesystem will be mounted at /host\n"
"\t\tkubectl debug node/mynode -it --image=busybox\n"
msgstr ""
"\n"
"\t\t# Create an interactive debugging session in pod mypod and immediately "
"attach to it.\n"
"\t\tkubectl debug mypod -it --image=busybox\n"
"\n"
"\t\t# Create a debug container named debugger using a custom automated "
"debugging image.\n"
"\t\tkubectl debug --image=myproj/debug-tools -c debugger mypod\n"
"\n"
"\t\t# Create a copy of mypod adding a debug container and attach to it\n"
"\t\tkubectl debug mypod -it --image=busybox --copy-to=my-debugger\n"
"\n"
"\t\t# Create a copy of mypod changing the command of mycontainer\n"
"\t\tkubectl debug mypod -it --copy-to=my-debugger --container=mycontainer -- "
"sh\n"
"\n"
"\t\t# Create a copy of mypod changing all container images to busybox\n"
"\t\tkubectl debug mypod --copy-to=my-debugger --set-image=*=busybox\n"
"\n"
"\t\t# Create a copy of mypod adding a debug container and changing container "
"images\n"
"\t\tkubectl debug mypod -it --copy-to=my-debugger --image=debian --set-"
"image=app=app:debug,sidecar=sidecar:debug\n"
"\n"
"\t\t# Create an interactive debugging session on a node and immediately "
"attach to it.\n"
"\t\t# The container will run in the host namespaces and the host's "
"filesystem will be mounted at /host\n"
"\t\tkubectl debug node/mynode -it --image=busybox\n"

#: staging/src/k8s.io/kubectl/pkg/cmd/delete/delete.go:74
msgid ""
"\n"
"\t\t# Delete a pod using the type and name specified in pod.json\n"
"\t\tkubectl delete -f ./pod.json\n"
"\n"
"\t\t# Delete resources from a directory containing kustomization.yaml - e.g. "
"dir/kustomization.yaml\n"
"\t\tkubectl delete -k dir\n"
"\n"
"\t\t# Delete a pod based on the type and name in the JSON passed into stdin\n"
"\t\tcat pod.json | kubectl delete -f -\n"
"\n"
"\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n"
"\t\tkubectl delete pod,service baz foo\n"
"\n"
"\t\t# Delete pods and services with label name=myLabel\n"
"\t\tkubectl delete pods,services -l name=myLabel\n"
"\n"
"\t\t# Delete a pod with minimal delay\n"
"\t\tkubectl delete pod foo --now\n"
"\n"
"\t\t# Force delete a pod on a dead node\n"
"\t\tkubectl delete pod foo --force\n"
"\n"
"\t\t# Delete all pods\n"
"\t\tkubectl delete pods --all"
msgstr ""
"\n"
"\t\t# Delete a pod using the type and name specified in pod.json\n"
"\t\tkubectl delete -f ./pod.json\n"
"\n"
"\t\t# Delete resources from a directory containing kustomization.yaml - e.g. "
"dir/kustomization.yaml\n"
"\t\tkubectl delete -k dir\n"
"\n"
"\t\t# Delete a pod based on the type and name in the JSON passed into stdin\n"
"\t\tcat pod.json | kubectl delete -f -\n"
"\n"
"\t\t# Delete pods and services with same names \"baz\" and \"foo\"\n"
"\t\tkubectl delete pod,service baz foo\n"
"\n"
"\t\t# Delete pods and services with label name=myLabel\n"
"\t\tkubectl delete pods,services -l name=myLabel\n"
"\n"
"\t\t# Delete a pod with minimal delay\n"
"\t\tkubectl delete pod foo --now\n"
"\n"
"\t\t# Force delete a pod on a dead node\n"
"\t\tkubectl delete pod foo --force\n"
"\n"
"\t\t# Delete all pods\n"
"\t\tkubectl delete pods --all"

#: staging/src/k8s.io/kubectl/pkg/cmd/describe/describe.go:51
msgid ""
"\n"
"\t\t# Describe a node\n"
"\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n"
"\n"
"\t\t# Describe a pod\n"
"\t\tkubectl describe pods/nginx\n"
"\n"
"\t\t# Describe a pod identified by type and name in \"pod.json\"\n"
"\t\tkubectl describe -f pod.json\n"
"\n"
"\t\t# Describe all pods\n"
"\t\tkubectl describe pods\n"
"\n"
"\t\t# Describe pods by label name=myLabel\n"
"\t\tkubectl describe po -l name=myLabel\n"
"\n"
"\t\t# Describe all pods managed by the 'frontend' replication controller (rc-"
"created pods\n"
"\t\t# get the name of the rc as a prefix in the pod the name)\n"
"\t\tkubectl describe pods frontend"
msgstr ""
"\n"
"\t\t# Describe a node\n"
"\t\tkubectl describe nodes kubernetes-node-emt8.c.myproject.internal\n"
"\n"
"\t\t# Describe a pod\n"
"\t\tkubectl describe pods/nginx\n"
"\n"
"\t\t# Describe a pod identified by type and name in \"pod.json\"\n"
"\t\tkubectl describe -f pod.json\n"
"\n"
"\t\t# Describe all pods\n"
"\t\tkubectl describe pods\n"
"\n"
"\t\t# Describe pods by label name=myLabel\n"
"\t\tkubectl describe po -l name=myLabel\n"
"\n"
"\t\t# Describe all pods managed by the 'frontend' replication controller (rc-"
"created pods\n"
"\t\t# get the name of the rc as a prefix in the pod the name)\n"
"\t\tkubectl describe pods frontend"

#: staging/src/k8s.io/kubectl/pkg/cmd/diff/diff.go:76
msgid ""
"\n"
"\t\t# Diff resources included in pod.json\n"
"\t\tkubectl diff -f pod.json\n"
"\n"
"\t\t# Diff file read from stdin\n"
"\t\tcat service.yaml | kubectl diff -f -"
msgstr ""
"\n"
"\t\t# Diff resources included in pod.json\n"
"\t\tkubectl diff -f pod.json\n"
"\n"
"\t\t# Diff file read from stdin\n"
"\t\tcat service.yaml | kubectl diff -f -"

#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:138
msgid ""
"\n"
"\t\t# Drain node \"foo\", even if there are pods not managed by a "
"replication controller, replica set, job, daemon set or stateful set on it\n"
"\t\tkubectl drain foo --force\n"
"\n"
"\t\t# As above, but abort if there are pods not managed by a replication "
"controller, replica set, job, daemon set or stateful set, and use a grace "
"period of 15 minutes\n"
"\t\tkubectl drain foo --grace-period=900"
msgstr ""
"\n"
"\t\t# Drain node \"foo\", even if there are pods not managed by a "
"replication controller, replica set, job, daemon set or stateful set on it\n"
"\t\tkubectl drain foo --force\n"
"\n"
"\t\t# As above, but abort if there are pods not managed by a replication "
"controller, replica set, job, daemon set or stateful set, and use a grace "
"period of 15 minutes\n"
"\t\tkubectl drain foo --grace-period=900"

#: staging/src/k8s.io/kubectl/pkg/cmd/edit/edit.go:55
msgid ""
"\n"
"\t\t# Edit the service named 'docker-registry'\n"
"\t\tkubectl edit svc/docker-registry\n"
"\n"
"\t\t# Use an alternative editor\n"
"\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n"
"\n"
"\t\t# Edit the job 'myjob' in JSON using the v1 API format\n"
"\t\tkubectl edit job.v1.batch/myjob -o json\n"
"\n"
"\t\t# Edit the deployment 'mydeployment' in YAML and save the modified "
"config in its annotation\n"
"\t\tkubectl edit deployment/mydeployment -o yaml --save-config"
msgstr ""
"\n"
"\t\t# Edit the service named 'docker-registry'\n"
"\t\tkubectl edit svc/docker-registry\n"
"\n"
"\t\t# Use an alternative editor\n"
"\t\tKUBE_EDITOR=\"nano\" kubectl edit svc/docker-registry\n"
"\n"
"\t\t# Edit the job 'myjob' in JSON using the v1 API format\n"
"\t\tkubectl edit job.v1.batch/myjob -o json\n"
"\n"
"\t\t# Edit the deployment 'mydeployment' in YAML and save the modified "
"config in its annotation\n"
"\t\tkubectl edit deployment/mydeployment -o yaml --save-config"

#: staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go:44
msgid ""
"\n"
"\t\t# Get output from running pod mypod; use the 'kubectl.kubernetes.io/"
"default-container' annotation\n"
"\t\t# for selecting the container to be attached or the first container in "
"the pod will be chosen\n"
"\t\tkubectl attach mypod\n"
"\n"
"\t\t# Get output from ruby-container from pod mypod\n"
"\t\tkubectl attach mypod -c ruby-container\n"
"\n"
"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container "
"from pod mypod\n"
"\t\t# and sends stdout/stderr from 'bash' back to the client\n"
"\t\tkubectl attach mypod -c ruby-container -i -t\n"
"\n"
"\t\t# Get output from the first pod of a replica set named nginx\n"
"\t\tkubectl attach rs/nginx\n"
"\t\t"
msgstr ""
"\n"
"\t\t# Get output from running pod mypod; use the 'kubectl.kubernetes.io/"
"default-container' annotation\n"
"\t\t# for selecting the container to be attached or the first container in "
"the pod will be chosen\n"
"\t\tkubectl attach mypod\n"
"\n"
"\t\t# Get output from ruby-container from pod mypod\n"
"\t\tkubectl attach mypod -c ruby-container\n"
"\n"
"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container "
"from pod mypod\n"
"\t\t# and sends stdout/stderr from 'bash' back to the client\n"
"\t\tkubectl attach mypod -c ruby-container -i -t\n"
"\n"
"\t\t# Get output from the first pod of a replica set named nginx\n"
"\t\tkubectl attach rs/nginx\n"
"\t\t"

#: staging/src/k8s.io/kubectl/pkg/cmd/exec/exec.go:48
msgid ""
"\n"
"\t\t# Get output from running the 'date' command from pod mypod, using the "
"first container by default\n"
"\t\tkubectl exec mypod -- date\n"
"\n"
"\t\t# Get output from running the 'date' command in ruby-container from pod "
"mypod\n"
"\t\tkubectl exec mypod -c ruby-container -- date\n"
"\n"
"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container "
"from pod mypod\n"
"\t\t# and sends stdout/stderr from 'bash' back to the client\n"
"\t\tkubectl exec mypod -c ruby-container -i -t -- bash -il\n"
"\n"
"\t\t# List contents of /usr from the first container of pod mypod and sort "
"by modification time\n"
"\t\t# If the command you want to execute in the pod has any flags in common "
"(e.g. -i),\n"
"\t\t# you must use two dashes (--) to separate your command's flags/"
"arguments\n"
"\t\t# Also note, do not surround your command and its flags/arguments with "
"quotes\n"
"\t\t# unless that is how you would execute it normally (i.e., do ls -t /usr, "
"not \"ls -t /usr\")\n"
"\t\tkubectl exec mypod -i -t -- ls -t /usr\n"
"\n"
"\t\t# Get output from running 'date' command from the first pod of the "
"deployment mydeployment, using the first container by default\n"
"\t\tkubectl exec deploy/mydeployment -- date\n"
"\n"
"\t\t# Get output from running 'date' command from the first pod of the "
"service myservice, using the first container by default\n"
"\t\tkubectl exec svc/myservice -- date\n"
"\t\t"
msgstr ""
"\n"
"\t\t# Get output from running the 'date' command from pod mypod, using the "
"first container by default\n"
"\t\tkubectl exec mypod -- date\n"
"\n"
"\t\t# Get output from running the 'date' command in ruby-container from pod "
"mypod\n"
"\t\tkubectl exec mypod -c ruby-container -- date\n"
"\n"
"\t\t# Switch to raw terminal mode; sends stdin to 'bash' in ruby-container "
"from pod mypod\n"
"\t\t# and sends stdout/stderr from 'bash' back to the client\n"
"\t\tkubectl exec mypod -c ruby-container -i -t -- bash -il\n"
"\n"
"\t\t# List contents of /usr from the first container of pod mypod and sort "
"by modification time\n"
"\t\t# If the command you want to execute in the pod has any flags in common "
"(e.g. -i),\n"
"\t\t# you must use two dashes (--) to separate your command's flags/"
"arguments\n"
"\t\t# Also note, do not surround your command and its flags/arguments with "
"quotes\n"
"\t\t# unless that is how you would execute it normally (i.e., do ls -t /usr, "
"not \"ls -t /usr\")\n"
"\t\tkubectl exec mypod -i -t -- ls -t /usr\n"
"\n"
"\t\t# Get output from running 'date' command from the first pod of the "
"deployment mydeployment, using the first container by default\n"
"\t\tkubectl exec deploy/mydeployment -- date\n"
"\n"
"\t\t# Get output from running 'date' command from the first pod of the "
"service myservice, using the first container by default\n"
"\t\tkubectl exec svc/myservice -- date\n"
"\t\t"

#: staging/src/k8s.io/kubectl/pkg/cmd/explain/explain.go:46
msgid ""
"\n"
"\t\t# Get the documentation of the resource and its fields\n"
"\t\tkubectl explain pods\n"
"\n"
"\t\t# Get the documentation of a specific field of a resource\n"
"\t\tkubectl explain pods.spec.containers"
msgstr ""
"\n"
"\t\t# Get the documentation of the resource and its fields\n"
"\t\tkubectl explain pods\n"
"\n"
"\t\t# Get the documentation of a specific field of a resource\n"
"\t\tkubectl explain pods.spec.containers"

#: staging/src/k8s.io/kubectl/pkg/cmd/completion/completion.go:65
msgid ""
"\n"
"\t\t# Installing bash completion on macOS using homebrew\n"
"\t\t## If running Bash 3.2 included with macOS\n"
"\t\t    brew install bash-completion\n"
"\t\t## or, if running Bash 4.1+\n"
"\t\t    brew install bash-completion@2\n"
"\t\t## If kubectl is installed via homebrew, this should start working "
"immediately\n"
"\t\t## If you've installed via other means, you may need add the completion "
"to your completion directory\n"
"\t\t    kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/"
"kubectl\n"
"\n"
"\n"
"\t\t# Installing bash completion on Linux\n"
"\t\t## If bash-completion is not installed on Linux, install the 'bash-"
"completion' package\n"
"\t\t## via your distribution's package manager.\n"
"\t\t## Load the kubectl completion code for bash into the current shell\n"
"\t\t    source <(kubectl completion bash)\n"
"\t\t## Write bash completion code to a file and source it from ."
"bash_profile\n"
"\t\t    kubectl completion bash > ~/.kube/completion.bash.inc\n"
"\t\t    printf \"\n"
"\t\t      # Kubectl shell completion\n"
"\t\t      source '$HOME/.kube/completion.bash.inc'\n"
"\t\t      \" >> $HOME/.bash_profile\n"
"\t\t    source $HOME/.bash_profile\n"
"\n"
"\t\t# Load the kubectl completion code for zsh[1] into the current shell\n"
"\t\t    source <(kubectl completion zsh)\n"
"\t\t# Set the kubectl completion code for zsh[1] to autoload on startup\n"
"\t\t    kubectl completion zsh > \"${fpath[1]}/_kubectl\""
msgstr ""
"\n"
"\t\t# Installing bash completion on macOS using homebrew\n"
"\t\t## If running Bash 3.2 included with macOS\n"
"\t\t    brew install bash-completion\n"
"\t\t## or, if running Bash 4.1+\n"
"\t\t    brew install bash-completion@2\n"
"\t\t## If kubectl is installed via homebrew, this should start working "
"immediately\n"
"\t\t## If you've installed via other means, you may need add the completion "
"to your completion directory\n"
"\t\t    kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/"
"kubectl\n"
"\n"
"\n"
"\t\t# Installing bash completion on Linux\n"
"\t\t## If bash-completion is not installed on Linux, install the 'bash-"
"completion' package\n"
"\t\t## via your distribution's package manager.\n"
"\t\t## Load the kubectl completion code for bash into the current shell\n"
"\t\t    source <(kubectl completion bash)\n"
"\t\t## Write bash completion code to a file and source it from ."
"bash_profile\n"
"\t\t    kubectl completion bash > ~/.kube/completion.bash.inc\n"
"\t\t    printf \"\n"
"\t\t      # Kubectl shell completion\n"
"\t\t      source '$HOME/.kube/completion.bash.inc'\n"
"\t\t      \" >> $HOME/.bash_profile\n"
"\t\t    source $HOME/.bash_profile\n"
"\n"
"\t\t# Load the kubectl completion code for zsh[1] into the current shell\n"
"\t\t    source <(kubectl completion zsh)\n"
"\t\t# Set the kubectl completion code for zsh[1] to autoload on startup\n"
"\t\t    kubectl completion zsh > \"${fpath[1]}/_kubectl\""

#: staging/src/k8s.io/kubectl/pkg/cmd/get/get.go:105
msgid ""
"\n"
"\t\t# List all pods in ps output format\n"
"\t\tkubectl get pods\n"
"\n"
"\t\t# List all pods in ps output format with more information (such as node "
"name)\n"
"\t\tkubectl get pods -o wide\n"
"\n"
"\t\t# List a single replication controller with specified NAME in ps output "
"format\n"
"\t\tkubectl get replicationcontroller web\n"
"\n"
"\t\t# List deployments in JSON output format, in the \"v1\" version of the "
"\"apps\" API group\n"
"\t\tkubectl get deployments.v1.apps -o json\n"
"\n"
"\t\t# List a single pod in JSON output format\n"
"\t\tkubectl get -o json pod web-pod-13je7\n"
"\n"
"\t\t# List a pod identified by type and name specified in \"pod.yaml\" in "
"JSON output format\n"
"\t\tkubectl get -f pod.yaml -o json\n"
"\n"
"\t\t# List resources from a directory with kustomization.yaml - e.g. dir/"
"kustomization.yaml\n"
"\t\tkubectl get -k dir/\n"
"\n"
"\t\t# Return only the phase value of the specified pod\n"
"\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}\n"
"\n"
"\t\t# List resource information in custom columns\n"
"\t\tkubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0]."
"name,IMAGE:.spec.containers[0].image\n"
"\n"
"\t\t# List all replication controllers and services together in ps output "
"format\n"
"\t\tkubectl get rc,services\n"
"\n"
"\t\t# List one or more resources by their type and names\n"
"\t\tkubectl get rc/web service/frontend pods/web-pod-13je7"
msgstr ""
"\n"
"\t\t# List all pods in ps output format\n"
"\t\tkubectl get pods\n"
"\n"
"\t\t# List all pods in ps output format with more information (such as node "
"name)\n"
"\t\tkubectl get pods -o wide\n"
"\n"
"\t\t# List a single replication controller with specified NAME in ps output "
"format\n"
"\t\tkubectl get replicationcontroller web\n"
"\n"
"\t\t# List deployments in JSON output format, in the \"v1\" version of the "
"\"apps\" API group\n"
"\t\tkubectl get deployments.v1.apps -o json\n"
"\n"
"\t\t# List a single pod in JSON output format\n"
"\t\tkubectl get -o json pod web-pod-13je7\n"
"\n"
"\t\t# List a pod identified by type and name specified in \"pod.yaml\" in "
"JSON output format\n"
"\t\tkubectl get -f pod.yaml -o json\n"
"\n"
"\t\t# List resources from a directory with kustomization.yaml - e.g. dir/"
"kustomization.yaml\n"
"\t\tkubectl get -k dir/\n"
"\n"
"\t\t# Return only the phase value of the specified pod\n"
"\t\tkubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}\n"
"\n"
"\t\t# List resource information in custom columns\n"
"\t\tkubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0]."
"name,IMAGE:.spec.containers[0].image\n"
"\n"
"\t\t# List all replication controllers and services together in ps output "
"format\n"
"\t\tkubectl get rc,services\n"
"\n"
"\t\t# List one or more resources by their type and names\n"
"\t\tkubectl get rc/web service/frontend pods/web-pod-13je7"

#: staging/src/k8s.io/kubectl/pkg/cmd/portforward/portforward.go:72
msgid ""
"\n"
"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports "
"5000 and 6000 in the pod\n"
"\t\tkubectl port-forward pod/mypod 5000 6000\n"
"\n"
"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports "
"5000 and 6000 in a pod selected by the deployment\n"
"\t\tkubectl port-forward deployment/mydeployment 5000 6000\n"
"\n"
"\t\t# Listen on port 8443 locally, forwarding to the targetPort of the "
"service's port named \"https\" in a pod selected by the service\n"
"\t\tkubectl port-forward service/myservice 8443:https\n"
"\n"
"\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n"
"\t\tkubectl port-forward pod/mypod 8888:5000\n"
"\n"
"\t\t# Listen on port 8888 on all addresses, forwarding to 5000 in the pod\n"
"\t\tkubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000\n"
"\n"
"\t\t# Listen on port 8888 on localhost and selected IP, forwarding to 5000 "
"in the pod\n"
"\t\tkubectl port-forward --address localhost,10.19.21.23 pod/mypod "
"8888:5000\n"
"\n"
"\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n"
"\t\tkubectl port-forward pod/mypod :5000"
msgstr ""
"\n"
"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports "
"5000 and 6000 in the pod\n"
"\t\tkubectl port-forward pod/mypod 5000 6000\n"
"\n"
"\t\t# Listen on ports 5000 and 6000 locally, forwarding data to/from ports "
"5000 and 6000 in a pod selected by the deployment\n"
"\t\tkubectl port-forward deployment/mydeployment 5000 6000\n"
"\n"
"\t\t# Listen on port 8443 locally, forwarding to the targetPort of the "
"service's port named \"https\" in a pod selected by the service\n"
"\t\tkubectl port-forward service/myservice 8443:https\n"
"\n"
"\t\t# Listen on port 8888 locally, forwarding to 5000 in the pod\n"
"\t\tkubectl port-forward pod/mypod 8888:5000\n"
"\n"
"\t\t# Listen on port 8888 on all addresses, forwarding to 5000 in the pod\n"
"\t\tkubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000\n"
"\n"
"\t\t# Listen on port 8888 on localhost and selected IP, forwarding to 5000 "
"in the pod\n"
"\t\tkubectl port-forward --address localhost,10.19.21.23 pod/mypod "
"8888:5000\n"
"\n"
"\t\t# Listen on a random port locally, forwarding to 5000 in the pod\n"
"\t\tkubectl port-forward pod/mypod :5000"

#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:87
msgid ""
"\n"
"\t\t# Mark node \"foo\" as schedulable\n"
"\t\tkubectl uncordon foo"
msgstr ""
"\n"
"\t\t# Mark node \"foo\" as schedulable\n"
"\t\tkubectl uncordon foo"

#: staging/src/k8s.io/kubectl/pkg/cmd/drain/drain.go:58
msgid ""
"\n"
"\t\t# Mark node \"foo\" as unschedulable\n"
"\t\tkubectl cordon foo"
msgstr ""
"\n"
"\t\t# Mark node \"foo\" as unschedulable\n"
"\t\tkubectl cordon foo"

#: staging/src/k8s.io/kubectl/pkg/cmd/patch/patch.go:83
msgid ""
"\n"
"\t\t# Partially update a node using a strategic merge patch, specifying the "
"patch as JSON\n"
"\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":true}}'\n"
"\n"
"\t\t# Partially update a node using a strategic merge patch, specifying the "
"patch as YAML\n"
"\t\tkubectl patch node k8s-node-1 -p $'spec:\n"
" unschedulable: true'\n"
"\n"
"\t\t# Partially update a node identified by the type and name specified in "
"\"node.json\" using strategic merge patch\n"
"\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n"
"\n"
"\t\t# Update a container's image; spec.containers[*].name is required "
"because it's a merge key\n"
"\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":"
"\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n"
"\n"
"\t\t# Update a container's image using a JSON patch with positional arrays\n"
"\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", "
"\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'"
msgstr ""
"\n"
"\t\t# Partially update a node using a strategic merge patch, specifying the "
"patch as JSON\n"
"\t\tkubectl patch node k8s-node-1 -p '{\"spec\":{\"unschedulable\":true}}'\n"
"\n"
"\t\t# Partially update a node using a strategic merge patch, specifying the "
"patch as YAML\n"
"\t\tkubectl patch node k8s-node-1 -p $'spec:\n"
" unschedulable: true'\n"
"\n"
"\t\t# Partially update a node identified by the type and name specified in "
"\"node.json\" using strategic merge patch\n"
"\t\tkubectl patch -f node.json -p '{\"spec\":{\"unschedulable\":true}}'\n"
"\n"
"\t\t# Update a container's image; spec.containers[*].name is required "
"because it's a merge key\n"
"\t\tkubectl patch pod valid-pod -p '{\"spec\":{\"containers\":[{\"name\":"
"\"kubernetes-serve-hostname\",\"image\":\"new image\"}]}}'\n"
"\n"
"\t\t# Update a container's image using a JSON patch with positional arrays\n"
"\t\tkubectl patch pod valid-pod --type='json' -p='[{\"op\": \"replace\", "
"\"path\": \"/spec/containers/0/image\", \"value\":\"new image\"}]'"

# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/options.go#L37
#: staging/src/k8s.io/kubectl/pkg/cmd/options/options.go:29
msgid ""
"\n"
"\t\t# Print flags inherited by all commands\n"
"\t\tkubectl options"
msgstr ""
"\n"
"\t\t# Print flags inherited by all commands\n"
"\t\tkubectl options"

#: staging/src/k8s.io/kubectl/pkg/cmd/clusterinfo/clusterinfo.go:44
msgid ""
"\n"
"\t\t# Print the address of the control plane and cluster services\n"
"\t\tkubectl cluster-info"
msgstr ""
"\n"
"\t\t# Print the address of the control plane and cluster services\n"
"\t\tkubectl cluster-info"

# https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/cmd/version.go#L39
#: staging/src/k8s.io/kubectl/pkg/cmd/version/version.go:44
msgid ""
"\n"
"\t\t# Print the client and server versions for the current context\n"
"\t\tkubectl version"
msgstr ""
"\n"
"\t\t# Print the client and server versions for the current context\n"
"\t\tkubectl version"

#: staging/src/k8s.io/kubectl/pkg/cmd/apiresources/apiversions.go:34
msgid ""
"\n"
"\t\t# Print the supported API versions\n"
"\t\tkubectl api-versions"
msgstr ""
"\n"
"\t\t# Print the supported API versions\n"
"\t\tkubectl api-versions"

#: staging/src/k8s.io/kubectl/pkg/cmd/replace/replace.go:56
msgid ""
"\n"
"\t\t# Replace a pod using the data in pod.json\n"
"\t\tkubectl replace -f ./pod.json\n"
"\n"
"\t\t# Replace a pod based on the JSON passed into stdin\n"
"\t\tcat pod.json | kubectl replace -f -\n"
"\n"
"\t\t# Update a single-container pod's image version (tag) to v4\n"
"\t\tkubectl get pod mypod -o yaml | sed 's/\\(image: myimage\\):.*$/