kubernetes - en to it_IT translation catalogue (234 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
it_IT: 
    		 # Creare un ClusterRoleBinding per user1, user2 e group1 utilizzando il cluster-admin ClusterRole
    		  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
it_IT: 
    		  # Crea un RoleBinding per user1, user2, and group1 utilizzando l'admin ClusterRole
    		  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
it_IT: 
    		  # Crea un nuovo configmap denominato my-config in base alla cartella bar
    		  kubectl create configmap my-config --from-file=path/to/bar
    
    		  # Crea un nuovo configmap denominato my-config con le chiavi specificate anziché i nomi dei file su disco
    		  kubectl create configmap my-config --from-file=key1=/path/to/bar/file1.txt --from-file=key2=/path/to/bar/file2.txt
    
    		  # Crea un nuovo configmap denominato my-config con key1 = config1 e 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
it_IT: 
    		  # Se non si dispone ancora di un file .dockercfg, è possibile creare un secret dockercfg direttamente utilizzando:
    		  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
it_IT: 
    		  # Mostra metriche per tutti i nodi
    		 kubectl top node
    
    		 # Mostra metriche per un determinato nodo
    		 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
it_IT: 
    		# Applica la configurazione pod.json a un pod.
    		kubectl apply -f ./pod.json
    
    		# Applicare il JSON passato in stdin a un pod.
    		cat pod.json | kubectl apply -f -
    
    		# Nota: --prune è ancora in in Alpha
    		# Applica la configurazione manifest.yaml che corrisponde alla label app = nginx ed elimina tutte le altre risorse che non sono nel file e nella label corrispondente app = nginx.
    		kubectl apply --prune -f manifest.yaml -l app=nginx
    
    		# Applica la configurazione manifest.yaml ed elimina tutti gli altri configmaps non presenti nel file.
    		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
it_IT: 
    		#  Auto scale un deployment "foo", con il numero di pod compresi tra 2 e 10, utilizzo della CPU target specificato in modo da utilizzare una politica di autoscaling predefinita:
    		kubectl autoscale deployment foo --min=2 --max=10
    
    		# Auto scale un controller di replica "foo", con il numero di pod compresi tra 1 e 5, utilizzo dell'utilizzo della CPU a 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 -
it_IT: 
    		# Converte 'pod.yaml' alla versione più recente e stampa in stdout.
    		kubectl convert -f pod.yaml
    
    		# Converte lo stato live della risorsa specificata da 'pod.yaml' nella versione più recente.
    		# e stampa in stdout nel formato json.
    		kubectl convert -f pod.yaml --local -o json
    
    		# Converte tutti i file nella directory corrente alla versione più recente e li crea tutti.
    		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
it_IT: 
    		# Crea un ClusterRole denominato "pod-reader" che consente all'utente di eseguire "get", "watch" e "list" sui pod
    		kubectl create clusterrole pod-reader --verb=get,list,watch --resource=pods
    
    		# Crea un ClusterRole denominato "pod-reader" con ResourceName specificato
    		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
it_IT: 
    		# Crea un ruolo denominato "pod-reader" che consente all'utente di eseguire "get", "watch" e "list" sui pod
    		kubectl create role pod-reader --verb=get --verb=list --verb=watch --resource=pods
    
    		# Crea un ruolo denominato "pod-reader" con ResourceName specificato
    		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
it_IT: 
    		# Crea una nuova resourcequota chiamata my-quota
    		kubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,replicationcontrollers=2,resourcequotas=1,secrets=5,persistentvolumeclaims=10
    
    		# Creare una nuova resourcequota denominata 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%
it_IT: 
    		# Crea un pod disruption budget chiamato my-pdb che seleziona tutti i pod con label app = rail
    		# e richiede che almeno uno di essi sia disponibile in qualsiasi momento.
    		kubectl create poddisruptionbudget my-pdb --selector=app=rails --min-available=1
    
    		# Crea un pod disruption budget con nome my-pdb che seleziona tutti i pod con label app = nginx 
    		# e richiede che almeno la metà dei pod selezionati sia disponibile in qualsiasi momento.
    		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
it_IT: 
    		# Crea un pod utilizzando i dati in pod.json.
    		kubectl create -f ./pod.json
    
    		# Crea un pod basato sul JSON passato in stdin.
    		cat pod.json | kubectl create -f -
    
    		# Modifica i dati in docker-registry.yaml in JSON utilizzando il formato API v1 quindi creare la risorsa utilizzando i dati modificati.
    		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
it_IT: 
    		# Crea un servizio per un nginx replicato, che serve nella porta 80 e si collega ai container sulla porta 8000.
    		kubectl expose rc nginx --port=80 --target-port=8000
    
    		# Crea un servizio per un controller di replica identificato per tipo e nome specificato in "nginx-controller.yaml", che serve nella porta 80 e si collega ai container sulla porta 8000.
    		kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000
    
    		# Crea un servizio per un pod valid-pod, che serve nella porta 444 con il nome "frontend"
    		kubectl expose pod valid-pod --port=444 --name=frontend
    
    		# Crea un secondo servizio basato sul servizio sopra, esponendo la porta container 8443 come porta 443 con il nome "nginx-https"
    		kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https
    
    		#  Crea un servizio per un'applicazione di replica in porta 4100 che bilanci il traffico UDP e denominato "video stream".
    		kubectl expose rc streamer --port=4100 --protocol=udp --name=video-stream
    
    		# Crea un servizio per un nginx replicato utilizzando l'insieme di replica, che serve nella porta 80 e si collega ai contenitori sulla porta 8000.
    		kubectl expose rs nginx --port=80 --target-port=8000
    
    		# Crea un servizio per una distribuzione di nginx, che serve nella porta 80 e si collega ai contenitori della porta 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
it_IT: 
    		# Elimina un pod utilizzando il tipo e il nome specificati in pod.json.
    		kubectl delete -f ./pod.json
    
    		# Elimina un pod in base al tipo e al nome del JSON passato in stdin.
    		cat pod.json | kubectl delete -f -
    
    		# Elimina i baccelli ei servizi con gli stessi nomi "baz" e "foo"
    		kubectl delete pod,service baz foo
    
    		# Elimina i baccelli ei servizi con il nome dell'etichetta = myLabel.
    		kubectl delete pods,services -l name=myLabel
    
    		# Eliminare un pod con un ritardo minimo
    		kubectl delete pod foo --now
    
    		# Forza elimina un pod in un nodo morto
    		kubectl delete pod foo --grace-period=0 --force
    
    		# Elimina tutti i pod
    		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
it_IT: 
    		# Descrive un nodo
    		kubectl describe nodes kubernetes-node-emt8.c.myproject.internal
    
    		# Descrive un pod
    		kubectl describe pods/nginx
    
    		# Descrive un pod identificato da tipo e nome in "pod.json"
    		kubectl describe -f pod.json
    
    		# Descrive tutti i pod
    		kubectl describe pods
    
    		# Descrive i pod con label name=myLabel
    		kubectl describe po -l name=myLabel
    
    		# Descrivere tutti i pod gestiti dal controller di replica "frontend"  (rc-created pods
    		# ottiene il nome del rc come un prefisso del nome pod).
    		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
it_IT: 
    		# Drain node "foo", anche se ci sono i baccelli non gestiti da ReplicationController, ReplicaSet, Job, DaemonSet o StatefulSet su di esso.
    		$ kubectl drain foo --force
    
    		# Come sopra, ma interrompere se ci sono i baccelli non gestiti da ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet, e utilizzare un periodo di grazia di 15 minuti.
    		$ 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
it_IT: 
    		# Modifica il servizio denominato 'docker-registry':
    		kubectl edit svc/docker-registry
    
    		# Usa un editor alternativo
    		KUBE_EDITOR="nano" kubectl edit svc/docker-registry
    
    		# Modifica il lavoro 'myjob' in JSON utilizzando il formato API v1:
    		kubectl edit job.v1.batch/myjob -o json
    
    		# Modifica la distribuzione 'mydeployment' in YAML e salvare la configurazione modificata nella sua annotazione:
    		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
it_IT: 
    		# Ottieni l'output dalla 'data' di esecuzione del pod 123456-7890, utilizzando il primo contenitore per impostazione predefinita
    		kubectl exec 123456-7890 date
    
    		# Ottieni l'output dalla data di esecuzione in ruby-container del pod 123456-7890
    		kubectl exec 123456-7890 -c ruby-container date
    
    		# Passare alla modalità raw terminal, invia stdin a 'bash' in ruby-container del pod 123456-7890
    		# and sends stdout/stderr from 'bash' back to the 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
it_IT: 
    		# Ottieni l'output dal pod 123456-7890 in esecuzione, utilizzando il primo contenitore per impostazione predefinita
    		kubectl attach 123456-7890
    
    		#  Ottieni l'output dal  ruby-container del pod 123456-7890
    		kubectl attach 123456-7890 -c ruby-container
    
    		# Passa alla modalità raw terminal, invia stdin a 'bash' in ruby-container del pod 123456-7890
    		# e invia stdout/stderr da 'bash' al client
    		kubectl attach 123456-7890 -c ruby-container -i -t
    
    		# Ottieni l'output dal primo pod di una ReplicaSet denominata 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
it_IT: 
    		# Ottieni la documentazione della risorsa e i relativi campi
    		kubectl explain pods
    
    		# Ottieni la documentazione di un campo specifico di una risorsa
    		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)
it_IT: 
    		# Installa il completamento di bash su un Mac utilizzando homebrew
    		brew install bash-completion
    		printf "
    # Bash completion support
    source $(brew --prefix)/etc/bash_completion
    " >> $HOME/.bash_profile
    		source $HOME/.bash_profile
    
    		# Carica il codice di completamento kubectl per bash nella shell corrente
    		source <(kubectl completion bash)
    
    		# Scrive il codice di completamento bash in un file e lo carica da .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
    
    		# Carica il codice di completamento kubectl per zsh [1] nella shell corrente
    		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
it_IT: 
    		# Elenca tutti i pod in formato output ps.
    		kubectl get pods
    
    		# Elenca tutti i pod in formato output ps con maggiori informazioni (ad esempio il nome del nodo).
    		kubectl get pods -o wide
    
    		# Elenca un controller di replica singolo con NAME specificato nel formato di output ps.
    		kubectl get replicationcontroller web
    
    		# Elenca un singolo pod nel formato di uscita JSON.
    		kubectl get -o json pod web-pod-13je7
    
    		# Elenca un pod identificato per tipo e nome specificato in "pod.yaml" nel formato di uscita JSON.
    		kubectl get -f pod.yaml -o json
    
    		# Restituisce solo il valore di fase del pod specificato.
    		kubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}
    
    		# Elenca tutti i controller e servizi di replica insieme in formato output ps.
    		kubectl get rc,services
    
    		# Elenca una o più risorse per il tipo e per i nomi.
    		kubectl get rc/web service/frontend pods/web-pod-13je7
    
    		# Elenca tutte le risorse con tipi diversi.
    		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
it_IT: 
    		# Ascolta localmente le porte 5000 e 6000, inoltrando i dati da/verso le porte 5000 e 6000 nel pod
    		kubectl port-forward mypod 5000 6000
    
    		# Ascolta localmente la porta 8888, inoltra a 5000 nel pod
    		kubectl port-forward mypod 8888:5000
    
    		# Ascolta localmente una porta casuale, inoltra a 5000 nel pod
    		kubectl port-forward mypod :5000
    
    		# Ascolta localmente una porta casuale, inoltra a 5000 nel pod
    		kubectl port-forward mypod 0:5000

en: 
    		# Mark node "foo" as schedulable.
    		$ kubectl uncordon foo
it_IT: 
    		# Segna il nodo "foo" come programmabile.
    		$ Kubectl uncordon foo

en: 
    		# Mark node "foo" as unschedulable.
    		kubectl cordon foo
it_IT: 
    		#  Segna il nodo "foo" come non programmabile.
    		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"}]'
it_IT: 
    		# Aggiorna parzialmente un nodo utilizzando merge patch strategica
    		kubectl patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}'
    
    		# Aggiorna parzialmente un nodo identificato dal tipo e dal nome specificato in "node.json" utilizzando  merge patch strategica
    		kubectl patch -f node.json -p '{"spec":{"unschedulable":true}}'
    
    		# Aggiorna l'immagine di un contenitore; spec.containers [*]. name è richiesto perché è una chiave di fusione
    		kubectl patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'
    
    		# Aggiorna l'immagine di un contenitore utilizzando una patch json con array posizionali
    		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
it_IT: 
    		# Stampa i flag ereditati da tutti i comandi
    		kubectl options

en: 
    		# Print the address of the master and cluster services
    		kubectl cluster-info
it_IT: 
    		# Stampa l'indirizzo dei servizi master e cluster
    		kubectl cluster-info

en: 
    		# Print the client and server versions for the current context
    		kubectl version
it_IT: 
    		# Stampa le versioni client e server per il current context
    		kubectl version

en: 
    		# Print the supported API versions
    		kubectl api-versions
it_IT: 
    		# Stampa le versioni API supportate
    		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
it_IT: 
    		# Sostituire un pod utilizzando i dati in pod.json.
    		kubectl replace -f ./pod.json
    
    		# Sostituire un pod usando il JSON passato da stdin.
    		cat pod.json | kubectl replace -f -
    
    		# Aggiorna la versione dell'immagine (tag) di un singolo container di pod a v4
    		kubectl get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/:v4/' | kubectl replace -f -
    
    		# Forza la sostituzione, cancellazione e quindi ricreare la risorsa
    		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
it_IT: 
    		# Restituisce snapshot log dal pod nginx con un solo container
    		kubectl logs nginx
    
    		# Restituisce snapshot log dei pod definiti dalla label app=nginx
    		kubectl logs -lapp=nginx
    
    		# Restituisce snapshot log del container ruby  terminato nel pod web-1
    		kubectl logs -p -c ruby web-1
    
    		# Iniziare a trasmettere i log del contenitore ruby nel pod web-1
    		kubectl logs -f -c ruby web-1
    
    		# Visualizza solo le ultime 20 righe di output del pod nginx
    		kubectl logs --tail=20 nginx
    
    		# Mostra tutti i log del pod nginx scritti nell'ultima ora
    		kubectl logs --since=1h nginx
    
    		# Restituisce snapshot log dal primo contenitore di un lavoro chiamato hello
    		kubectl logs job/hello
    
    		# Restituisce snapshot logs del container nginx-1 del deployment chiamato nginx
    		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
it_IT: 
    		# Esegui un proxy verso kubernetes apiserver sulla porta 8011, che fornisce contenuti statici da ./local/www/
    		kubectl proxy --port=8011 --www=./local/www/
    
    		# Esegui un proxy verso kubernetes apiserver su una porta locale arbitraria.
    		# La porta selezionata per il server verrà inviata a stdout.
    		kubectl proxy --port=0
    
    		# Esegui un proxy verso kubernetes apiserver, cambiando il prefisso api in k8s-api
    		# Questo comporta, ad es., pod api disponibili presso localhost:8001/k8s-api/v1/pods/
    		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
it_IT: 
    		# Scala un replicaset denominato 'foo' a 3.
    		kubectl scale --replicas=3 rs/foo
    
    		# Scala una risorsa identificata per tipo e nome specificato in "foo.yaml" a 3.
    		kubectl scale --replicas=3 -f foo.yaml
    
    		#  Se la distribuzione corrente di mysql è 2, scala mysql a 3.
    		kubectl scale --current-replicas=2 --replicas=3 deployment/mysql
    
    		# Scalare più controllori di replica.
    		kubectl scale --replicas=5 rc/foo rc/bar rc/baz
    
    		# Scala il lavoro denominato 'cron' a 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
it_IT: 
    		# Imposta l'ultima-configurazione-applicata di una risorsa che corrisponda al contenuto di un file.
    		kubectl apply set-last-applied -f deploy.yaml
    
    		# Esegue set-last-applied per ogni file di configurazione in una directory.
    		kubectl apply set-last-applied -f path/
    
    		# Imposta la configurazione dell'ultima applicazione di una risorsa che corrisponda al contenuto di un file, creerà l'annotazione se non esiste già.
    		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
it_IT: 
    		# Mostra metriche di tutti i pod nello spazio dei nomi predefinito
    		kubectl top pod
    
    		# Mostra metriche di tutti i pod nello spazio dei nomi specificato
    		kubectl top pod --namespace=NAMESPACE
    
    		# Mostra metriche per un pod e i suoi relativi container
    		kubectl top pod POD_NAME --containers
    
    		# Mostra metriche per i pod definiti da 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
it_IT: 
    		# Spegni foo.
    		kubectl stop replicationcontroller foo
    
    		# Stop di tutti i pod e servizi con label name=myLabel.
    		kubectl stop pods,services -l name=myLabel
    
    		# Spegnere il servizio definito in service.json
    		kubectl stop -f service.json
    
    		# Spegnere tutte le resources in path/to/resources directory
    		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)'
it_IT: 
    		# Avviare un'unica istanza di nginx.
    		kubectl run nginx --image=nginx
    
    		# Avviare un'unica istanza di hazelcast e lasciare che il container  esponga la porta 5701.
    		kubectl run hazelcast --image=hazelcast --port=5701
    
    		# Avviare una singola istanza di hazelcast ed imposta le variabili ambiente "DNS_DOMAIN=cluster" e "POD_NAMESPACE=default" nel container.
    		kubectl run hazelcast --image=hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"
    
    		# Avviare un'istanza replicata di nginx.
    		kubectl run nginx --image=nginx --replicas=5
    
    		# Dry run. Stampare gli oggetti API corrispondenti senza crearli.
    		kubectl run nginx --image=nginx --dry-run
    
    		# Avviare un'unica istanza di nginx, ma overload  le spec  del deployment  con un insieme parziale di valori analizzati da JSON.
    		kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'
    
    		# Avviare un pod di busybox e tenerlo in primo piano, non riavviarlo se esce.
    		kubectl run -i -t busybox --image=busybox --restart=Never
    
    		# Avviare il container nginx utilizzando il comando predefinito, ma utilizzare argomenti personalizzati (arg1 .. argN) per quel comando.
    		kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>
    
    		# Avviare il container  nginx utilizzando un diverso comando e argomenti personalizzati.
    		kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>
    
    		# Avviare il contenitore perl per calcolare π a 2000 posti e stamparlo.
    		kubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'
    
    		# Avviare il cron job per calcolare π a 2000 posti e stampare ogni 5 minuti.
    		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-
it_IT: 
    		# Aggiorna il nodo "foo" con un marcatore con il tasto 'dedicated' e il valore 'special-user' ed effettua 'NoSchedule'.
    		# Se un marcatore con quel tasto e l'effetto già esiste, il suo valore viene sostituito come specificato.
    		kubectl taint nodes foo dedicated=special-user:NoSchedule
    
    		# Rimuove dal nodo 'foo' il marcatore con il tasto 'dedicated' ed effettua 'NoSchedule' se esiste.
    		kubectl taint nodes foo dedicated:NoSchedule-
    
    		# Rimuovi dal nodo 'foo' tutti i marcatori con chiave '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-
it_IT: 
    		# Aggiorna il pod 'foo' con l'etichetta 'unhealthy' e il valore 'true'.
    		kubectl label pods foo unhealthy=true
    
    		# Aggiorna il pod 'foo' con l'etichetta 'status' e il valore 'unhealthy', sovrascrivendo qualsiasi valore esistente.
    		kubectl label --overwrite pods foo status=unhealthy
    
    		# Aggiorna tutti i pod nello spazio dei nomi
    		kubectl label pods --all status=unhealthy
    
    		# Aggiorna un pod identificato dal tipo e dal nome in "pod.json"
    		kubectl label -f pod.json status=unhealthy
    
    		# Aggiorna il pod 'foo' solo se la risorsa è invariata dalla versione 1.
    		kubectl label pods foo status=unhealthy --resource-version=1
    
    		#  Aggiorna il pod 'foo' rimuovendo un'etichetta denominata 'bar' se esiste.
    		# Non richiede la flag -overwrite.
    		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
it_IT: 
    		# Aggiorna i pod di frontend-v1 usando i dati del replication controller in frontend-v2.json.
    		kubectl rolling-update frontend-v1 -f frontend-v2.json
    
    		# Aggiorna i pod di frontend-v1 usando i dati JSON passati da stdin.
    		cat frontend-v2.json | kubectl rolling-update frontend-v1 -f -
    
    		# Aggiorna i pod di frontend-v1 in frontend-v2  solo cambiando l'immagine e modificando
    		# il nome del replication controller.
    		kubectl rolling-update frontend-v1 frontend-v2 --image=image:v2
    
    		# Aggiorna i pod di frontend solo cambiando l'immaginee mantenendo il vecchio none.
    		kubectl rolling-update frontend --image=image:v2
    
    		#  Interrompee ed invertire un rollout esistente in corso (da frontend-v1 a frontend-v2).
    		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
it_IT: 
    		# Visualizza le annotazioni dell'ultima-configurazione-applicata per tipo/nome in YAML.
    		kubectl apply view-last-applied deployment/nginx
    
    		# # Visualizza le annotazioni dell'ultima-configurazione-applicata per file in JSON.
    		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.
it_IT: 
    		Applicare una configurazione a una risorsa per nomefile o stdin.
    		Questa risorsa verrà creata se non esiste ancora.
    		Per utilizzare 'apply', creare sempre la risorsa inizialmente con 'apply' o 'create --save-config'.
    
    		Sono accettati i formati JSON e YAML.
    
    		Disclaimer Alpha: la funzionalità --prune non è ancora completa. Non utilizzare a meno che non si sia a conoscenza di quale sia lo stato attuale. Vedi 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.
it_IT: 
    		Convertire i file di configurazione tra diverse versioni API. Sono
    		accettati i formati YAML e JSON.
    
    		Il comando prende il nome di file, la directory o l'URL come input e lo converte nel formato
    		di versione specificata dal flag -output-version. Se la versione di destinazione non è specificata o
    		non supportata, viene convertita nella versione più recente.
    
    		L'output predefinito verrà stampato su stdout nel formato YAML. Si può usare l'opzione -o
    		per cambiare la destinazione di output.

en: 
    		Create a ClusterRole.
it_IT: 
    	
    Crea un ClusterRole.

en: 
    		Create a ClusterRoleBinding for a particular ClusterRole.
it_IT: 
    		Crea un ClusterRoleBinding per un ClusterRole particolare.

en: 
    		Create a RoleBinding for a particular Role or ClusterRole.
it_IT: 
    		Crea un RoleBinding per un particolare Ruolo o 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.
it_IT: 
    		Crea un TLS secret dalla coppia di chiavi pubblica/privata.
    
    		La coppia di chiavi pubblica/privata deve esistere prima. Il certificato chiave pubblica deve essere .PEM codificato e corrispondere alla chiave privata data.

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).
it_IT: 
    		Creare un configmap basato su un file, una directory o un valore literal specificato.
    
    		Un singolo configmap può includere una o più coppie chiave/valore.
    
    		Quando si crea una configmap basata su un file, il valore predefinito sarà il nome di base del file e il valore sarà
    		predefinito per il contenuto del file. Se il nome di base è una chiave non valida, è possibile specificare un tasto alternativo.
    
    		Quando si crea un configmap basato su una directory, ogni file il cui nome di base è una chiave valida nella directory verrà
    		pacchettizzata nel configmap. Le voci di directory tranne i file regolari vengono ignorati (ad esempio sottodirectory,
    		symlinks, devices, pipes, ecc).

en: 
    		Create a namespace with the specified name.
it_IT: 
    		Creare un namespace con il nome specificato.

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.
it_IT: 
    		Creare un nuovo secret per l'utilizzo con i registri Docker.
    
    		Dockercfg secrets vengono utilizzati per autenticare i registri Docker.
    
    		Quando utilizzi la riga di comando Docker per il push delle immagini, è possibile eseguire l'autenticazione eseguendo correttamente un determinato registry
    
    		    $ docker login DOCKER_REGISTRY_SERVER --username=DOCKER_USER --password=DOCKER_PASSWORD --email=DOCKER_EMAIL'.
    
        Questo produce un file ~ / .dockercfg che viene utilizzato dai successivi comandi "docker push" e "docker pull"
    		per autenticarsi nel registry. L'indirizzo email è facoltativo.
    
    		Durante la creazione di applicazioni, è possibile avere un Docker registry che richiede l'autenticazione. Affinché i 
    		nodi eseguano pull di immagini per vostro conto, devono avere le credenziali. È possibile fornire queste informazioni 
    		creando un dockercfg secret e collegandolo al tuo account di servizio.

en: 
    		Create a pod disruption budget with the specified name, selector, and desired minimum available pods
it_IT: 
    		Crea un pod disruption budget con il nome specificato, selector e il numero minimo di pod disponibili

en: 
    		Create a resource by filename or stdin.
    
    		JSON and YAML formats are accepted.
it_IT: 
    		Crea una risorsa per nome file o stdin.
    
    		Sono accettati i formati JSON e YAML.

en: 
    		Create a resourcequota with the specified name, hard limits and optional scopes
it_IT: 
    		Crea una resourcequota con il nome specificato, hard limits e gli scope opzionali

en: 
    		Create a role with single rule.
it_IT: 
    		Crea un ruolo con una singola regola.

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).
it_IT: 
    		Crea un secret basato su un file, una directory o un valore specifico literal.
    
    		Un singolo secret  può includere una o più coppie chiave/valore.
    
    		Quando si crea un secret basato su un file, la chiave per impostazione predefinita sarà il nome di base del file e il valore sarà
    		predefinito al contenuto del file. Se il nome di base è una chiave non valida, è possibile specificare un tasto alternativo.
    
    
    		Quando si crea un segreto basato su una directory, ogni file il cui nome di base è una chiave valida nella directory verrà 
    	\paccehttizzataw in un secret.   Le voci di directory tranne i file regolari vengono ignorati (ad esempio sottodirectory,
    		symlinks, devices, pipes, ecc).

en: 
    		Create a service account with the specified name.
it_IT: 
    		Creare un service account con il nome specificato.

en: 
    		Create and run a particular image, possibly replicated.
    
    		Creates a deployment or job to manage the created container(s).
it_IT: 
    		Crea ed esegue un'immagine particolare, eventualmente replicata.
    
    		Crea un deployment o un job per gestire i container creati.

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.
it_IT: 
    		Crea un autoscaler che automaticamente sceglie e imposta il numero di pod che vengono eseguiti in un cluster di kubernets.
    
    		Esegue una ricerca di un Deployment, ReplicaSet o ReplicationController per nome e crea un autoscaler che utilizza la risorsa indicata come riferimento.
    		Un autoscaler può aumentare o diminuire automaticamente il numero di pod distribuiti all'interno del sistema se necessario.

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.
it_IT: 
    		Cancella risorse secondo nomi di file, stdin, risorse e nomi, o per selettori di risorse e etichette.
    
    		Sono accettati i formati JSON e YAML. È possibile specificare un solo tipo di argomenti: nome file,
    		risorse e nomi, o risorse e selettore di etichette.
    
    		Alcune risorse, come i pod, supportano cacellazione corretta. Queste risorse definiscono un periodo di default
    		prima che siano forzatamente terminate (il grace period) ma si può sostituire quel valore con
    		il falg --grace-period, o passare --now per impostare il grace-period a 1. Poiché queste risorse spesso
    		rappresentano entità del cluster, la cancellazione non può essere presa in carico immediatamente. Se il nodo
    		che ospita un pod è spento o non raggiungibile da API server, termination può richiedere molto più tempo
    		del grace period. Per forzare la cancellazione di una resource,	devi obbligatoriamente indicare un grace	period di 0 e specificare
    		il flag --force.
    
    		IMPORTANTE: Fozare la cancellazione dei pod non attende conferma che i processi del pod siano
    		terminati, che può lasciare questi processi in esecuzione fino a quando il nodo rileva la cancellazione
    		completata correttamente. Se i tuoi processi utilizzano l'archiviazione condivisa o parlano con un'API remota e
    		dipendono dal nome del pod per identificarsi, la forzata eliminazione di questi pod può comportare
    		più processi in esecuzione su macchine diverse che utilizzando la stessa identificazione che può portare
    		corruzione o inconsistenza dei dati. Forza i pod solo quando si è sicuri che il pod sia
    		terminato, o se la tua applicazione può can tollerare più copie dello stesso pod in esecuzione contemporaneamente.
    		Inoltre, se forzate l'eliminazione dei i nodi, lo scheduler può può creare nuovi nodi su questi nodi prima che il nodo
    		abbia liberato quelle risorse e provocando immediatamente evict di tali pod.
    
    
    		Notare che il comando di eliminazione NON fa verificare la versione delle risorse, quindi se qualcuno
    		invia un aggiornamento ad una risorsa quando invii un eliminazione, il loro aggiornamento
    		saranno persi insieme al resto della risorsa.

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.
it_IT: 
    		Deprecated: chiudere correttamente una risorsa per nome o nome file.
    
    		Il comando stop è deprecato, tutte le sue funzionalità sono coperte dal comando delete.
    		Vedere 'kubectl delete --help' per ulteriori dettagli.
    
    		Tenta di arrestare ed eliminare una risorsa che supporta la corretta terminazione.
    		Se la risorsa è scalabile, verrà scalata a 0 prima dell'eliminazione.

en: 
    		Display Resource (CPU/Memory/Storage) usage of nodes.
    
    		The top-node command allows you to see the resource consumption of nodes.
it_IT: 
    		Visualizza l'utilizzo di risorse (CPU/Memoria/Storage) dei nodi.
    
    		Il comando top-node consente di visualizzare il consumo di risorse dei nodi.

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.
it_IT: 
    		Visualizza l'utilizzo di risorse (CPU/Memoria/Storage) dei pod.
    
    		Il comando "top pod" consente di visualizzare il consumo delle risorse dei pod.
    
    		A causa del ritardo della pipeline metrica, potrebbero non essere disponibili per alcuni minuti
    		eal momento della creazione dei pod.

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.
it_IT: 
    		Visualizza l'utilizzo di risorse (CPU/Memoria/Storage).
    
    		Il comando top consente di visualizzare il consumo di risorse per nodi o pod.
    
    		Questo comando richiede che Heapster sia configurato correttamente e che funzioni sul 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)
it_IT: 
    		Drain node in preparazione alla manutenzione.
    
    		Il nodo indicato verrà contrassegnato unschedulable  per impedire che nuovi pod arrivino.
    		'drain' evict i pod se l'APIServer supporta eviction
    		(http://kubernetes.io/docs/admin/disruptions/).  Altrimenti, usa il normale DELETE
    		per eliminare i pod.
    		Il 'drain' evicts o la cancellazione di tutti all pod tranne mirror pods (che non possono essere eliminati
    		attraverso API server).  Se ci sono i pod gestiti da  DaemonSet, drain non procederà
    		senza --ignore-daemonsets e, a prescindere da ciò, non cancellerà alcun
    		pod gestitto da DaemonSet,poiché questi pods verrebbero immediatamente sostituiti dal
    		DaemonSet controller,  che ignora le marcature unschedulable.  Se ci sono
    		pod che non sono né mirror pod né gestiti dal ReplicationController,
    		ReplicaSet, DaemonSet, StatefulSet o Job, allora drain non cancellerà alcun pod finché non
    		userai --force.  --force permetterà alla cancellazione di procedere se la risorsa gestita da uno
    		o più pod è mancante.
    
    		'drain' attende il termine corretto. Non devi operare sulla macchina finché
    		il comando non viene completato.
    
    		Quando sei pronto per riportare il nodo al servizio, utilizza kubectl uncordon, per
    		rimettere il nodo schedulable nuovamente.
    
    		![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.
it_IT: 
    		Modificare una risorsa dall'editor predefinito.
    
    		Il comando di modifica consente di modificare direttamente qualsiasi risorsa API che è possibile recuperare tramite gli
    		strumenti di riga di comando. Apre l'editor definito dalle variabili d'ambiente
    		KUBE_EDITOR o EDITOR, o ritornare a 'vi' per Linux o 'notepad' per Windows.
    		È possibile modificare più oggetti, anche se le modifiche vengono applicate una alla volta. Il comando
    		accetta sia nomi di file che argomenti da riga di comando, anche se i file a cui fa riferimento devono
    		essere state salvate precedentemente le versioni delle risorse.
    
    		La modifica viene eseguita con la versione API utilizzata per recuperare la risorsa.
    		Per modificare utilizzando una specifica versione API, fully-qualify la risorsa, versione e il gruppo.
    
    		Il formato predefinito è YAML. Per modificare in JSON, specificare "-o json".
    
    		Il flag --windows-line-endings può essere utilizzato per forzare i fine linea Windows,
    		altrimenti verrà utilizzato il default per il sistema operativo.
    
    		Nel caso in cui si verifica un errore durante l'aggiornamento, verrà creato un file temporaneo sul disco
    		che contiene le modifiche non apportate. L'errore più comune durante l'aggiornamento di una risorsa
    		è una modifica da pare di un altro editor della risorsa sul server. Quando questo si verifica, dovrai
    		applicare le modifiche alla versione più recente della risorsa o aggiornare il tua copia
    		temporanea salvata per includere l'ultima versione delle risorse.

en: 
    		Mark node as schedulable.
it_IT: 
    		Contrassegna il nodo come programmabile.

en: 
    		Mark node as unschedulable.
it_IT: 
    		Contrassegnare il nodo come non programmabile.

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
it_IT: 
    		In output codice di completamento shell output per la shell specificata (bash o zsh).
    		Il codice di shell deve essere valorizzato per fornire completamento
    		interattivo dei comandi kubectl. Questo può essere eseguito richiamandolo
    		da .bash_profile.
    
    		Nota: questo richiede il framework di completamento bash, che non è installato
    		per impostazione predefinita su Mac. Questo può essere installato utilizzando homebrew:
    
    		    $ brew install bash-completion
    
    		Una volta installato, bash_completion deve essere valutato. Ciò può essere fatto aggiungendo la
    		seguente riga al file .bash_profile
    
    		    $ source $(brew --prefix)/etc/bash_completion
    
    		Nota per gli utenti zsh: [1] i completamenti zsh sono supportati solo nelle versioni zsh> = 5.2

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)
it_IT: 
    		Eseguire un rolling update del ReplicationController specificato.
    
    		Sostituisce il replication controller specificato con un nuovo replication controller aggiornando un pod alla volta per usare il
    		nuovo PodTemplate. Il new-controller.json deve specificare lo stesso namespace del
    		controller di replica esistente e sovrascrivere almeno una etichetta (comune) nella sua replicaSelector.
    
    		![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.
it_IT: 
    		Sostituire una risorsa per nomefile o stdin.
    
    		Sono accettati i formati JSON e YAML. Se si sostituisce una risorsa esistente, 
    		è necessario fornire la specifica completa delle risorse. Questo può essere ottenuta da
    
    		    $ kubectl get TYPE NAME -o yaml
    
    		Fare riferimento ai modelli https://htmlpreview.github.io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html per trovare se un campo è mutevole.

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.
it_IT: 
    		Imposta una nuova dimensione per Deployment, ReplicaSet, Replication Controller, o Job.
    
    		Scala consente anche agli utenti di specificare una o più condizioni preliminari per l'azione della scala.
    
    		Se --current-replicas o --resource-version sono specificate, viene convalidata prima di
    		tentare scale, ed è garantito che la precondizione vale quando
    		scale viene inviata al server..

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.
it_IT: 
    		Imposta le annotazioni dell'ultima-configurazione-applicata impostandola in modo che corrisponda al contenuto di un file.
    		Ciò determina l'aggiornamento dell'ultima-configurazione-applicata come se 'kubectl apply -f <file>' fosse stato eseguito,
    		senza aggiornare altre parti dell'oggetto.

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'
it_IT: 
    		Per proxy tutti i kubernetes api e nient'altro, utilizzare:
    
    		    $ kubectl proxy --api-prefix=/
    
    		Per proxy solo una parte dei kubernetes api e anche alcuni file static
    
    		    $ kubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/
    
    		Quanto sopra consente 'curl localhost:8001/api/v1/pods'.
    
    		Per eseguire il proxy tutti i kubernetes api in una radice diversa, utilizzare:
    
    		    $ kubectl proxy --api-prefix=/custom/
    
    		Quanto sopra ti permette 'curl localhost:8001/custom/api/v1/pods'

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.
it_IT: 
    		Aggiorna i campi di una risorsa utilizzando la merge patch strategica
    
    		Sono accettati i formati JSON e YAML.
    
    		Si prega di fare riferimento ai modelli in https://htmlpreview.github.io/?https://github.com/kubernetes/kubernetes/blob/HEAD/docs/api-reference/v1/definitions.html per trovare se un campo è mutevole.

en: 
    		Update the labels on a resource.
    
    		* A label must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to %[1]d characters.
    		* If --overwrite is true, then existing labels can be overwritten, otherwise attempting to overwrite a label will result in an error.
    		* If --resource-version is specified, then updates will use this resource version, otherwise the existing resource-version will be used.
it_IT: 
    		Aggiorna le label di una risorsa.
    
    		* A label must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to %[1]d characters.
    		* If --overwrite is true, then existing labels can be overwritten, otherwise attempting to overwrite a label will result in an error.
    		* If --resource-version is specified, then updates will use this resource version, otherwise the existing resource-version will be used.

en: 
    		Update the taints on one or more nodes.
    
    		* A taint consists of a key, value, and effect. As an argument here, it is expressed as key=value:effect.
    		* The key must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to %[1]d characters.
    		* The value must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to %[2]d characters.
    		* The effect must be NoSchedule, PreferNoSchedule or NoExecute.
    		* Currently taint can only apply to node.
it_IT: 
    		Aggiorna i marcatori su uno o più nodi.
    
    		* Un marcatore è costituita da una chiave, un valore e un effetto. Come argomento qui, viene espresso come chiave = valore: effetto.
    		* La chiave deve iniziare con una lettera o un numero e può contenere lettere, numeri, trattini, punti e sottolineature, fino a% [1] d caratteri.
    		* Il valore deve iniziare con una lettera o un numero e può contenere lettere, numeri, trattini, punti e sottolineature, fino a% [2] d caratteri.
    		* L'effetto deve essere NoSchedule, PreferNoSchedule o NoExecute.
    		* Attualmente il marcatore può essere applicato solo al nodo.

en: 
    		View the latest last-applied-configuration annotations by type/name or file.
    
    		The default output will be printed to stdout in YAML format. One can use -o option
    		to change output format.
it_IT: 
    		Visualizza le annotazioni dell'ultima-configurazione-applicata per tipo/nome o file.
    
    		L'output predefinito verrà stampato su stdout nel formato YAML. Si può usare l'opzione -o
    		Per cambiare il formato di output.

en: 
    	    # !!!Important Note!!!
    	    # Requires that the 'tar' binary is present in your container
    	    # image.  If 'tar' is not present, 'kubectl cp' will fail.
    
    	    # Copy /tmp/foo_dir local directory to /tmp/bar_dir in a remote pod in the default namespace
    		kubectl cp /tmp/foo_dir <some-pod>:/tmp/bar_dir
    
            # Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific container
    		kubectl cp /tmp/foo <some-pod>:/tmp/bar -c <specific-container>
    
    		# Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace <some-namespace>
    		kubectl cp /tmp/foo <some-namespace>/<some-pod>:/tmp/bar
    
    		# Copy /tmp/foo from a remote pod to /tmp/bar locally
    		kubectl cp <some-namespace>/<some-pod>:/tmp/foo /tmp/bar
it_IT: 
    	    #  !!!Nota importante!!!
    	    # Richiede che il binario 'tar' sia presente nel tuo contenitore
    	    #  immagine. Se 'tar' non è presente, 'kubectl cp' non riesce.
    
    	    # Copia /tmp/foo_dir directory locale in /tmp/bar_dir in un pod remoto nello spazio dei nomi predefinito
    		kubectl cp /tmp/foo_dir <some-pod>:/tmp/bar_dir
    
            # Copia /tmp/foo file locale in /tmp/bar in un pod remoto in un contenitore specifico
    		kubectl cp /tmp/foo <some-pod>:/tmp/bar -c <specific-container>
    
    		# Copia /tmp/foo file locale in /tmp/bar in un pod remoto nello spazio dei nomi <some-namespace>
    		kubectl cp /tmp/foo <some-namespace>/<some-pod>:/tmp/bar
    
    		# Copia /tmp/foo da un pod remoto in /tmp/bar localmente
    		kubectl cp <some-namespace>/<some-pod>:/tmp/foo /tmp/bar

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
it_IT: 
    	  # Crea un nuovo secret TLS denominato tls-secret con la coppia di dati fornita:
    	  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
it_IT: 
    	  # Crea un nuovo namespace denominato 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
it_IT: 
    	  # Crea un nuovo secret denominato my-secret con i tasti per ogni file nella barra delle cartelle
    	  kubectl create secret generic my-secret --from-file=path/to/bar
    
    	  # Crea un nuovo secret denominato my-secret con le chiavi specificate anziché i nomi sul disco
    	  kubectl create secret generic my-secret --from-file=ssh-privatekey=~/.ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub
    
    	  # Crea un nuovo secret denominato my-secret con key1 = supersecret e 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
it_IT: 
    	  # Crea un nuovo service account denominato 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
it_IT: 
    	#  Crea un nuovo servizio ExternalName denominato 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.
it_IT: 
    	Crea un servizio ExternalName con il nome specificato.
    
    	Il servizio ExternalName fa riferimento a un indirizzo DNS esterno 
    	solo pod, che permetteranno agli autori delle applicazioni di utilizzare i servizi di riferimento
    	che esistono fuori dalla piattaforma, su altri cluster, o localmente..

en: 
    	Help provides help for any command in the application.
    	Simply type kubectl help [path to command] for full details.
it_IT: 
    	Help fornisce assistenza per qualsiasi comando nell'applicazione.
    	Basta digitare kubectl help [path to command] per i dettagli completi.

en: 
        # Create a new LoadBalancer service named my-lbs
        kubectl create service loadbalancer my-lbs --tcp=5678:8080
it_IT: 
        # Creare un nuovo servizio LoadBalancer denominato 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"
it_IT: 
        # Creare un nuovo servizio clusterIP denominato my-cs
        kubectl create service clusterip my-cs --tcp=5678:8080
    
        # Creare un nuovo servizio clusterIP denominato my-cs (in modalità headless)
        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
it_IT: 
        # Crea una nuovo deployment chiamato my-dep che esegue l'immagine busybox.
        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
it_IT: 
        # Creare un nuovo servizio nodeport denominato 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
it_IT: 
        # Dump dello stato corrente del cluster verso stdout
        kubectl cluster-info dump
    
        # Dump dello stato corrente del cluster verso /path/to/cluster-state
        kubectl cluster-info dump --output-directory=/path/to/cluster-state
    
        # Dump di tutti i namespaces verso stdout
        kubectl cluster-info dump --all-namespaces
    
        # Dump di un set di namespace verso /path/to/cluster-state
        kubectl cluster-info dump --namespaces default,kube-system --output-directory=/path/to/cluster-state

en: 
        # Update pod 'foo' with the annotation 'description' and the value 'my frontend'.
        # If the same annotation is set multiple times, only the last value will be applied
        kubectl annotate pods foo description='my frontend'
    
        # Update a pod identified by type and name in "pod.json"
        kubectl annotate -f pod.json description='my frontend'
    
        # Update pod 'foo' with the annotation 'description' and the value 'my frontend running nginx', overwriting any existing value.
        kubectl annotate --overwrite pods foo description='my frontend running nginx'
    
        # Update all pods in the namespace
        kubectl annotate pods --all description='my frontend running nginx'
    
        # Update pod 'foo' only if the resource is unchanged from version 1.
        kubectl annotate pods foo description='my frontend running nginx' --resource-version=1
    
        # Update pod 'foo' by removing an annotation named 'description' if it exists.
        # Does not require the --overwrite flag.
        kubectl annotate pods foo description-
it_IT: 
        # Aggiorna il pod 'foo' con annotazione 'description'e il valore 'my frontend'.
        # Se la stessa annotazione è impostata più volte, verrà applicato solo l'ultimo valore
        kubectl annotate pods foo description='my frontend'
    
        # Aggiorna un pod identificato per tipo e nome in "pod.json"
        kubectl annotate -f pod.json description='my frontend'
    
        # Aggiorna pod 'foo' con la annotazione 'description' e il valore 'my frontend running nginx', sovrascrivendo qualsiasi valore esistente.
        kubectl annotate --overwrite pods foo description='my frontend running nginx'
    
        # Aggiorna tutti i baccelli nel namespace
        kubectl annotate pods --all description='my frontend running nginx'
    
        # Aggiorna il pod 'foo' solo se la risorsa è invariata dalla versione 1.
        kubectl annotate pods foo description='my frontend running nginx' --resource-version=1
    
        # Aggiorna il pod 'foo' rimuovendo un'annotazione denominata 'descrizione' se esiste.
        # Non richiede flag -overwrite.
        kubectl annotate pods foo description-

en: 
        Create a LoadBalancer service with the specified name.
it_IT: 
        Crea un servizio LoadBalancer con il nome specificato.

en: 
        Create a clusterIP service with the specified name.
it_IT: 
        Crea un servizio clusterIP con il nome specificato.

en: 
        Create a deployment with the specified name.
it_IT: 
        Creare un deployment con il nome specificato.

en: 
        Create a nodeport service with the specified name.
it_IT: 
        Creare un servizio nodeport con il nome specificato.

en: 
        Dumps cluster info out suitable for debugging and diagnosing cluster problems.  By default, dumps everything to
        stdout. You can optionally specify a directory with --output-directory.  If you specify a directory, kubernetes will
        build a set of files in that directory.  By default only dumps things in the 'kube-system' namespace, but you can
        switch to a different namespace with the --namespaces flag, or specify --all-namespaces to dump all namespaces.
    
        The command also dumps the logs of all of the pods in the cluster, these logs are dumped into different directories
        based on namespace and pod name.
it_IT: 
        Dump delle informazioni di cluster idonee per il debug e la diagnostica di problemi di cluster. Per impostazione predefinita, tutto
        verso stdout. È possibile specificare opzionalmente una directory con --output-directory. Se si specifica una directory, kubernetes 
        creearà un insieme di file in quella directory. Per impostazione predefinita, dumps solo i dati del namespace "kube-system", ma è
        possibile passare ad namespace diverso con il flag --namespaces o specificare --all-namespaces per il dump di tutti i namespace.
    
         Il comando esegue dump anche dei log di tutti i pod del cluster, questi log vengono scaricati in directory differenti
         basati sul namespace e sul nome del pod.

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'.
it_IT: 
      Visualizza gli indirizzi del master e dei servizi con label kubernetes.io/cluster-service=true
      Per ulteriore debug e diagnosticare i problemi di cluster, utilizzare 'kubectl cluster-info dump'.

en: A comma-delimited set of quota scopes that must all match each object tracked by the quota.
it_IT: Un insieme delimitato-da-virgole di quota scopes che devono corrispondere a ciascun oggetto gestito dalla quota.

en: A comma-delimited set of resource=quantity pairs that define a hard limit.
it_IT: Un insieme delimitato-da-virgola di coppie risorsa = quantità che definiscono un hard limit.

en: A label selector to use for this budget. Only equality-based selector requirements are supported.
it_IT: Un label selector da utilizzare per questo budget. Sono supportati solo i selettori equality-based selector.

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.)
it_IT: Un selettore di label da utilizzare per questo servizio. Sono supportati solo equality-based selector.  Se vuota (default) dedurre il selettore dal replication controller o replica set.)

en: A schedule in the Cron format the job should be run with.
it_IT: Un calendario in formato Cron del lavoro che deve essere eseguito.

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.
it_IT: Indirizzo IP esterno aggiuntivo (non gestito da Kubernetes) da accettare per il servizio. Se questo IP viene indirizzato a un nodo, è possibile accedere da questo IP in aggiunta al service IP generato.

en: An inline JSON override for the generated object. If this is non-empty, it is used to override the generated object. Requires that the object supply a valid apiVersion field.
it_IT: Un override JSON inline per l'oggetto generato. Se questo non è vuoto, viene utilizzato per ignorare l'oggetto generato. Richiede che l'oggetto fornisca un campo valido apiVersion.

en: An inline JSON override for the generated service object. If this is non-empty, it is used to override the generated object. Requires that the object supply a valid apiVersion field.  Only used if --expose is true.
it_IT: Un override JSON inline per l'oggetto di servizio generato. Se questo non è vuoto, viene utilizzato per ignorare l'oggetto generato. Richiede che l'oggetto fornisca un campo valido apiVersion. Utilizzato solo se --expose è true.

en: Apply a configuration to a resource by filename or stdin
it_IT: Applica una configurazione risorsa per nomefile o stdin

en: Approve a certificate signing request
it_IT: Approva una richiesta di firma del certificato

en: Assign your own ClusterIP or set to 'None' for a 'headless' service (no loadbalancing).
it_IT: Assegnare il proprio ClusterIP o impostare su 'None' per un servizio 'headless' (nessun bilanciamento del carico).

en: Attach to a running container
it_IT: Collega a un container in esecuzione

en: Auto-scale a Deployment, ReplicaSet, or ReplicationController
it_IT: Auto-scale a Deployment, ReplicaSet, o ReplicationController

en: ClusterIP to be assigned to the service. Leave empty to auto-allocate, or set to 'None' to create a headless service.
it_IT: ClusterIP da assegnare al servizio. Lasciare vuoto per allocare automaticamente o impostare su 'None' per creare un servizio headless.

en: ClusterRole this ClusterRoleBinding should reference
it_IT: ClusterRole a cui questo ClusterRoleBinding fa riferimento

en: ClusterRole this RoleBinding should reference
it_IT: ClusterRole a cui questo RoleBinding fa riferimento

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
it_IT: Nome container che avrà la sua immagine aggiornata. Soltanto rilevante quando --image è specificato, altrimenti ignorato. Necessario quando si utilizza --image su un contenitore a più contenitori

en: Convert config files between different API versions
it_IT: Convertire i file di configurazione tra diverse versioni APIs

en: Copy files and directories to and from containers.
it_IT: Copiare file e directory da e verso i container.

en: Create a ClusterRoleBinding for a particular ClusterRole
it_IT: Crea un ClusterRoleBinding per un ClusterRole particolare

en: Create a LoadBalancer service.
it_IT: Creare un servizio LoadBalancer.

en: Create a NodePort service.
it_IT: Crea un servizio NodePort.

en: Create a RoleBinding for a particular Role or ClusterRole
it_IT: Crea un RoleBinding per un particolare Role o ClusterRole

en: Create a TLS secret
it_IT: Crea un secret TLS

en: Create a clusterIP service.
it_IT: Crea un servizio clusterIP.

en: Create a configmap from a local file, directory or literal value
it_IT: Crea un configmap da un file locale, una directory o un valore letterale

en: Create a deployment with the specified name.
it_IT: Creare un deployment con il nome specificato.

en: Create a namespace with the specified name
it_IT: Crea un namespace con il nome specificato

en: Create a pod disruption budget with the specified name.
it_IT: Crea un pod disruption budget con il nome specificato.

en: Create a quota with the specified name.
it_IT: Crea una quota con il nome specificato.

en: Create a resource by filename or stdin
it_IT: Crea una risorsa per nome file o stdin

en: Create a secret for use with a Docker registry
it_IT: Crea un secret da utilizzare con un registro Docker

en: Create a secret from a local file, directory or literal value
it_IT: Crea un secret da un file locale, una directory o un valore letterale

en: Create a secret using specified subcommand
it_IT: Crea un secret utilizzando un subcommand specificato

en: Create a service account with the specified name
it_IT: Creare un account di servizio con il nome specificato

en: Create a service using specified subcommand.
it_IT: Crea un servizio utilizzando il subcommand specificato.

en: Create an ExternalName service.
it_IT: Crea un servizio ExternalName.

en: Delete resources by filenames, stdin, resources and names, or by resources and label selector
it_IT: Elimina risorse selezionate per nomi di file, stdin, risorse e nomi, o per risorsa e selettore di label

en: Delete the specified cluster from the kubeconfig
it_IT: Elimina il cluster specificato dal kubeconfig

en: Delete the specified context from the kubeconfig
it_IT: Elimina il context specificato dal kubeconfig

en: Deny a certificate signing request
it_IT: Nega una richiesta di firma del certificato

en: Deprecated: Gracefully shut down a resource by name or filename
it_IT: Deprecated: spegne correttamente una risorsa per nome o nome file

en: Describe one or many contexts
it_IT: Descrive uno o più context

en: Display Resource (CPU/Memory) usage of nodes
it_IT: Visualizza l'utilizzo di risorse (CPU/Memoria) per nodo

en: Display Resource (CPU/Memory) usage of pods
it_IT: Visualizza l'utilizzo di risorse (CPU/Memoria) per pod.

en: Display Resource (CPU/Memory) usage.
it_IT: Visualizza l'utilizzo di risorse (CPU/Memoria).

en: Display cluster info
it_IT: Visualizza informazioni sul cluster

en: Display clusters defined in the kubeconfig
it_IT: Mostra i cluster definiti nel kubeconfig

en: Display merged kubeconfig settings or a specified kubeconfig file
it_IT: Visualizza le impostazioni merged di kubeconfig o un file kubeconfig specificato

en: Display one or many resources
it_IT: Visualizza una o più risorse

en: Displays the current-context
it_IT: Visualizza il current-context

en: Documentation of resources
it_IT: Documentazione delle risorse

en: Drain node in preparation for maintenance
it_IT: Drain node in preparazione alla manutenzione

en: Dump lots of relevant info for debugging and diagnosis
it_IT: Dump di un sacco di informazioni pertinenti per il debug e la diagnosi

en: Edit a resource on the server
it_IT: Modificare una risorsa sul server

en: Email for Docker registry
it_IT: Email per il registro Docker

en: Execute a command in a container
it_IT: Esegui un comando in un contenitore

en: Explicit policy for when to pull container images. Required when --image is same as existing image, ignored otherwise.
it_IT: Politica esplicita per il pull delle immagini container. Richiesto quando --image è uguale all'immagine esistente, altrimenti ignorata.

en: Forward one or more local ports to a pod
it_IT: Inoltra una o più porte locali a un pod

en: Help about any command
it_IT: Aiuto per qualsiasi comando

en: IP to assign to the Load Balancer. If empty, an ephemeral IP will be created and used (cloud-provider specific).
it_IT: IP da assegnare al Load Balancer. Se vuota, un IP effimero verrà creato e utilizzato (specifico per provider cloud).

en: If non-empty, set the session affinity for the service to this; legal values: 'None', 'ClientIP'
it_IT: Se non è vuoto, impostare l'affinità di sessione per il servizio; Valori validi: 'None', 'ClientIP'

en: If non-empty, the annotation update will only succeed if this is the current resource-version for the object. Only valid when specifying a single resource.
it_IT: Se non è vuoto, l'aggiornamento delle annotazioni avrà successo solo se questa è la resource-version corrente per l'oggetto. Valido solo quando si specifica una singola risorsa.

en: If non-empty, the labels update will only succeed if this is the current resource-version for the object. Only valid when specifying a single resource.
it_IT: Se non vuoto, l'aggiornamento delle label avrà successo solo se questa è la resource-version corrente per l'oggetto. Valido solo quando si specifica una singola risorsa.

en: Image to use for upgrading the replication controller. Must be distinct from the existing image (either new image or new image tag).  Can not be used with --filename/-f
it_IT: Immagine da utilizzare per aggiornare il replication controller. Deve essere diversa dall'immagine esistente (nuova immagine o nuovo tag immagine). Non può essere utilizzata con --filename/-f

en: Manage a deployment rollout
it_IT: Gestisci un deployment rollout

en: Mark node as schedulable
it_IT: Contrassegnare il nodo come programmabile

en: Mark node as unschedulable
it_IT: Contrassegnare il nodo come non programmabile

en: Mark the provided resource as paused
it_IT: Imposta la risorsa indicata in pausa

en: Modify certificate resources.
it_IT: Modificare le risorse del certificato.

en: Modify kubeconfig files
it_IT: Modifica i file kubeconfig

en: Name or number for the port on the container that the service should direct traffic to. Optional.
it_IT: Nome o numero di porta nel container verso il quale il servizio deve dirigere il traffico. Opzionale.

en: Only return logs after a specific date (RFC3339). Defaults to all logs. Only one of since-time / since may be used.
it_IT: Restituisce solo i log dopo una data specificata (RFC3339). Predefinito tutti i log. È possibile utilizzare solo uno tra data-inizio/a-partire-da.

en: Output shell completion code for the specified shell (bash or zsh)
it_IT: Codice di completamento shell di output per la shell specificata (bash o zsh)

en: Output the formatted object with the given group version (for ex: 'extensions/v1beta1').)
it_IT: Output dell'oggetto formattato con la versione del gruppo fornito (per esempio: 'extensions/v1beta1').)

en: Password for Docker registry authentication
it_IT: Password per l'autenticazione al registro di Docker

en: Path to PEM encoded public key certificate.
it_IT: Percorso certificato di chiave pubblica codificato PEM.

en: Path to private key associated with given certificate.
it_IT: Percorso alla chiave privata associata a un certificato specificato.

en: Perform a rolling update of the given ReplicationController
it_IT: Eseguire un rolling update del ReplicationController specificato

en: Precondition for resource version. Requires that the current resource version match this value in order to scale.
it_IT: Prerequisito per la versione delle risorse. Richiede che la versione corrente delle risorse corrisponda a questo valore per scalare.

en: Print the client and server version information
it_IT: Stampa per client e server le informazioni sulla versione

en: Print the list of flags inherited by all commands
it_IT: Stampa l'elenco flag ereditati da tutti i comandi

en: Print the logs for a container in a pod
it_IT: Stampa i log per container in un pod

en: Replace a resource by filename or stdin
it_IT: Sostituire una risorsa per nomefile o stdin

en: Resume a paused resource
it_IT: Riprendere una risorsa in pausa

en: Role this RoleBinding should reference
it_IT: Ruolo di riferimento per RoleBinding

en: Run a particular image on the cluster
it_IT: Esegui una particolare immagine nel cluster

en: Run a proxy to the Kubernetes API server
it_IT: Eseguire un proxy al server Kubernetes API

en: Server location for Docker registry
it_IT: Posizione del server per il Registro Docker

en: Set a new size for a Deployment, ReplicaSet, Replication Controller, or Job
it_IT: Imposta una nuova dimensione per Deployment, ReplicaSet, Replication Controller, o Job

en: Set specific features on objects
it_IT: Imposta caratteristiche specifiche sugli oggetti

en: Set the last-applied-configuration annotation on a live object to match the contents of a file.
it_IT: Imposta l'annotazione dell'ultima-configurazione-applicata ad un oggetto live per abbinare il contenuto di un file.

en: Set the selector on a resource
it_IT: Impostare il selettore di una risorsa

en: Sets a cluster entry in kubeconfig
it_IT: Imposta una voce cluster in kubeconfig

en: Sets a context entry in kubeconfig
it_IT: Imposta una voce context in kubeconfig

en: Sets a user entry in kubeconfig
it_IT: Imposta una voce utente in kubeconfig

en: Sets an individual value in a kubeconfig file
it_IT: Imposta un singolo valore in un file kubeconfig

en: Sets the current-context in a kubeconfig file
it_IT: Imposta il current-context in un file kubeconfig

en: Show details of a specific resource or group of resources
it_IT: Mostra i dettagli di una specifiche risorsa o un gruppo di risorse

en: Show the status of the rollout
it_IT: Mostra lo stato del rollout

en: Synonym for --target-port
it_IT: Sinonimo di --target-port

en: Take a replication controller, service, deployment or pod and expose it as a new Kubernetes Service
it_IT: Prende un replication controller, service, deployment o un pod e lo espone come nuovo servizio Kubernetes

en: The image for the container to run.
it_IT: L'immagine per il container da eseguire.

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
it_IT: La politica di pull dell'immagine per il container. Se lasciato vuoto, questo valore non verrà specificato dal client e predefinito dal server

en: The key to use to differentiate between two different controllers, default 'deployment'.  Only relevant when --image is specified, ignored otherwise
it_IT: La chiave da utilizzare per distinguere tra due controller diversi, predefinito "deployment". Rilevante soltanto quando --image è specificato, altrimenti ignorato

en: The minimum number or percentage of available pods this budget requires.
it_IT: Il numero minimo o la percentuale di pod disponibili che questo budget richiede.

en: The name for the newly created object.
it_IT: Il nome dell'oggetto appena creato.

en: The name for the newly created object. If not specified, the name of the input resource will be used.
it_IT: Il nome dell'oggetto appena creato. Se non specificato, verrà utilizzato il nome della risorsa di input.

en: The name of the API generator to use, see http://kubernetes.io/docs/user-guide/kubectl-conventions/#generators for a list.
it_IT: Il nome del generatore API da utilizzare, si veda http://kubernetes.io/docs/user-guide/kubectl-conventions/#generators per un elenco.

en: The name of the API generator to use. Currently there is only 1 generator.
it_IT: Il nome del generatore API da utilizzare. Attualmente c'è solo 1 generatore.

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'.
it_IT: Il nome del generatore API da utilizzare. Ci sono 2 generatori: 'service/v1' e 'service/v2'. L'unica differenza tra loro è che la porta di servizio in v1 è denominata "predefinita", mentre viene lasciata unnamed in v2. Il valore predefinito è 'service/v2'.

en: The name of the generator to use for creating a service.  Only used if --expose is true
it_IT: Il nome del generatore da utilizzare per la creazione di un servizio. Utilizzato solo se --expose è true

en: The network protocol for the service to be created. Default is 'TCP'.
it_IT: Il protocollo di rete per il servizio da creare. Il valore predefinito è 'TCP'.

en: The port that the service should serve on. Copied from the resource being exposed, if unspecified
it_IT: La porta che il servizio deve servire. Copiato dalla risorsa esposta, se non specificata

en: The port that this container exposes.  If --expose is true, this is also the port used by the service that is created.
it_IT: La porta che questo contenitore espone. Se --expose è true, questa è anche la porta utilizzata dal servizio creato.

en: The resource requirement limits for this container.  For example, 'cpu=200m,memory=512Mi'.  Note that server side components may assign limits depending on the server configuration, such as limit ranges.
it_IT: I limiti delle richieste di risorse per questo contenitore.  Ad esempio, 'cpu=200m,memory=512Mi'. Si noti che i componenti lato server possono assegnare i limiti a seconda della configurazione del server, ad esempio intervalli di limiti.

en: The resource requirement requests for this container.  For example, 'cpu=100m,memory=256Mi'.  Note that server side components may assign requests depending on the server configuration, such as limit ranges.
it_IT: La risorsa necessita di richieste di requisiti per questo pod. Ad esempio, 'cpu = 100m, memoria = 256Mi'. Si noti che i componenti lato server possono assegnare i requisiti a seconda della configurazione del server, ad esempio intervalli di limiti.

en: The restart policy for this Pod.  Legal values [Always, OnFailure, Never].  If set to 'Always' a deployment is created, if set to 'OnFailure' a job is created, if set to 'Never', a regular pod is created. For the latter two --replicas must be 1.  Default 'Always', for CronJobs `Never`.
it_IT: La politica di riavvio per questo Pod. Valori accettati [Always, OnFailure, Never]. Se impostato su 'Always' viene creato un deployment, se impostato su 'OnFailure' viene creato un job, se impostato su 'Never', viene creato un pod. Per questi ultimi due le - repliche devono essere 1. Predefinito 'Always', per CronJobs `Never`.

en: The type of secret to create
it_IT: Tipo di segreto da creare

en: Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is 'ClusterIP'.
it_IT: Digitare per questo servizio: ClusterIP, NodePort o LoadBalancer. Ppredefinito è 'ClusterIP'.

en: Undo a previous rollout
it_IT: Annulla un precedente rollout

en: Unsets an individual value in a kubeconfig file
it_IT: Annulla singolo valore in un file kubeconfig

en: Update field(s) of a resource using strategic merge patch
it_IT: Aggiornare campo/i risorsa utilizzando merge patch strategici

en: Update image of a pod template
it_IT: Aggiorna immagine di un pod template

en: Update resource requests/limits on objects with pod templates
it_IT: Aggiorna richieste di risorse/limiti sugli oggetti con pod template

en: Update the annotations on a resource
it_IT: Aggiorna annotazioni di risorsa

en: Update the labels on a resource
it_IT: Aggiorna label di una risorsa

en: Update the taints on one or more nodes
it_IT: Aggiorna i taints su uno o più nodi

en: Username for Docker registry authentication
it_IT: Nome utente per l'autenticazione nel registro Docker

en: View latest last-applied-configuration annotations of a resource/object
it_IT: Visualizza ultime annotazioni dell'ultima configurazione applicata per risorsa/oggetto

en: View rollout history
it_IT: Visualizza la storia del rollout

en: Where to output the files.  If empty or '-' uses stdout, otherwise creates a directory hierarchy in that directory
it_IT: Dove eseguire l'output dei file. Se vuota o '-' utilizza lo stdout, altrimenti crea una gerarchia di directory in quella directory

en: dummy restart flag)
it_IT: flag di riavvio finto)

en: external name of service
it_IT: nome esterno del servizio

en: kubectl controls the Kubernetes cluster manager
it_IT: Kubectl controlla il gestore cluster di Kubernetes
