t9
E
Qzq_
L
k
\k
>
4!s"o
w$H%g0+-q
/
&1
246\7:
==g?;??<BPBS=C<C
C{E
H
zJ
uLc
PNT
O	Q
WY\_
`
Dbc<d=OddgTe.g1ggkQkRk"*lXMl4n}nk
Yopf
Gxy4z{
{2Q

q
D



{X.X̙%%oKu

1v3t}j
;81*7\u
[Jabī918%AWg=ݯu4-ư32̱88W9r@ܲ,*J7u'&ճ.=+*i0,Ŵ]0p0"ҵ?5,S+$Ѷ*ASq)6ӷ
( Bvc(ڸp` ɻ$>\atsּBJY++6?;vq/$1T''ֿ&%(<#eK _V"u"--	97qc#2HJ&ez JWE$ajvC
Tp/9=$Ot&+G/rD/
*w/
vZ

oz
|
L
_~
fjP#

	j+tbC
EF_As

K

P

=R


)d

	





W
0

#k






 

"
$
=$
>$
%
%
/(
(
h{,
S,
T8-
(-
-
5u0
0

.1
^2
}
&;
<

8=
X>
FE?
D
+J
1J
J

M

O

mQ
'
R

T
=
V

\W
cY
[

_\
a_
^`
Nj`
ub
}/c
)
c
d
}ce

e
f
smg

g
i
;m
8"n
2[n
9n
n
q
pgr
]r
l6s
s
B^t
t
lu
"v
7	w
.Aw
rpw
$w
<x
Ex
:x
3y
;y
=z
0@z
9qz
 z
z
9z
!{
4{
HP{
-{
){
6{
'(|
&P|
3w|
E|
4|
5&}
7\}
}
g}
-~
-I~
+w~
A~
~
7

79
/q
#
(
P
?
]
{
,
Fŀ
!
.
#K
o
(
!
u=
e

΃
z
;
)Z
-
$
&ׅ

e

M
ga
3ɇ
7
D5
@z

9@
1z
$
+щ

$
+B
*n
+
VŊ
0
sM
%
&
&
%5
/[
0
B


i5
(
ȍ
X
P
#M
iq
ۏ
Ma


i
P
Xn
uǒ
=
+
H
$
m
^

,
=1
$o
C
ؗ

$
4;
Vp
 ǘ

k

2

^\F-c1o}JUu*yCr+6h;z/V!~lsg#SG$Xm	xk<E:&[Ie>?Y'45(O )Z"v]aj8qt_@,{iLw=N%9.P
RDBn
WQdK2fA`M70H|3Tbp
		  # 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
		  # Create a RoleBinding for user1, user2, and group1 using the admin ClusterRole
		  kubectl create rolebinding admin --clusterrole=admin --user=user1 --user=user2 --group=group1
		  # 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
		  # 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
		  # Show metrics for all nodes
		  kubectl top node

		  # Show metrics for a given node
		  kubectl top node NODE_NAME
		# 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
		# 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
		# 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 -
		# 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
		# 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
		# 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
		# 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%
		# 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
		# 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
		# 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
		# 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
		# 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
		# 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
		# 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
		# 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
		
		# 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
		# 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)
		# 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
		# 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
		# Mark node "foo" as schedulable.
		$ kubectl uncordon foo
		# Mark node "foo" as unschedulable.
		kubectl cordon foo
		# 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"}]'
		# Print flags inherited by all commands
		kubectl options
		# Print the address of the master and cluster services
		kubectl cluster-info
		# Print the client and server versions for the current context
		kubectl version
		# Print the supported API versions
		kubectl api-versions
		# 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
		# 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
		# 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
		# 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
		# 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
		
		# 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
		# 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
		# 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)'
		# 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-
		# 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-
		# 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
		# 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
		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.
		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.
		Create a ClusterRole.
		Create a ClusterRoleBinding for a particular ClusterRole.
		Create a RoleBinding for a particular Role or ClusterRole.
		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.
		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).
		Create a namespace with the specified name.
		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.
		Create a pod disruption budget with the specified name, selector, and desired minimum available pods
		Create a resource by filename or stdin.

		JSON and YAML formats are accepted.
		Create a resourcequota with the specified name, hard limits and optional scopes
		Create a role with single rule.
		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).
		Create a service account with the specified name.
		Create and run a particular image, possibly replicated.

		Creates a deployment or job to manage the created container(s).
		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.
		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.
		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.
		Display Resource (CPU/Memory/Storage) usage of nodes.

		The top-node command allows you to see the resource consumption of nodes.
		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.
		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. 
		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)
		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.
		Mark node as schedulable.
		Mark node as unschedulable.
		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
		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)
		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.
		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.
		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.
		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'
		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.
		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.
		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.
		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.
	    # !!!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
	  # 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
	  # Create a new namespace named my-namespace
	  kubectl create namespace my-namespace
	  # 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
	  # Create a new service account named my-service-account
	  kubectl create serviceaccount my-service-account
	# Create a new ExternalName service named my-ns 
	kubectl create service externalname my-ns --external-name bar.com
	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.
	Help provides help for any command in the application.
	Simply type kubectl help [path to command] for full details.
    # Create a new LoadBalancer service named my-lbs
    kubectl create service loadbalancer my-lbs --tcp=5678:8080
    # 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"
    # Create a new deployment named my-dep that runs the busybox image.
    kubectl create deployment my-dep --image=busybox
    # Create a new nodeport service named my-ns
    kubectl create service nodeport my-ns --tcp=5678:8080
    # 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
    # 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-
    Create a LoadBalancer service with the specified name.
    Create a clusterIP service with the specified name.
    Create a deployment with the specified name.
    Create a nodeport service with the specified name.
    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.
  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'.A comma-delimited set of quota scopes that must all match each object tracked by the quota.A comma-delimited set of resource=quantity pairs that define a hard limit.A label selector to use for this budget. Only equality-based selector requirements are supported.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.)A schedule in the Cron format the job should be run with.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.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.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.Apply a configuration to a resource by filename or stdinApprove a certificate signing requestAssign your own ClusterIP or set to 'None' for a 'headless' service (no loadbalancing).Attach to a running containerAuto-scale a Deployment, ReplicaSet, or ReplicationControllerClusterIP to be assigned to the service. Leave empty to auto-allocate, or set to 'None' to create a headless service.ClusterRole this ClusterRoleBinding should referenceClusterRole this RoleBinding should referenceContainer name which will have its image upgraded. Only relevant when --image is specified, ignored otherwise. Required when using --image on a multi-container podConvert config files between different API versionsCopy files and directories to and from containers.Create a ClusterRoleBinding for a particular ClusterRoleCreate a LoadBalancer service.Create a NodePort service.Create a RoleBinding for a particular Role or ClusterRoleCreate a TLS secretCreate a clusterIP service.Create a configmap from a local file, directory or literal valueCreate a deployment with the specified name.Create a namespace with the specified nameCreate a pod disruption budget with the specified name.Create a quota with the specified name.Create a resource by filename or stdinCreate a secret for use with a Docker registryCreate a secret from a local file, directory or literal valueCreate a secret using specified subcommandCreate a service account with the specified nameCreate a service using specified subcommand.Create an ExternalName service.Delete resources by filenames, stdin, resources and names, or by resources and label selectorDelete the specified cluster from the kubeconfigDelete the specified context from the kubeconfigDeny a certificate signing requestDeprecated: Gracefully shut down a resource by name or filenameDescribe one or many contextsDisplay Resource (CPU/Memory) usage of nodesDisplay Resource (CPU/Memory) usage of podsDisplay Resource (CPU/Memory) usage.Display cluster infoDisplay clusters defined in the kubeconfigDisplay merged kubeconfig settings or a specified kubeconfig fileDisplay one or many resourcesDisplays the current-contextDocumentation of resourcesDrain node in preparation for maintenanceDump lots of relevant info for debugging and diagnosisEdit a resource on the serverEmail for Docker registryExecute a command in a containerExplicit policy for when to pull container images. Required when --image is same as existing image, ignored otherwise.Forward one or more local ports to a podHelp about any commandIP to assign to the Load Balancer. If empty, an ephemeral IP will be created and used (cloud-provider specific).If non-empty, set the session affinity for the service to this; legal values: 'None', 'ClientIP'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.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.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/-fManage a deployment rolloutMark node as schedulableMark node as unschedulableMark the provided resource as pausedModify certificate resources.Modify kubeconfig filesName or number for the port on the container that the service should direct traffic to. Optional.Only return logs after a specific date (RFC3339). Defaults to all logs. Only one of since-time / since may be used.Output shell completion code for the specified shell (bash or zsh)Output the formatted object with the given group version (for ex: 'extensions/v1beta1').)Password for Docker registry authenticationPath to PEM encoded public key certificate.Path to private key associated with given certificate.Perform a rolling update of the given ReplicationControllerPrecondition for resource version. Requires that the current resource version match this value in order to scale.Print the client and server version informationPrint the list of flags inherited by all commandsPrint the logs for a container in a podReplace a resource by filename or stdinResume a paused resourceRole this RoleBinding should referenceRun a particular image on the clusterRun a proxy to the Kubernetes API serverServer location for Docker registrySet a new size for a Deployment, ReplicaSet, Replication Controller, or JobSet specific features on objectsSet the last-applied-configuration annotation on a live object to match the contents of a file.Set the selector on a resourceSets a cluster entry in kubeconfigSets a context entry in kubeconfigSets a user entry in kubeconfigSets an individual value in a kubeconfig fileSets the current-context in a kubeconfig fileShow details of a specific resource or group of resourcesShow the status of the rolloutSynonym for --target-portTake a replication controller, service, deployment or pod and expose it as a new Kubernetes ServiceThe image for the container to run.The image pull policy for the container. If left empty, this value will not be specified by the client and defaulted by the serverThe key to use to differentiate between two different controllers, default 'deployment'.  Only relevant when --image is specified, ignored otherwiseThe minimum number or percentage of available pods this budget requires.The name for the newly created object.The name for the newly created object. If not specified, the name of the input resource will be used.The name of the API generator to use, see http://kubernetes.io/docs/user-guide/kubectl-conventions/#generators for a list.The name of the API generator to use. Currently there is only 1 generator.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'.The name of the generator to use for creating a service.  Only used if --expose is trueThe network protocol for the service to be created. Default is 'TCP'.The port that the service should serve on. Copied from the resource being exposed, if unspecifiedThe port that this container exposes.  If --expose is true, this is also the port used by the service that is created.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.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.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`.The type of secret to createType for this service: ClusterIP, NodePort, or LoadBalancer. Default is 'ClusterIP'.Undo a previous rolloutUnsets an individual value in a kubeconfig fileUpdate field(s) of a resource using strategic merge patchUpdate image of a pod templateUpdate resource requests/limits on objects with pod templatesUpdate the annotations on a resourceUpdate the labels on a resourceUpdate the taints on one or more nodesUsername for Docker registry authenticationView latest last-applied-configuration annotations of a resource/objectView rollout historyWhere to output the files.  If empty or '-' uses stdout, otherwise creates a directory hierarchy in that directorydummy restart flag)external name of servicekubectl controls the Kubernetes cluster managerProject-Id-Version: kubernetes
Report-Msgid-Bugs-To: EMAIL
POT-Creation-Date: 2017-03-14 21:32-0700
PO-Revision-Date: 2017-08-28 15:20+0200
Language: it_IT
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Plural-Forms: nplurals=2; plural=(n != 1);
Last-Translator: Luca Berton <mr.evolution85@gmail.com>
Language-Team: Luca Berton <mr.evolution85@gmail.com>
X-Generator: Poedit 1.8.7.1
X-Poedit-SourceCharset: UTF-8

		 # 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
		  # Crea un RoleBinding per user1, user2, and group1 utilizzando l'admin ClusterRole
		  kubectl create rolebinding admin --clusterrole=admin --user=user1 --user=user2 --group=group1
		  # 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
		  # 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
		  # Mostra metriche per tutti i nodi
		 kubectl top node

		 # Mostra metriche per un determinato nodo
		 kubectl top node NODE_NAME
		# 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
		#  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
		# 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 -
		# 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
		# 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
		# 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
		# 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%
		# 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
		# 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
		# 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
		# 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
		# 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
		# 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
		# 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
		# 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
		
		# 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
		# 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)
		# 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
		# 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
		# Segna il nodo "foo" come programmabile.
		$ Kubectl uncordon foo
		#  Segna il nodo "foo" come non programmabile.
		kubectl cordon foo
		# 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"}]'
		# Stampa i flag ereditati da tutti i comandi
		kubectl options
		# Stampa l'indirizzo dei servizi master e cluster
		kubectl cluster-info
		# Stampa le versioni client e server per il current context
		kubectl version
		# Stampa le versioni API supportate
		kubectl api-versions
		# 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
		# 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
		# 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
		# 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
		# 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
		
		# 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
		# 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
		# 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)'
		# 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-
		# 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-
		# 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
		# 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
		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.
		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.
	
Crea un ClusterRole.
		Crea un ClusterRoleBinding per un ClusterRole particolare.
		Crea un RoleBinding per un particolare Ruolo o ClusterRole.
		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.
		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).
		Creare un namespace con il nome specificato.
		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.
		Crea un pod disruption budget con il nome specificato, selector e il numero minimo di pod disponibili
		Crea una risorsa per nome file o stdin.

		Sono accettati i formati JSON e YAML.
		Crea una resourcequota con il nome specificato, hard limits e gli scope opzionali
		Crea un ruolo con una singola regola.
		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).
		Creare un service account con il nome specificato.
		Crea ed esegue un'immagine particolare, eventualmente replicata.

		Crea un deployment o un job per gestire i container creati.
		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.
		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.
		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.
		Visualizza l'utilizzo di risorse (CPU/Memoria/Storage) dei nodi.

		Il comando top-node consente di visualizzare il consumo di risorse dei nodi.
		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.
		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.
		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)
		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.
		Contrassegna il nodo come programmabile.
		Contrassegnare il nodo come non programmabile.
		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
		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)
		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.
		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..
		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.
		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'
		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.
		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.
		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.
		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.
	    #  !!!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
	  # 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
	  # Crea un nuovo namespace denominato my-namespace
	  kubectl create namespace my-namespace
	  # 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
	  # Crea un nuovo service account denominato my-service-account
	  kubectl create serviceaccount my-service-account
	#  Crea un nuovo servizio ExternalName denominato my-ns 
	kubectl create service externalname my-ns --external-name bar.com
	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..
	Help fornisce assistenza per qualsiasi comando nell'applicazione.
	Basta digitare kubectl help [path to command] per i dettagli completi.
    # Creare un nuovo servizio LoadBalancer denominato my-lbs
    kubectl create service loadbalancer my-lbs --tcp=5678:8080
    # 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"
    # Crea una nuovo deployment chiamato my-dep che esegue l'immagine busybox.
    kubectl create deployment my-dep --image=busybox
    # Creare un nuovo servizio nodeport denominato my-ns
    kubectl create service nodeport my-ns --tcp=5678:8080
    # 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
    # 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-
    Crea un servizio LoadBalancer con il nome specificato.
    Crea un servizio clusterIP con il nome specificato.
    Creare un deployment con il nome specificato.
    Creare un servizio nodeport con il nome specificato.
    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.
  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'.Un insieme delimitato-da-virgole di quota scopes che devono corrispondere a ciascun oggetto gestito dalla quota.Un insieme delimitato-da-virgola di coppie risorsa = quantità che definiscono un hard limit.Un label selector da utilizzare per questo budget. Sono supportati solo i selettori equality-based selector.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.)Un calendario in formato Cron del lavoro che deve essere eseguito.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.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.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.Applica una configurazione risorsa per nomefile o stdinApprova una richiesta di firma del certificatoAssegnare il proprio ClusterIP o impostare su 'None' per un servizio 'headless' (nessun bilanciamento del carico).Collega a un container in esecuzioneAuto-scale a Deployment, ReplicaSet, o ReplicationControllerClusterIP da assegnare al servizio. Lasciare vuoto per allocare automaticamente o impostare su 'None' per creare un servizio headless.ClusterRole a cui questo ClusterRoleBinding fa riferimentoClusterRole a cui questo RoleBinding fa riferimentoNome container che avrà la sua immagine aggiornata. Soltanto rilevante quando --image è specificato, altrimenti ignorato. Necessario quando si utilizza --image su un contenitore a più contenitoriConvertire i file di configurazione tra diverse versioni APIsCopiare file e directory da e verso i container.Crea un ClusterRoleBinding per un ClusterRole particolareCreare un servizio LoadBalancer.Crea un servizio NodePort.Crea un RoleBinding per un particolare Role o ClusterRoleCrea un secret TLSCrea un servizio clusterIP.Crea un configmap da un file locale, una directory o un valore letteraleCreare un deployment con il nome specificato.Crea un namespace con il nome specificatoCrea un pod disruption budget con il nome specificato.Crea una quota con il nome specificato.Crea una risorsa per nome file o stdinCrea un secret da utilizzare con un registro DockerCrea un secret da un file locale, una directory o un valore letteraleCrea un secret utilizzando un subcommand specificatoCreare un account di servizio con il nome specificatoCrea un servizio utilizzando il subcommand specificato.Crea un servizio ExternalName.Elimina risorse selezionate per nomi di file, stdin, risorse e nomi, o per risorsa e selettore di labelElimina il cluster specificato dal kubeconfigElimina il context specificato dal kubeconfigNega una richiesta di firma del certificatoDeprecated: spegne correttamente una risorsa per nome o nome fileDescrive uno o più contextVisualizza l'utilizzo di risorse (CPU/Memoria) per nodoVisualizza l'utilizzo di risorse (CPU/Memoria) per pod.Visualizza l'utilizzo di risorse (CPU/Memoria).Visualizza informazioni sul clusterMostra i cluster definiti nel kubeconfigVisualizza le impostazioni merged di kubeconfig o un file kubeconfig specificatoVisualizza una o più risorseVisualizza il current-contextDocumentazione delle risorseDrain node in preparazione alla manutenzioneDump di un sacco di informazioni pertinenti per il debug e la diagnosiModificare una risorsa sul serverEmail per il registro DockerEsegui un comando in un contenitorePolitica esplicita per il pull delle immagini container. Richiesto quando --image è uguale all'immagine esistente, altrimenti ignorata.Inoltra una o più porte locali a un podAiuto per qualsiasi comandoIP da assegnare al Load Balancer. Se vuota, un IP effimero verrà creato e utilizzato (specifico per provider cloud).Se non è vuoto, impostare l'affinità di sessione per il servizio; Valori validi: 'None', 'ClientIP'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.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.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/-fGestisci un deployment rolloutContrassegnare il nodo come programmabileContrassegnare il nodo come non programmabileImposta la risorsa indicata in pausaModificare le risorse del certificato.Modifica i file kubeconfigNome o numero di porta nel container verso il quale il servizio deve dirigere il traffico. Opzionale.Restituisce solo i log dopo una data specificata (RFC3339). Predefinito tutti i log. È possibile utilizzare solo uno tra data-inizio/a-partire-da.Codice di completamento shell di output per la shell specificata (bash o zsh)Output dell'oggetto formattato con la versione del gruppo fornito (per esempio: 'extensions/v1beta1').)Password per l'autenticazione al registro di DockerPercorso certificato di chiave pubblica codificato PEM.Percorso alla chiave privata associata a un certificato specificato.Eseguire un rolling update del ReplicationController specificatoPrerequisito per la versione delle risorse. Richiede che la versione corrente delle risorse corrisponda a questo valore per scalare.Stampa per client e server le informazioni sulla versioneStampa l'elenco flag ereditati da tutti i comandiStampa i log per container in un podSostituire una risorsa per nomefile o stdinRiprendere una risorsa in pausaRuolo di riferimento per RoleBindingEsegui una particolare immagine nel clusterEseguire un proxy al server Kubernetes APIPosizione del server per il Registro DockerImposta una nuova dimensione per Deployment, ReplicaSet, Replication Controller, o JobImposta caratteristiche specifiche sugli oggettiImposta l'annotazione dell'ultima-configurazione-applicata ad un oggetto live per abbinare il contenuto di un file.Impostare il selettore di una risorsaImposta una voce cluster in kubeconfigImposta una voce context in kubeconfigImposta una voce utente in kubeconfigImposta un singolo valore in un file kubeconfigImposta il current-context in un file kubeconfigMostra i dettagli di una specifiche risorsa o un gruppo di risorseMostra lo stato del rolloutSinonimo di --target-portPrende un replication controller, service, deployment o un pod e lo espone come nuovo servizio KubernetesL'immagine per il container da eseguire.La politica di pull dell'immagine per il container. Se lasciato vuoto, questo valore non verrà specificato dal client e predefinito dal serverLa chiave da utilizzare per distinguere tra due controller diversi, predefinito "deployment". Rilevante soltanto quando --image è specificato, altrimenti ignoratoIl numero minimo o la percentuale di pod disponibili che questo budget richiede.Il nome dell'oggetto appena creato.Il nome dell'oggetto appena creato. Se non specificato, verrà utilizzato il nome della risorsa di input.Il nome del generatore API da utilizzare, si veda http://kubernetes.io/docs/user-guide/kubectl-conventions/#generators per un elenco.Il nome del generatore API da utilizzare. Attualmente c'è solo 1 generatore.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'.Il nome del generatore da utilizzare per la creazione di un servizio. Utilizzato solo se --expose è trueIl protocollo di rete per il servizio da creare. Il valore predefinito è 'TCP'.La porta che il servizio deve servire. Copiato dalla risorsa esposta, se non specificataLa porta che questo contenitore espone. Se --expose è true, questa è anche la porta utilizzata dal servizio creato.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.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.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`.Tipo di segreto da creareDigitare per questo servizio: ClusterIP, NodePort o LoadBalancer. Ppredefinito è 'ClusterIP'.Annulla un precedente rolloutAnnulla singolo valore in un file kubeconfigAggiornare campo/i risorsa utilizzando merge patch strategiciAggiorna immagine di un pod templateAggiorna richieste di risorse/limiti sugli oggetti con pod templateAggiorna annotazioni di risorsaAggiorna label di una risorsaAggiorna i taints su uno o più nodiNome utente per l'autenticazione nel registro DockerVisualizza ultime annotazioni dell'ultima configurazione applicata per risorsa/oggettoVisualizza la storia del rolloutDove eseguire l'output dei file. Se vuota o '-' utilizza lo stdout, altrimenti crea una gerarchia di directory in quella directoryflag di riavvio finto)nome esterno del servizioKubectl controlla il gestore cluster di Kubernetes