kubernetes.cli.txt

                                  ┏━━━━━━━━━━━━━━━━┓
                                  ┃   KUBERNETES   ┃
                                  ┗━━━━━━━━━━━━━━━━┛

                                  ┌─────────────┐
                                  │   VERSION   │
                                  └─────────────┘

VERSION ==>                                       #1.4.6

VERSION                                           #Different API versions offer different possible entities:
                                                  #  - batch/v1: only Job
                                                  #  - autoscaling/v1: only HorizontalPodAutoscaler
                                                  #  - v1beta1: Job, HorizontalPodAutoscaler, Deployment, ReplicaSet, DaemonSet, Ingress, NetworkPolicy, ThirdPartyResource, Scale
                                                  #  - v1: everything else
                                                  #Can query:
                                                  #  - GET HOST/api[s] or kubectl api[-]versions: available versions
                                                  #  - GET HOST/version: current Git version

RESC[_LIST].apiVersion                            #Required

kubectl version                                   #Print the client and server version information
-c
--client BOOL                                     #Client version only (no server required). Def: false


kubectl create|run|set image|explain|edit|delete|
 rolling-update|scale|autoscale|cluster-info|
 taint|describe|log|apply|patch|replace|convert|
 label|annotate ...                               #
--include-extended-apis BOOL                      #If true (def), include definitions of new APIs via calls to the API server.

kubectl ...                                       #
--match-server-version BOOL                       #Require server version to match client version. Def: false

kubeadm init ...
--use-kubernetes-version STR                      #Choose a specific Kubernetes version for the control plane (default "v1.4.4")

kubectl convert                                   #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.
                                                  #--filename is required

kube-apiserver ...
--storage-versions STR,...                        #The per-group version to store resources in.
                                                  #Specified in the format "group1/version1,group2/version2,...".
                                                  #In the case where objects are moved from one group to the other, you may specify the format "group1=group2/v1beta1,group3/v1beta1,...".
                                                  #You only need to pass the groups you wish to change from the defaults. 
                                                  #It defaults to a list of preferred versions of all registered groups, which is derived from the KUBE_API_VERSIONS environment variable. 
                                                  #(default "apps/v1alpha1,authentication.k8s.io/v1beta1,authorization.k8s.io/v1beta1,autoscaling/v1,batch/v1,certificates.k8s.io/v1alpha1,
                                                  #componentconfig/v1alpha1,extensions/v1beta1,imagepolicy.k8s.io/v1alpha1,policy/v1alpha1,rbac.authorization.k8s.io/v1alpha1,storage.k8s.io/v1beta1,v1")

minikube start ...                                #
--kubernetes-version STR                          #Def: "v1.4.3"

                                  ┌────────────────┐
                                  │   GENERATORS   │
                                  └────────────────┘

kubectl create|expose|run|autoscale ...           #
--generator "GENERATOR"                           #The name of the API generator to use:
                                                  #  - create: configmap|deployment-basic|namespace|resourcequotas|secret-for-docker-registry|secret|secret-for-tls|service-cluster|service-loadbalancer|
                                                  #    service-nodeport|serviceaccount/v1
                                                  #  - expose: service/v1 (service port is "default") or service/v2 (service port is unnamed) (def)
                                                  #  - run: default is according to --restart:
                                                  #     - Always: 'deployment/v1beta1'
                                                  #     - OnFailure: 'job/v1'
                                                  #     - Never: 'run-pod/v1'
                                                  #  - autoscale: 'horizontalpodautoscaler/v1' (only choice)
kubectl run ...
--service-generator STR                           #The name of the generator to use for creating a service.
                                                  #Only used if --expose is true
                                                  #Def: 'service/v2'

                                  ┌─────────────┐
                                  │   KUBEADM   │
                                  └─────────────┘

http://kubernetes.io/docs/getting-started-guides/kubeadm/
http://kubernetes.io/docs/admin/kubeadm/


kubeadm                                           #Easily bootstrap a secure Kubernetes cluster

kubeadm init                                      #Run this in order to set up the Kubernetes master
--api-advertise-addresses IP                      #The IP addresses to advertise, in case autodetection fails
--api-port NUM                                    #Port for API to bind to (default 6443)
--discovery-port NUM                              #Port for JWS discovery service to bind to (default 9898)
--pod-network-cidr CIDR                           #Specify range of IP addresses for the pod network; if set, the control plane will automatically allocate CIDRs for every node
--service-cidr CIDR                               #Use alternative range of IP address for service VIPs (default "10.96.0.0/12")
--token STR                                       #Shared secret used to secure cluster bootstrap; if none is provided, one will be generated for you
--config FILE                                     #Path to kubeadm config file

kubeadm join                                      #Run this on any machine you wish to join an existing cluster
--config FILE                     
--api-port NUM                    
--discovery-port NUM              
--token STR                                       #See kubeadm init

kubeadm reset                                     #Run this to revert any changes made to this host by 'kubeadm init' or 'kubeadm join'.

kubeadm init|join|reset
--skip-preflight-checks                           #Skip preflight checks normally run before modifying the system

                                  ┌─────────────────────┐
                                  │   CLOUD PROVIDERS   │
                                  └─────────────────────┘

kubelet|kubeadm init|kube-apiserver|
 controller-manager ...                           #
--cloud-provider STR                              #The provider for cloud services.
                                                  #Enable cloud provider features (external load-balancers, storage, etc), e.g. "gce"
                                                  #By default, will attempt to auto-detect the cloud provider. 
                                                  #Specify empty string for running with no cloud provider. [default=auto-detect] (default "auto-detect")
kubelet|kube-apiserver|controller-manager ...
--cloud-config FILE                               #The path to the cloud provider configuration file. 
                                                  #Empty string for no configuration file.

kubelet|kube-proxy|apiserver|controller-manager|
 scheduler ...                                    #
--google-json-key STR                             #The Google Cloud Platform Service Account JSON Key to use for authentication.


kube-controller-manager ...                       #
--allocate-node-cidrs                             #Should CIDRs for Pods be allocated and set on the cloud provider.
--configure-cloud-routes                          #Should CIDRs allocated by allocate-node-cidrs be configured on the cloud provider. (default true)
--node-cidr-mask-size NUM                         #Mask size for node cidr in cluster. (default 24)
--enable-dynamic-provisioning                     #Enable dynamic provisioning for environments that support it. (default true)
--enable-hostpath-provisioner                     #Enable HostPath PV provisioning when running without a cloud provider.
                                                  #This allows testing and development of provisioning features.
                                                  #HostPath provisioning is not supported in any way, won't work in a multi-node cluster,
                                                  #and should not be used for anything other than testing or development.

                                  ┌────────────────────┐
                                  │   KUBE-APISERVER   │
                                  └────────────────────┘

kube-apiserver                                    #The Kubernetes API server validates and configures data for the api objects which include pods, services, replicationcontrollers, and others.
                                                  #The API Server services REST operations and provides the frontend to the cluster’s shared state through which all other components interact.

                                  ┌────────────────────┐
                                  │   KUBE-SCHEDULER   │
                                  └────────────────────┘

http://kubernetes.io/docs/admin/multiple-schedulers/


kube-scheduler                                    #The Kubernetes scheduler is a policy-rich, topology-aware, workload-specific function that significantly impacts 
                                                  #availability, performance, and capacity. 
                                                  #The scheduler needs to take into account individual and collective resource requirements, quality of service requirements, 
                                                  #hardware/software/policy constraints, affinity and anti-affinity specifications, data locality, inter-workload interference, deadlines, and so on. 
                                                  #Workload-specific requirements will be exposed through the API as necessary.
--scheduler-name NAME                             #Name of the scheduler, used to select which pods will be processed by this scheduler, 
                                                  #based on pod's annotation with key 'scheduler.alpha.kubernetes.io/name' (default "default-scheduler")
--policy-config-file PATH                         #File with scheduler policy configuration
--algorithm-provider STR                          #The scheduling algorithm provider to use, one of: DefaultProvider | ClusterAutoscalerProvider (default "DefaultProvider")
--failure-domains STR                             #Indicate the "all topologies" set for an empty topologyKey when it's used for PreferredDuringScheduling pod anti-affinity. 
                                                  #(default "kubernetes.io/hostname,failure-domain.beta.kubernetes.io/zone,failure-domain.beta.kubernetes.io/region")
--hard-pod-affinity-symmetric-weight NUM          #RequiredDuringScheduling affinity is not symmetric, but there is an implicit PreferredDuringScheduling affinity rule 
                                                  #corresponding to every RequiredDuringScheduling affinity rule. 
                                                  #--hard-pod-affinity-symmetric-weight represents the weight of implicit PreferredDuringScheduling affinity rule. (default 1)

                                  ┌─────────────────────────────┐
                                  │   KUBE-CONTROLLER-MANAGER   │
                                  └─────────────────────────────┘

kube-controller-manager                           #The Kubernetes controller manager is a daemon that embeds the core control loops shipped with Kubernetes.
                                                  #In applications of robotics and automation, a control loop is a non-terminating loop that regulates the state of the system.
                                                  #In Kubernetes, a controller is a control loop that watches the shared state of the cluster through the apiserver and makes changes 
                                                  #attempting to move the current state towards the desired state.
                                                  #Examples of controllers that ship with Kubernetes today are the replication controller, endpoints controller, namespace controller, 
                                                  #and serviceaccounts controller.
--controller-start-interval DUR                   #Interval between starting controller managers. (default 0s)

                                  ┌──────────┐
                                  │   ETCD   │
                                  └──────────┘

kube-apiserver ...                                #
--etcd-cafile PATH                                #SSL Certificate Authority file used to secure etcd communication.
--etcd-certfile PATH                              #SSL certification file used to secure etcd communication.
--etcd-keyfile PATH                               #SSL key file used to secure etcd communication.
--etcd-prefix STR                                 #The prefix for all resource paths in etcd. (default "/registry")
--etcd-quorum-read                                #If true, enable quorum read.
--etcd-servers ORIGIN,...                         #List of etcd servers to connect with (http://ip:port), comma separated. (default [])
--etcd-servers-overrides ORIGIN,...               #Per-resource etcd servers overrides, comma separated.
                                                  #The individual override format: group/resource#servers, where servers are http://ip:port, semicolon separated. (default [])

kube-apiserver ...
--storage-backend STR                             #The storage backend for persistence.
                                                  #Options: 'etcd2' (default), 'etcd3'.
--storage-media-type TYPE                         #The media type to use to store objects in storage.
                                                  #Some resources may only support a specific media type and will ignore this setting. (default "application/json")

                                  ┌─────────────┐
                                  │   KUBELET   │
                                  └─────────────┘

kubelet                                           #Server
                                                  #The kubelet is the primary "node agent" that runs on each node. 
                                                  #The kubelet works in terms of a PodSpec. 
                                                  #A PodSpec is a YAML or JSON object that describes a pod. 
                                                  #The kubelet takes a set of PodSpecs that are provided through various mechanisms (primarily through the apiserver)
                                                  #and ensures that the containers described in those PodSpecs are running and healthy. 
                                                  #The kubelet doesn't manage containers which were not created by Kubernetes.
                                                  #Other than from an PodSpec from the apiserver, there are three ways that a container manifest can be provided to the Kubelet.
                                                  #File: Path passed as a flag on the command line. This file is rechecked every 20 seconds (configurable with a flag).
                                                  #HTTP endpoint: HTTP endpoint passed as a parameter on the command line. This endpoint is checked every 20 seconds (also configurable with a flag).
                                                  #HTTP server: The kubelet can also listen for HTTP and respond to a simple API (underspec'd currently) to submit a new manifest.
--runonce                                         #If true, exit after spawning pods from local manifests or remote urls. Exclusive with --api-servers, and --enable-server
--enable-server                                   #Enable the Kubelet's server (default true)

                                  ┌───────────────────┐
                                  │   KUBELET FILES   │
                                  └───────────────────┘

kubelet ...
--root-dir DIR                                    #Directory path for managing kubelet files (volume mounts,etc). (default "/var/lib/kubelet")
--lock-file FILE                                  #<Warning: Alpha feature> The path to file for kubelet to use as a lock file.

kubelet ...
--exit-on-lock-contention                         #Whether kubelet should exit upon lock-file contention.

kubelet ...                                       #
--boot-id-file FILE                               #Comma-separated list of files to check for boot-id. Use the first one that exists. (default "/proc/sys/kernel/random/boot_id")
--machine-id-file FILE,...                        #Comma-separated list of files to check for machine-id. Use the first one that exists. (default "/etc/machine-id,/var/lib/dbus/machine-id")

                                  ┌─────────────┐
                                  │   KUBECTL   │
                                  └─────────────┘

http://kubernetes.io/docs/user-guide/prereqs/

BOOL in CLI: not specified???


kubectl ...                                       #Client

kubectl create ...|edit|rolling-update|taint|
 apply|replace|convert ...                        #
--schema-cache-dir '~/.kube/schema'               #If non-empty, load/store cached API schemas in this directory, default is '$HOME/.kube/schema'
--validate BOOL                                   #If true (def), use a schema to validate the input before sending it

kubectl create ...|expose|label|rolling-update|
 autoscale|run ...                                #
--dry-run BOOL                                    #If true (def: false), only print the object that would be sent, without sending it.

kubectl set image|patch|convert                   #
--local BOOL                                      #If true (def), does not try to contact api-server but run locally.

kubectl completion bash|zsh                       #Output shell completion code for the given shell
                                                  #This command prints shell code which must be evaluation to provide interactive completion of kubectl commands.

                                  ┌────────────────────┐
                                  │   KUBECTL OUTPUT   │
                                  └────────────────────┘

http://kubernetes.io/docs/user-guide/kubectl-conventions/
http://kubernetes.io/docs/user-guide/docker-cli-to-kubectl/
http://kubernetes.io/docs/user-guide/kubectl-overview/
http://kubernetes.io/docs/user-guide/jsonpath/
http://kubernetes.io/docs/getting-started-guides/kubectl/

kubectl create|delete|scale|apply|replace ...     #
-o
--output STR                                      #Output mode. (resource/name).
--no-headers BOOL                                 #When using the default or custom-column output format, don't print headers.
                                                  #Def: false

kubectl create|expose|run|convert|set image|get|
 edit|autoscale|rolling-update|taint|patch|label|
 annotate|config view|config get-contexts ...     #
-o
--output STR                                      #Output format. 
                                                  #One of: json|yaml|wide|name|custom-columns=...|custom-columns-file=...|go-template=...|go-template-file=...|jsonpath=...|jsonpath-file=... 
                                                  #kubectl edit only supports yaml|json
--output-version STR                              #Output the formatted object with the given group version (for ex: 'extensions/v1beta1').
-a
--show-all BOOL                                   #When printing, show all resources (default hide terminated pods.) Def: false
--show-labels BOOL                                #When printing, show all labels as the last column (default hide labels column). Def: false
--sort-by STR                                     #If non-empty, sort list types using this field specification.
                                                  #The field specification is expressed as a JSONPath expression (e.g. '{.metadata.name}'). 
                                                  #The field in the API resource specified by this JSONPath expression must be an integer or a string
--template STR                                    #Template string or path to template file to use when -o=go-template, -o=go-template-file. 
                                                  #The template format is golang templates.

                                  ┌────────────────┐
                                  │   KUBECONFIG   │
                                  └────────────────┘

http://kubernetes.io/docs/user-guide/kubeconfig-file/

kubectl config ...                                #Modify kubeconfig files
                                                  #The loading order follows these rules:
                                                  #  1. If the --kubeconfig flag is set, then only that file is loaded.  The flag may only be set once and no merging takes place.
                                                  #  2. If $KUBECONFIG environment variable is set, then it is used a list of paths (normal path delimitting rules for your system).
                                                  #     These paths are merged.
                                                  #     When a value is modified, it is modified in the file that defines the stanza.
                                                  #     When a value is created, it is created in the first file that exists.
                                                  #     If no files in the chain exist, then it creates the last file in the list.
                                                  #  3. Otherwise, ${HOME}/.kube/config is used and no merging takes place.

kubectl config set VARR VAL                       #Sets an individual value in a kubeconfig file
                                                  #VARR is a dot delimited name where each token represents either an attribute name or a map key. Map keys may not contain dots.
                                                  #VAL is the new value you wish to set. 
                                                  #Binary fields such as 'certificate-authority-data' expect a base64 encoded string unless the --set-raw-bytes flag is used.
--set-raw-bytes BOOL                              #When writing a []byte PROPERTY_VALUE, write the given string directly without base64 decoding.
                                                  #Def: false

kubectl config unset VARR                         #Unsets an individual value in a kubeconfig file
                                                  #VARR is a dot delimited name where each token represents either an attribute name or a map key.  Map keys may not contain dots.

kubectl config view                               #Display merged kubeconfig settings or a specified kubeconfig file
                                                  #You can use --output jsonpath={...} to extract specific values using a jsonpath expression.
--flatten BOOL                                    #Flatten the resulting kubeconfig file into self-contained output (useful for creating portable kubeconfig files)
                                                  #Def: false
--merge BOOL                                      #Merge the full hierarchy of kubeconfig files
                                                  #Def: true
--minify BOOL                                     #Remove all information not used by current-context from the output
                                                  #Def: false
--raw BOOL                                        #Display raw byte data
                                                  #Def: false


kubelet|kubectl|kube-proxy|controller-manager|
 scheduler ...                                    #
--kubeconfig FILE                                 #Path to a kubeconfig file, specifying how to connect to the API server. 
                                                  #--api-servers will be used for the location unless --require-kubeconfig is set. (default "/var/lib/kubelet/kubeconfig")
kubelet|kubectl
--require-kubeconfig                              #If true the Kubelet will exit if there are configuration errors, 
                                                  #and will ignore the value of --api-servers in favor of the server defined in the kubeconfig file.
--experimental-bootstrap-kubeconfig FILE          #<Warning: Experimental feature> Path to a kubeconfig file that will be used to get client certificate for kubelet. 
                                                  #If the file specified by --kubeconfig does not exist, the bootstrap kubeconfig is used to request a client certificate from the API server. 
                                                  #On success, a kubeconfig file referencing the generated key and obtained certificate is written to the path specified by --kubeconfig. 
                                                  #The certificate and key file will be stored in the directory pointed by --cert-dir.

                                  ┌─────────────┐
                                  │   CLUSTER   │
                                  └─────────────┘

http://kubernetes.io/docs/tutorials/kubernetes-basics/cluster-intro/
http://kubernetes.io/docs/getting-started-guides/
http://kubernetes.io/docs/getting-started-guides/aws/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/aws_under_the_hood.md
http://kubernetes.io/docs/getting-started-guides/scratch/, and following topics
http://kubernetes.io/docs/getting-started-guides/docker-multinode/
http://kubernetes.io/docs/admin/cluster-large/
http://kubernetes.io/docs/admin/multiple-zones/
http://kubernetes.io/docs/admin/cluster-management/
http://kubernetes.io/docs/admin/etcd/
http://kubernetes.io/docs/admin/multi-cluster/
http://kubernetes.io/docs/user-guide/sharing-clusters/


METADATA.clusterName                              #CLUSTER
                                                  #This is used to distinguish resources with same name and namespace in different clusters.
                                                  #This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request.

kubectl ...
kubectl config set-cluster CLUSTER_NAME ...       #
--certificate-authority FILE                      #Path to a cert. file for the certificate authority
--insecure-skip-tls-verify BOOL                   #If true (def: false), the server's certificate will not be checked for validity. This will make your HTTPS connections insecure
-s
--server HOST                                     #The address and port of the Kubernetes API server

kubectl config set-cluster CLUSTER_NAME           #Sets a cluster entry in kubeconfig
                                                  #Specifying a name that already exists will merge new fields on top of existing values for those fields.
--embed-certs BOOL                                #Embed client cert/key
                                                  #Def: false

kubectl config delete-cluster CLUSTER             #Delete the specified cluster from the kubeconfig

kubectl config get-clusters                       #Display clusters defined in the kubeconfig

kubectl cluster[-]info                            #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'.

kubectl cluster[-]info dump                       #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.
--namespaces NAMESPACE,...                        #A comma separated list of namespaces to dump.
--output-directory DIR                            #Where to output the files.  If empty or '-' uses stdout, otherwise creates a directory hierarchy in that directory


kube-controller-manager ...                       #
--cluster-name CLUSTER                            #The instance prefix for the cluster (default "kubernetes")

                                  ┌─────────────┐
                                  │   CONTEXT   │
                                  └─────────────┘

kubectl ...
kubectl config set-context ...                    #
--cluster CLUSTER                                 #The name of the kubeconfig cluster to use
-n
--namespace NAMESPACE                             #If present, the namespace scope for this CLI request
--user USER                                       #The name of the kubeconfig user to use

kubectl ...                                       #
--context CONTEXT                                 #The name of the kubeconfig context to use

kubectl config set-context                        #Sets a context entry in kubeconfig
                                                  #Specifying a name that already exists will merge new fields on top of existing values for those fields.

kubectl config current-context                    #Displays the current-context

kubectl config delete-context CONTEXT             #Delete the specified context from the kubeconfig

kubectl config get-contexts [CONTEXT]             #Describe one or many contexts form the kubeconfig file

kubectl config use-context CONTEXT                #Sets the current-context in a kubeconfig file

                                  ┌───────────────┐
                                  │   NAMESPACE   │
                                  └───────────────┘

http://kubernetes.io/docs/user-guide/namespaces.md
http://kubernetes.io/docs/admin/namespaces/
http://kubernetes.io/docs/admin/namespaces/walkthrough/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/namespaces.md


NAMESPACE                                         #Sub-cluster
                                                  #The following entities are always at the cluster-level, i.e. do not use namespaces:
                                                  #  - Namespace itself, Node, PersistentVolume, ThirdPartyResource, ComponentStatus
                                                  #Specified with each REST call, although optional for GET /RESOURCE (see above)
                                                  #Def: "default"
                                                  #Must be DNS label

METADATA.namespace                                #NAMESPACE
                                                  #Read-only

NAMESPACE.status.phase                            #STR. Current lifecycle phase of the namespace.

APIRESOURCE.namespaced                            #BOOL. Indicates if a resource is namespaced or not.


kubectl create namespace|ns NAMESPACE             #Create a namespace with the specified name


kubectl get|cluster-info|top pode|describe
--all-namespaces BOOL                             #If present, list the requested object(s) across all namespaces. 
                                                  #Namespace in current context is ignored even if specified with --namespace.
                                                  #Def: false

kubelet|kube-apiserver ...
--master-service-namespace STR                    #The namespace from which the kubernetes master services should be injected into pods (default "default")


minikube service [list]
-n
--namespace NAMESPACE                             #

                                  ┌───────────────┐
                                  │   RESOURCES   │
                                  └───────────────┘

http://kubernetes.io/docs/whatisk8s/
http://kubernetes.io/docs/getting-started-guides/binary_release/
http://kubernetes.io/docs/user-guide/config-best-practices/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/architecture.md


RESOURCES ==>                                     #Only describes the ones in the following table:
                                                  #  +-------------------------+-------------------------------------------------------------+-------------------------------+
                                                  #  | REST NAME               | REST ROUTE                                                  | RESC_TYPE (CLI)               |
                                                  #  +-------------------------+-------------------------------------------------------------+-------------------------------+
                                                  #  | Cluster                 | None (whole API)                                            | cluster                       |
                                                  #  | APIResource             | "" (top-level)                                              | None                          |
                                                  #  | Binding                 | /pods/NAME/binding                                          | None (Pod subresource)        |
                                                  #  | ComponentStatus         | /componentstatuses                                          | componentstatus|cs            |
                                                  #  | ConfigMap               | /configmaps                                                 | configmap|cm                  |
                                                  #  | DaemonSet               | /daemonsets                                                 | daemonset|ds                  |
                                                  #  | Deployment              | /deployments                                                | deployment|deploy             |
                                                  #  | DeploymentRollback      | /deployments/NAME/rollback                                  | None (Deployment subresource) |
                                                  #  | Endpoint                | /endpoints                                                  | endpoint|ep                   |
                                                  #  | Event                   | /events                                                     | event|ev                      |
                                                  #  | Eviction                | /pods/NAME/eviction                                         | None (Pod subresource)        |
                                                  #  | HorizontalPodAutoscaler | /horizontalpodautoscalers                                   | horizontalpodautoscaler|hpa   |
                                                  #  | Ingress                 | /ingresses                                                  | ingress|ing                   |
                                                  #  | Job                     | /jobs                                                       | job                           |
                                                  #  | LimitRange              | /limitranges                                                | limitrange|limits             |
                                                  #  | Namespace               | /namespaces                                                 | namespace|ns                  |
                                                  #  | NetworkPolicy           | /networkpolicies                                            | networkpolicy                 |
                                                  #  | Node                    | /nodes                                                      | node|no                       |
                                                  #  | PersistentVolume        | /persistentvolumes                                          | persistentvolume|pv           |
                                                  #  | PersistentVolumeClaim   | /persistentvolumeclaims                                     | persistentvolumeclaim|pvc     |
                                                  #  | Pod                     | /pods                                                       | pod|po                        |
                                                  #  | PodTemplate             | /podtemplates                                               | podtemplate                   |
                                                  #  | ReplicaSet              | /replicasets                                                | replicaset|rs                 |
                                                  #  | ReplicationController   | /replicationcontrollers                                     | replicationcontroller|rc      |
                                                  #  | ResourceQuota           | /resourcequotas                                             | [resource]quota               |
                                                  #  | Scale                   | /deployments|replicasets|replicationcontrollers/NAME/scale  | None (subresource)            |
                                                  #  | Secret                  | /secrets                                                    | secret                        |
                                                  #  | Service                 | /services                                                   | service|svc                   |
                                                  #  | ServiceAccount          | /serviceaccounts                                            | serviceaccount|sa             |
                                                  #  | ThirdPartyResource      | /thirdpartyresources                                        | thirdpartyresource            |
                                                  #  +-------------------------+-------------------------------------------------------------+-------------------------------+

CLI ==>                                           #The following notations are for CLI
RESC...                                           #Can be:
                                                  #  - RESC_TYPE,... [RESC_NAME ...]:
                                                  #     - if RESC_NAME not specified: all resource of that type
                                                  #        - must also specify --all with kubectl set image|delete|taint|label|annotate
                                                  #     - RESC_NAME is optional if --selector used
                                                  #  - RESC_TYPE/RESC_NAME ...
                                                  #Optional if --filename used
RESC                                              #Like RESC... but for a single resource, i.e. RESC_TYPE[/]RESC_NAME
                                                  #It seems kubctl edit needs /, and kubectl patch needs no / (verify???)
CLUSTER|POD|..._RESC[...]                         #Like RESC[...] but restrict to few possible RESC_TYPE
RESC_TYPE                                         #Resource type (see below)
                                                  #Can use plural form (does not make any difference)
RESC_NAME                         
CLUSTER|POD|...                                   #Resource name

API ==>                                           #The following notations are for REST operations and --filename files
RESC.*
CLUSTER|POD|....*                                 #Resource definition
RESC_LIST                                         #List of resources
RESC_LIST.items                                   #Array of RESC
RESC.spec|status                                  #Many resources have those fields: "spec" is target state, "status" is current state

RESC[_LIST].kind                                  
APIRESOURCE.kind                                  #Resource type, e.g. 'Pod' or 'PodLists'. Required
kubectl get ...                                   #
--show-kind BOOL                                  #If present, list the resource type for the requested object(s). Def: false


kube-apiserver ...                                #
--runtime-config value                            #A set of key=value pairs that describe runtime configuration that may be passed to apiserver.
                                                  #  - apis/<groupVersion> key can be used to turn on/off specific api versions.
                                                  #  - apis/<groupVersion>/<resource> can be used to turn on/off specific resources.
                                                  #  - api/all and api/legacy are special keys to control all and legacy api versions respectively.

                                  ┌──────────────────┐
                                  │   API RESOURCE   │
                                  └──────────────────┘

APIRESOURCE.name                                  #STR

                                  ┌──────────────┐
                                  │   REST API   │
                                  └──────────────┘

http://kubernetes.io/docs/api/
http://kubernetes.io/docs/devel/api-conventions.md
https://github.com/kubernetes/kubernetes/blob/master/docs/api.md



ROOT_URL                                          #HOST/api/VERSION[/namespaces/NAMESPACE]/
                                                  #Implied for all endpoints below
NAMESPACE                                         #Required. Exceptions:
                                                  #  - optional with GET /ROOT/RESOURCE (not subresources)
                                                  #  - some entities do not use namespaces (see namespace section)
RESOURCES                                         #Plural lowercase resource name, e.g. "jobs"
                                                  #See resource list
RESOURCE                                          #Either:
                                                  #  - nothing (i.e. top-level): for APIResource
                                                  #  - RESOURCES: for most resources
                                                  #  - /PARENT/NAME/RESOURCES: for subresources, i.e.:
                                                  #     - DeploymentRollback: under Deployment
                                                  #     - Binding: optionally under Pod
                                                  #     - Eviction: under Pod
                                                  #     - Scale: under Deployment|ReplicaSet|ReplicationController

BODY TYPE ==>                                     #Request|response body possible type:
                                                  #  - application/json (def)
                                                  #  - application/yaml
                                                  #  - application/vnd.kubernetes.protobuf
kubelet|kube-proxy|controller-manager|scheduler   #
--kube-api-content-type STR                       #Content type of requests sent to apiserver (def: "application/vnd.kubernetes.protobuf")

REST OPERATIONS ==>                               #Possible operations follow.
                                                  #Some resources cannot do all operations:
                                                  #  - read-only:
                                                  #     - APIResource: only GET /RESOURCE
                                                  #     - ComponentStatus: only GET
                                                  #  - update-only:
                                                  #     - Binding|Eviction: only POST|PUT
                                                  #     - DeploymentRollback: only POST
                                                  #  - no creation|deletion:
                                                  #     - Scale: no POST|DELETE
                                                  #  - no mass delete:
                                                  #     - Service: no DELETE /RESOURCE

GET|PUT|PATCH /RESOURCE/NAME/status               #Like GET|PUT|PATCH /RESOURCE/NAME except:
                                                  #  - targets RESOURCE.status, i.e. it must exist and be an OBJ
                                                  #  - can only use QOBJ.pretty

QOBJ                                              #Query variable with REST routes, for any call
QOBJ(...)                                         #Query variable with REST routes, for specific calls


NON-REST ROUTES ==>                               #Do not use REST entities|operations
                                                  #Use different QOBJ
                                                  #List: /pods/NAME/attach, /pods/NAME/exec, /pods/NAME/portforward, /pods/NAME/log, */proxy*

NON-TOP-LEVEL REST RESOURCES ==>                  #The following do not have top-level REST routes, but are subresources of Pod: Container, Volume, SecurityContext
                                                  
NON-TOP-LEVEL UTILITIES ==>                       #The following do not have top-level REST routes, but are utilities: selectors, object references, metadata

                                  ┌───────────────────┐
                                  │   MANIFEST FILE   │
                                  └───────────────────┘

http://kubernetes.io/docs/user-guide/working-with-resources/


kubectl create|expose|set image|get|edit|delete|
 rollout ...|rolling-update|scale|autoscale|
 describe|apply|patch|replace|convert|label|
 annotate ...                                     #
-f
--filename FILE|DIR|URL                           #Filename, directory, or URL to file to use to create the resource.
-R
--recursive BOOL                                  #Process the directory used in -f, --filename recursively. 
                                                  #Useful when you want to manage related manifests organized within the same directory.
                                                  #Def: false


kubelet ...
--manifest-url URL                                #URL for accessing the container manifest
--manifest-url-header STR                         #HTTP header to use when accessing the manifest URL, with the key separated from the value with a ':', as in 'key:value'
--pod-manifest-path FILE                          #Path to to the directory containing pod manifest files to run, or the path to a single pod manifest file.

                                  ┌─────────────┐
                                  │   TIMEOUT   │
                                  └─────────────┘

QOBJ(GET|DELETE /RESOURCE).timeoutSeconds         #Call timeout


kubelet
--runtime-request-timeout DUR                     #Timeout of all runtime requests except long running request - pull, logs, exec and attach. 
                                                  #When timeout exceeded, kubelet will cancel the request, throw out an error and retry later. Default: 2m0s (default 2m0s)
--streaming-connection-idle-timeout DUR           #Maximum time a streaming connection can be idle before the connection is automatically closed. 
                                                  #0 indicates no timeout. Example: '5m' (default 4h0m0s)

kubectl replace|delete|rolling-update|scale       #
--timeout DUR                                     #The length of time to wait before giving up, 0 means (rolling-update|scale) no wait or (replace|update) relative to object size. 
                                                  #Def: 5m (rolling-update), 0 (otherwise).

kube-apiserver ...                                #
--min-request-timeout NUM                         #An optional field indicating the minimum number of seconds a handler must keep a request open before timing it out.
                                                  #Currently only honored by the watch request handler, which picks a randomized value above this number as the connection timeout, to spread out load.
                                                  #(default 1800)

                                  ┌───────────────────┐
                                  │   REST API READ   │
                                  └───────────────────┘

GET /RESOURCE                                     #Response body: RESOURCE_LIST

GET /RESOURCE/NAME                                #Response body: RESOURCE

kubectl get RESC...                               #Display one or many resources
                                                  #This command will hide resources that have completed. For instance, pods that are in the Succeeded or Failed phases.
                                                  #You can see the full results for any resource by providing the '--show-all' flag.
                                                  #By specifying the output as 'template' and providing a Go template as the value of the --template flag, 
                                                  #you can filter the attributes of the fetched resource(s).
--raw URI                                         #Raw URI to request from the server.  Uses the transport specified by the kubeconfig file.

kubectl describe RESC                             #Show details of a specific resource or group of resources
                                                  #This command joins many API calls together to form a detailed description of a given resource or group of resources.
                                                  #Will first check for an exact match on ERESOURCES. 
                                                  #If no such resource exists, it will output details for every resource that has a name prefixed with NAME

kubectl explain RESC...                           #Documentation of resources
--recursive BOOL                                  #Print the fields of fields (Currently only 1 level deep). Def: false

                                  ┌─────────────────────┐
                                  │   REST API CREATE   │
                                  └─────────────────────┘

POST /RESOURCE                                    #Request body: RESOURCE. Response body: RESOURCE

kubectl create ...                                #Create a resource by filename or stdin

                                  ┌─────────────────────┐
                                  │   REST API UPDATE   │
                                  └─────────────────────┘

PUT /RESOURCE/NAME                                #Request body: RESOURCE. Response body: RESOURCE

kubectl apply                                     #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.
                                                  #--filename is required
--overwrite BOOL                                  #Automatically resolve conflicts between the modified and live configuration by using values from the modified configuration
                                                  #Def: true

kubectl replace|update                            #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
                                                  #--filename is required
--force BOOL                                      #Delete and re-create the specified resource. Def: false

kubectl edit RESC                                 #Edit a resource on the server, 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.
                                                  #The files to edit will be output in the default API version, or a version specified by --output-version. 
                                                  #The default format is YAML - if you would like to edit in JSON pass -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.
--windows-line-endings BOOL                       #Use Windows line-endings (default Unix line-endings). Def: false

kubectl expose|run ...                            #
--overrides JSON                                  #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.
kubectl run ...
--service-overrides 'JSON'                        #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.


PATCH /RESOURCE/NAME                              #Request body:
                                                  #  - PATCH
                                                  #  - possible types:
                                                  #     - application/json-patch+json
                                                  #     - application/merge-patch+json
                                                  #     - application/strategic-merge-patch+json
                                                  #Response body: RESOURCE

kubectl patch RESC                                #Update field(s) of a resource using strategic merge patch
                                                  #JSON and YAML formats are accepted.
-p                                                #The patch to be applied to the resource JSON file.
--patch STR                                       #Required
--type STR                                        #The type of patch being provided; one of: json, merge, strategic (def)

kubectl taint|label|annotate                      #
--overwrite BOOL                                  #If true (def: false), allow to be overwritten, otherwise reject updates that overwrite existing ones.


kube-apiserver ...                                #
--repair-malformed-updates                        #If true, server will do its best to fix the update request to pass the validation, e.g., setting empty UID in update request to its existing value.
                                                  #This flag can be turned off after we fix all the clients that send malformed updates. (default true)

                                  ┌─────────────────────┐
                                  │   REST API DELETE   │
                                  └─────────────────────┘

DELETE /RESOURCE                                  #Response body: STATUS
DELETE /RESOURCE/NAME                             #Request body: DELETEOPTS. Response body: STATUS

kubectl delete RESC...                            #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
                                                  #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.
--ignore-not-found BOOL                           #Treat "resource not found" as a successful delete. Defaults to "true" when --all is specified., false otherwise

                                  ┌────────────┐
                                  │   STATUS   │
                                  └────────────┘

STATUS.status                                     #Status of the operation, either "Success" or "Failure".
STATUS.message                                    #STR. A human-readable description of the status of this operation.
STATUS.reason                                     #STR. A machine-readable description of why this operation is in the "Failure" status.
                                                  #If this value is empty there is no information available. 
                                                  #A Reason clarifies an HTTP status code but does not override it.
STATUS.code                                       #HTTP_STATUS_NUM, or 0 if not set
STATUS.details                                    #STATUSDETAILS. Extended data associated with the reason.
                                                  #Each reason may define its own extended details.
                                                  #This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type.
STATUSDETAILS.name|group|kind                     #STR
STATUSDETAILS.retryAfterSeconds                   #NUM. Time in seconds before the operation should be retried.
STATUSDETAILS.causes                              #STATUSCAUSE_ARR. Details associated with the failure.
STATUSCAUSE.reason                                #STR. A machine-readable description of the cause of the error.
STATUSCAUSE.message                               #STR. A human-readable description of the cause of the error.
STATUSCAUSE.field                                 #The field of the resource that has caused this error, as named by its JSON serialization.
                                                  #May include dot and postfix notation for nested attributes.
                                                  #Arrays are zero-indexed.
                                                  #Fields may appear more than once in an array of causes due to fields having multiple errors.
                                                  #Examples: "name" - the field "name" on the current resource "items[0].name" - the field "name" on the first array entry in "items" false string

                                  ┌─────────────────┐
                                  │   IDENTIFIERS   │
                                  └─────────────────┘

http://kubernetes.io/docs/user-guide/identifiers.md
https://github.com/kubernetes/kubernetes/blob/master/docs/design/identifiers.md


METADATA.uid UID                                  #RESOURCE_ID.
                                                  #Read-only, set by server.
METADATA.name                                     #RESOURCE_NAME
                                                  #Read-only
METADATA.generateName                             #STR. GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. 
                                                  #If this field is used, the name returned to the client will be different than the name passed. 
                                                  #This value will also be combined with a unique suffix. 
                                                  #The provided value has the same validation rules as the Name field, 
                                                  #and may be truncated by the suffix lenfth required to make the value unique on the server.
                                                  #If this field is specified and the generated name exists, the server will NOT return a 409 - 
                                                  #instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, 
                                                  #and the client should retry (optionally after the time indicated in the Retry-After header).
                                                  #Applied only if Name is not specified.
[LIST_]METADATA.selfLink                          #REST URI. Read only

                                  ┌──────────────┐
                                  │   METADATA   │
                                  └──────────────┘

RESC[_LIST].metadata                              #[LIST_]METADATA

METADATA.creationTimestamp                        #DATE.
                                                  #Read-only, set by server.

                                  ┌─────────────────┐
                                  │   ANNOTATIONS   │
                                  └─────────────────┘

http://kubernetes.io/docs/user-guide/annotations/

METADATA.annotations                              #OBJ. Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. 
                                                  #They are not queryable and should be preserved when modifying objects. 

kubectl annotate RESC... VAR=VAL...               #Update the annotations on one or more resources.
                                                  #An annotation is a key/value pair that can hold larger (compared to a label), and possibly not human-readable, data.
                                                  #It is intended to store non-identifying auxiliary data, especially data manipulated by tools and system extensions.

kubectl create|expose|run|set image|edit|scale|
 autoscale|apply|patch|replace|label|annotate ... #
--record BOOL                                     #Record current kubectl command in the resource annotation.
                                                  #If set to false (def), do not record the command.
                                                  #If set to true, record the command.
                                                  #If not set, default to updating the existing annotation value only if one already exists.

kubectl create ...|expose|run|edit|autoscale|
 replace ...                                      #
--save-config BOOL                                #If true, the configuration of current object will be saved in its annotation.
                                                  #This is useful when you want to perform kubectl apply on this object in the future.
                                                  #Def: false

                                  ┌────────────┐
                                  │   LABELS   │
                                  └────────────┘

http://kubernetes.io/docs/user-guide/labels.md
https://github.com/kubernetes/kubernetes/blob/master/docs/api-reference/labels-annotations-taints.md


METADATA.labels                                   #OBJ. Map of string keys and values that can be used to organize and categorize (scope and select) objects. 
                                                  #May match selectors of replication controllers and services.
                                                  #A label must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to 63 characters.

kubectl label RESC... VAR=VAL ...                 #Update the labels on a resource

kubectl expose|run ...                            #
-l
--labels STR                                      #Labels to apply

kubelet ...
--node-labels VAR=VAL,...                         #<Warning: alpha feature> Labels to add when registering the node in the cluster.  Labels must be key=value pairs separated by ','.


LABELSELECTOR.matchLabels                         #{KEY: ARR, ...}, same as matchExpressions [{key: KEY, operator: "In", values: ARR}, ...]
LABELSELECTOR.matchExpressions                    #LABELSELECTORREQUIREMENT_ARR. The requirements are ANDed.
LABELSELECTORREQUIREMENT.key                      #STR. Label key that the selector applies to.
LABELSELECTORREQUIREMENT.operator                 #STR. Key's relationship to a set of values, among: "[Not]In" or "Exists|DoesNotExist"
LABELSELECTORREQUIREMENT.values                   #STR_ARR. Must be non-empty with "[Not]In", empty with "Exists|DoesNotExist"
                                                  #This array is replaced during a strategic merge patch.

QOBJ(GET|DELETE /RESOURCE).labelSelector          #STR. A selector to restrict the list of returned objects by their labels.


kubectl set image|get|delete|top|taint|describe|
 label|annotate                                   #
-l
--selector STR                                    #Selector (label query) to filter on

kubectl get ...                                   #
-L 
--label-columns VAR,...                           #Accepts a comma separated list of labels that are going to be presented as columns. 
                                                  #Names are case-sensitive. You can also use multiple flag options like -L label1 -L label2...

                                  ┌────────────────┐
                                  │   REFERENCES   │
                                  └────────────────┘

OBJREF.namespace                                  #NAMESPACE of the referent
OBJREF.name                                       #NAME of the referent.
OBJREF.uid                                        #UID of the referent.
OBJREF.resourceVersion                            #Specific METADATA.resourceVersion to which this reference is made
OBJREF.fieldPath                                  #STR. If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, 
                                                  #such as desiredState.manifest.containers[2]. 
                                                  #For example, if the object reference is to a container within a pod, this would take on a value like: "spec.containers{name}" 
                                                  #(where "name" refers to the name of the container that triggered the event) or if no container name is specified "spec.containers[2]" 
                                                  #(container with index 2 in this pod).
                                                  #This syntax is chosen only to have some well-defined way of referencing a part of an object.

LOCALOBJREF.name                                  #NAME of the referent.

SUBRESREF.name                                    #NAME of the referent
SUBRESREF.subresource                             #Subresource NAME of the referent

                                  ┌──────────────┐
                                  │   SELECTOR   │
                                  └──────────────┘

https://github.com/kubernetes/kubernetes/blob/master/docs/design/selector-generation.md


OBJFIELDSELECTOR.apiVersion                       #STR (def: "v1"). Version of the schema the FieldPath is written in terms of.
OBJFIELDSELECTOR.fieldPath                        #STR. Path of the field to select in the specified API version.

RESOURCEFIELDSELECTOR.containerName               #CONTAINER_NAME. Required for volumes
RESOURCEFIELDSELECTOR.resource                    #STR. Resource to select. Required
RESOURECFIELDSELECTOR.divisor                     #STR (def: "1"). Output format of the exposed resources

SECRETKEYSELECTOR.name                            #STR. Name of the referent.
SECRETKEYSELECTOR.key                             #STR. The key of the secret to select from. Must be a valid secret key.

QOBJ.pretty                                       #BOOL. If true (def: false), then the output is pretty printed
QOBJ(GET /RESOURCE/NAME).exact                    #BOOL (def: false). Should the export be exact. Exact export maintains cluster-specific fields like Namespace
QOBJ(GET|DELETE /RESOURCE).fieldSelector          #STR. A selector to restrict the list of returned objects by their labels.

QOBJ(GET /RESOURCE/NAME).export                   #BOOL (def: false). Should this value be exported. Export strips fields that a user can not specify.
kubectl get ...                                   #
--export BOOL                                     #If true (def: false), use 'export' for the resources.
                                                  #Exported resources are stripped of cluster-specific information.

                                  ┌────────────────┐
                                  │   CONFIG MAP   │
                                  └────────────────┘

http://kubernetes.io/docs/user-guide/configmap/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/configmap.md

CONFIGMAP.data                                    #OBJ. Configuration data. Each key must be a valid DNS_SUBDOMAIN with an optional leading dot.

VOLUME.configMap                                  #CONFIGMAPVOLUMESOURCE. ConfigMap that should populate this volume
CONFIGMAPVOLUMESOURCE.name                        #STR. Name of the referent.
CONFIGMAPVOLUMESOURCE.defaultMode                 #Like KEYTOPATH.mode
CONFIGMAPVOLUMESOURCE.items                       #KEYTOPATH_ARR. If unspecified, each key-value pair in the Data field of the referenced ConfigMap 
                                                  #will be projected into the volume as a file whose name is the key and content is the value. 
                                                  #If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present.
                                                  #If a key is specified which is not present in the ConfigMap, the volume setup will error.
                                                  #Paths must be relative and may not contain the .. path or start with ...
KEYTOPATH.key                                     #'KEY'. The key to project.
KEYTOPATH.path                                    #PATH. The relative path of the file to map the key to.
                                                  #May not be an absolute path.
                                                  #May not contain the path element ..
                                                  #May not start with the string ..
KEYTOPATH.mode                                    #NUM. Mode bits to use on created files by default.
                                                  #Must be a value between 0 and 0777.
                                                  #Defaults to 0644.
                                                  #Directories within the path are not affected by this setting.
                                                  #This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.


CONFIGMAPKEYSELECTOR.name                         #STR. Name of the referent.
CONFIGMAPKEYSELECTOR.key                          #'KEY'. The key to select.


kubectl create configmap|cm CONFIGMAP             #Create a configmap from a local file, directory or 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)

                                  ┌───────────────┐
                                  │   CONDITION   │
                                  └───────────────┘

CONDITION                                         #Available observation of an object's current state.
                                                  #Inherited by: JOB_CONDITION, COMPONENT_CONDITION, POD_CONDITION, NODE_CONDITION
CONDITION.type                                    #STR. Type of job condition, among possibilities defined by child.
CONDITION.status                                  #Status of the condition, among: "True", "False" or "Unknown".
CONDITION.lastProbeTime                           #"DATETIME". Last time the condition was checked.
CONDITION.lastTransitionTime                      #"DATETIME". Last time the condition transit from one status to another.
CONDITION.reason                                  #STR. Brief reason for the condition's last transition.
CONDITION.message                                 #STR. Human readable message indicating details about last transition.

                                  ┌─────────────┐
                                  │   HANDLER   │
                                  └─────────────┘

HANDLER.*                                         #exec|httpGet|tcpSocket are exclusive
HANDLER.exec                                      #EXECACTION. Action to take.
HANDLER.httpGet                                   #HTTPGETACTION. HTTP request to perform.
HANDLER.tcpSocket                                 #TCPSOCKETACTION. Action involving a TCP port.
                                                  #TCP hooks not yet supported 
EXECACTION.command                                #STR_ARR. Command line to execute inside the container, the working directory for the command is root (/) in the container's filesystem.
                                                  #The command is simply exec'd, it is not run inside a shell, so traditional shell instructions (' ', etc) won't work.
                                                  #To use a shell, you need to explicitly call out to that shell.
                                                  #Exit status of 0 is treated as live/healthy and non-zero is unhealthy.
HTTPGETACTION.path                                #PATH to access on the HTTP server.
HTTPGETACTION.port                                #PORT_STR|NUM. Port to access on the container.
HTTPGETACTION.host                                #HOST. Host name to connect to, defaults to the pod IP.
                                                  #You probably want to set "Host" in httpHeaders instead.
HTTPGETACTION.scheme                              #'PROTO' (def: 'HTTP').
HTTPGETACTION.httpHeaders                         #HTTPHEADER_ARR
HTTPHEADER.name                                   #STR
HTTPHEADER.value                                  #STR
TCPSOCKETACTION.port                              #PORT_STR|NUM. Port to access on the container.

                                  ┌────────────────────────────┐
                                  │   REPLICATION CONTROLLER   │
                                  └────────────────────────────┘

http://kubernetes.io/docs/user-guide/replication-controller/
http://kubernetes.io/docs/user-guide/replication-controller/operations/


REPLICATIONCONTROLLER.spec.replicas               #NUM (def: 1). Number of desired replicas.
                                                  #This is a pointer to distinguish between explicit zero and unspecified.
REPLICATIONCONTROLLER.spec.selector               #OBJ. Label query over pods that should match the Replicas count.
                                                  #If Selector is empty, it is defaulted to the labels present on the Pod template.
REPLICATIONCONTROLLER.spec.template               #PODTEMPLATE.spec. Describes the pod that will be created if insufficient replicas are detected.
                                                  #This takes precedence over a TemplateRef.

REPLICATIONCONTROLLER.status.replicas             #NUM. Replicas is the most recently oberved number of replicas.
REPLICATIONCONTROLLER.status.fullyLabeledReplicas #NUM. The number of pods that have labels matching the labels of the pod template of the replication controller.
REPLICATIONCONTROLLER.status.readyReplicas        #NUM. The number of ready replicas for this replication controller.

                                  ┌─────────────────┐
                                  │   REPLICA SET   │
                                  └─────────────────┘

http://kubernetes.io/docs/user-guide/replicasets/


REPLICASET.spec.template                          #PODTEMPLATE.spec. Describes the pod that will be created if insufficient replicas are detected.
REPLICASET.spec.selector                          #LABELSELECTOR. Label query over pods that should match the replica count.
                                                  #If the selector is empty, it is defaulted to the labels present on the pod template.
                                                  #Label keys and values that must match in order to be controlled by this replica set.

REPLICASET.spec.replicas                          #NUM (def: 1). Number of desired replicas.
                                                  #This is a pointer to distinguish between explicit zero and unspecified.
REPLICASET.status.replicas                        #NUM. Most recently oberved number of replicas.
REPLICASET.status.fullyLabeledReplicas            #NUM. Number of pods that have labels matching the labels of the pod template of the replicaset.
REPLICASET.status.readyReplicas                   #NUM. Number of ready replicas for this replica set.

                                  ┌────────────────┐
                                  │   DEPLOYMENT   │
                                  └────────────────┘

http://kubernetes.io/docs/user-guide/deployments/
http://kubernetes.io/images/docs/kubectl_rollingupdate.svg
http://kubernetes.io/docs/tutorials/kubernetes-basics/deploy-intro/
http://kubernetes.io/docs/tutorials/kubernetes-basics/update-intro/
http://kubernetes.io/docs/tutorials/stateless-application/run-stateless-application-deployment/
http://kubernetes.io/docs/tutorials/stateful-application/run-stateful-application/
http://kubernetes.io/docs/user-guide/deploying-applications/
http://kubernetes.io/docs/user-guide/managing-deployments/
http://kubernetes.io/docs/user-guide/rolling-updates/
http://kubernetes.io/docs/user-guide/update-demo/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/simple-rolling-update.md


DEPLOYMENT.spec.replicas                          #NUM (def: 1). Number of desired pods.
                                                  #This is a pointer to distinguish between explicit zero and not specified.
DEPLOYMENT.status.replicas                        #NUM. Total number of non-terminated pods targeted by this deployment (i.e. their labels match the selector).
DEPLOYMENT.status.updatedReplicas                 #NUM. Total number of non-terminated pods targeted by this deployment that have the desired template spec.
DEPLOYMENT.status.[un]availableReplicas           #NUM Total number of [un]available pods targeted by this deployment, i.e. [not] ready for at least minReadySeconds

DEPLOYMENT.spec.template                          #PODTEMPLATE.spec. Describes the pods that will be created.
                                                  #Required
DEPLOYMENT.spec.selector                          #LABELSELECTOR for pods.
                                                  #Existing ReplicaSets whose pods are selected by this will be the ones affected by this deployment.
DEPLOYMENT.spec.minReadySeconds                   #NUM (def: 0).
                                                  #Min number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. 
DEPLOYMENT.spec.paused                            #BOOL (def: false). Indicates that the deployment is paused and will not be processed by the deployment controller.

DEPLOYMENT.spec.strategy                          #DEPLOYMENTSTRATEGY. The deployment strategy to use to replace existing pods with new ones.
DEPLOYMENTSTRATEGY.type                           #Type, among: "Recreate" or "RollingUpdate" (def)


kubectl create deployment|dep DEPLOYMENT          #Create a deployment with the specified name.

                                  ┌────────────────────┐
                                  │   ROLLING UPDATE   │
                                  └────────────────────┘

DEPLOYMENTSTRATEGY.rollingUpdate                  #ROLLINGUPATEDEPLOYMENT. Present only if DEPLOYMENTSTRATEGY.type === "RollingUpdate".
ROLLINGUPDATEDEPLOYMENT.maxUnavailable            #'NUM[%]' (def: '1'). The maximum number of pods that can be unavailable during the update.
                                                  #Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
                                                  #Absolute number is calculated from percentage by rounding up.
                                                  #This can not be 0 if MaxSurge is 0.
                                                  #Example: 
                                                  #  - when this is set to 30%, the old RC can be scaled down to 70% of desired pods immediately when the rolling update starts.
                                                  #  - once new pods are ready, old RC can be scaled down further, followed by scaling up the new RC, 
                                                  #    ensuring that the total number of pods available at all times during the update is at least 70% of desired pods.
ROLLINGUPDATEDEPLOYMENT.maxSurge                  #'NUM[%]' (def: '1'). The maximum number of pods that can be scheduled above the desired number of pods.
                                                  #Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
                                                  #Absolute number is calculated from percentage by rounding up.
                                                  #This can not be 0 if MaxUnavailable is 0.
                                                  #Example: 
                                                  #  - when this is set to 30%, the new RC can be scaled up immediately when the rolling update starts, 
                                                  #    such that the total number of old and new pods do not exceed 130% of desired pods.
                                                  #  - once old pods have been killed, new RC can be scaled up further, 
                                                  #    ensuring that total number of pods running at any time during the update is atmost 130% of desired pods.


kubectl rolling[-]update OLD_REPLICATIONCONTROLER #Perform a rolling update of the given ReplicationController.
 NEW_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.
                                                  #NEW_NAME optional if --image of --filename
--container CONTAINER_NAME                        #Container name which will have its image upgraded. 
                                                  #Only relevant when --image is specified, ignored otherwise.
                                                  #Required when using --image on a multi-container pod
--deployment-label-key STR                        #The key to use to differentiate between two different controllers, default 'deployment'.  Only relevant when --image is specified, ignored otherwise
--image IMAGE                                     #Image to use for upgrading the replication controller. 
                                                  #Must be distinct from the existing image (either new image or new image tag).
                                                  #Can not be used with --filename/-f
--poll-interval DUR                               #Time delay between polling for replication controller status after the update. Def: 3s
--rollback BOOL                                   #If true (def: false), this is a request to abort an existing rollout that is partially rolled out. 
                                                  #It effectively reverses current and next and runs a rollout
--update-period DUR                               #Time to wait between updating pods. Def: 1m

                                  ┌────────────────────────┐
                                  │   DEPLOYMENTROLLBACK   │
                                  └────────────────────────┘

DEPLOYMENTROLLBACK.rollbackTo                     #ROLLBACKCONFIG. The config of this deployment rollback. Required.
DEPLOYMENT.spec.rollbackTo                        #ROLLBACKCONFIG. The config this deployment is rolling back to. Will be cleared after rollback is done.
ROLLBACKCONF.revision                             #NUM. The revision to rollback to.
                                                  #If set to 0, rollback to the last revision.

DEPLOYMENTROLLBACK.name                           #DEPLOYMENT_NAME. Required
DEPLOYMENTROLLBACK.updatedAnnotations             #OBJ. The annotations to be updated to a deployment

DEPLOYMENT.spec.revisionHistoryLimit              #NUM. The number of old ReplicaSets to retain to allow rollback.
                                                  #This is a pointer to distinguish between explicit zero and not specified.


kubectl rollout undo deployment/DEPLOYMENT        #Rollback to a previous rollout.
--to-revision NUM                                 #The revision to rollback to. Default to 0 (last revision).

kubectl rollout pause deployment/DEPLOYMENT       #Mark the provided resource as paused
                                                  #Paused resources will not be reconciled by a controller.
                                                  #Use \"kubectl rollout resume\" to resume a paused resource.
                                                  #Currently only deployments support being paused.

kubectl rollout resume deployment/DEPLOYMENT      #Resume a paused resource
                                                  #Paused resources will not be reconciled by a controller. 
                                                  #By resuming a resource, we allow it to be reconciled again.
                                                  #Currently only deployments support being resumed.

kubectl rollout status deployment/DEPLOYMENT      #Watch the status of current rollout, until it's done.

kubectl rollout history deployment/DEPLOYMENT     #View previous rollout revisions and configurations.
--revision NUM                                    #See the details, including podTemplate of the revision specified. Def: 0

                                  ┌───────────┐
                                  │   SCALE   │
                                  └───────────┘

http://kubernetes.io/docs/tutorials/kubernetes-basics/scale-intro/
http://kubernetes.io/docs/user-guide/resizing-a-replication-controller/


SCALE.spec.replicas                               #NUM. Desired number of instances for the scaled object.

SCALE.status.replicas                             #NUM. Actual number of observed instances of the scaled object.
SCALE.status.selector                             #OBJ. Label query over pods that should match the replicas count.
SCALE.status.targetSelector                       #STR. Label selector for pods that should match the replicas count.
                                                  #This is a serializated version of both map-based and more expressive set-based selectors.
                                                  #This is done to avoid introspection in the clients.
                                                  #The string will be in the same format as the query-param syntax.
                                                  #If the target type only supports map-based selectors, both this field and map-based selector field are populated.


kubectl scale|resize DEPLOYMENT|REPLICASET|       #Set a new size
 REPLICACONTROLLER|JOB_RESC                       #Scale also allows users to specify one or more preconditions for the scale action.
                                                  #If --current-replicas 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.
--replicas NUM                                    #The new desired number of replicas. Required.
                                                  #Def: -1
--current-replicas NUM                            #Precondition for current size. Requires that the current size of the resource match this value in order to scale.
                                                  #Def: -1


kubectl run ...                                   #
-r
--replicas NUM                                    #Number of replicas to create for this container. Default is 1.

                                  ┌────────────────┐
                                  │   AUTOSCALER   │
                                  └────────────────┘

http://kubernetes.io/docs/user-guide/horizontal-pod-autoscaling/
http://kubernetes.io/docs/user-guide/horizontal-pod-autoscaling/walkthrough/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/horizontal-pod-autoscaler.md


AUTOSCALER                                        #Short for HORIZONTALPODAUTOSCALER

AUTOSCALER.spec.min|maxReplicas                   #NUM. Lower (def: 1) and upper limit for the number of pods that can be set by the autoscaler
AUTOSCALER.status.current|desiredReplicas         #NUM. Current|desired number of replicas of pods managed by this autoscaler.

AUTOSCALER.spec.scaleRef                          #SUBRESOURCEREF to SCALE subresource.
                                                  #AUTOSCALER will learn the current resource consumption from its status, and will set the desired number of pods by modifying its spec.
                                                  #Required
AUTOSCALER.status.lastScaleTime                   #"DATETIME". Last time the AUTOSCALER scaled the number of pods.
                                                  #Used by the AUTOSCALER to control how often the number of pods is changed.

AUTOSCALER.status.cpuUtilization                  #CPUTARGETUTILIZATION
CPUTARGETUTILIZATION.targetPercentage             
AUTOSCALER.spec.targetCPUUtilization              #NUM (def: 80). Fraction of the requested CPU that should be used over all the pods, e.g. 70 means that 70% of the requested CPU should be in use.


kubectl autoscale DEPLOYMENT|REPLICASET|          #Creates an autoscaler that automatically chooses and sets the number of pods that run in a kubernetes cluster.
 REPLICACONTROLLER_RESC                           #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.
--cpu-percent NUM                                 #The target average CPU utilization (represented as a percent of requested CPU) over all the pods. 
                                                  #If it's not specified or negative, a default autoscaling policy will be used.
                                                  #Def: -1
--max NUM                                         #The upper limit for the number of pods that can be set by the autoscaler. Required.
                                                  #Def: -1
--min NUM                                         #The lower limit for the number of pods that can be set by the autoscaler. If it's not specified or negative, the server will apply a default value.
                                                  #Def: -1
--name NAME                                       #The name for the newly created object. If not specified, the name of the input resource will be used.

                                  ┌────────────────┐
                                  │   DAEMON SET   │
                                  └────────────────┘

http://kubernetes.io/docs/admin/daemons.md 
https://github.com/kubernetes/kubernetes/blob/master/docs/design/daemon.md


DAEMONSET.status.desiredNumberScheduled           #NUM. Number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod).
DAEMONSET.status.currentNumberScheduled           #NUM. Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod.
DAEMONSET.status.numberMisscheduled               #NUM. Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod.

DAEMONSET.spec.selector                           #LABELSELECTOR. Label query over pods that are managed by the daemon set.
                                                  #Must match in order to be controlled.
                                                  #If empty, defaulted to labels on Pod template.
DAEMONSET.spec.template                           #PODTEMPLATE.spec. Describes the pod that will be created.
                                                  #DAEMONSET will create exactly one copy of this pod on every node that matches the template's node selector (or on every node if no node selector is specified).
                                                  #Required

                                  ┌─────────┐
                                  │   JOB   │
                                  └─────────┘

http://kubernetes.io/docs/user-guide/jobs.md 
http://kubernetes.io/docs/user-guide/jobs/
http://kubernetes.io/docs/user-guide/jobs/expansions/
http://kubernetes.io/docs/user-guide/jobs/work-queue-1/
http://kubernetes.io/docs/user-guide/jobs/work-queue-2/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/indexed-job.md
https://github.com/kubernetes/kubernetes/blob/master/docs/design/selector-generation.md


JOB.spec.template                                 #PODTEMPLATE.spec. Describes the pod that will be created when executing a job.
JOB.spec.parallelism                              #NUM. Maximum desired number of pods the job should run at any given time.
JOB.spec.completions                              #NUM. Desired number of successfully finished pods the job should be run with.
                                                  #Setting to nil (def) means that the success of any pod signals the success of all pods, and allows parallelism to have any positive value.
                                                  #Setting to 1 means that parallelism is limited to 1 and the success of that pod signals the success of the job. 
JOB.spec.activeDeadlineSeconds                    #UINT. Duration in seconds relative to JOB.status.startTime that the job may be active before the system tries to terminate it 
JOB.spec.selector                                 #LABELSELECTOR. Label query over pods that should match the pod count.
                                                  #Usually set by the system
JOB.spec.manualSelector                           #BOOL (def: false). Controls generation of pod labels and pod selectors.
                                                  #Leave manualSelector unset unless you are certain what you are doing.
                                                  #When false or unset, the system pick labels unique to this job and appends those labels to the pod template.
                                                  #When true, the user is responsible for picking unique labels and specifying the selector.
                                                  #Failure to pick a unique label may cause this and other jobs to not function correctly.
                                                  #However, You may see manualSelector=true in jobs that were created with the old extensions/v1beta1 API.

JOB.status.start|completionTime                   #"DATETIME". Time when the job was started|completed.
                                                  #It is not guaranteed to be set in happens-before order across separate operations.
JOB.status.active                                 #NUM. Number of actively running pods.
JOB.status.succeeded|failed                       #NUM. Number of pods which reached Phase Succeeded|Failed.

JOB.status.conditions                             #JOB_CONDITION_ARR.
JOBCONDITION.type                                 #Type, among: "Complete" or "Failed".

                                  ┌──────────┐
                                  │   NODE   │
                                  └──────────┘

http://kubernetes.io/docs/user-guide/node-selection/
http://kubernetes.io/docs/admin/node.md
http://kubernetes.io/images/docs/kubectl_drain.svg
http://kubernetes.io/docs/tasks/administer-cluster/assign-pods-nodes/
http://kubernetes.io/docs/tutorials/kubernetes-basics/explore-intro/
http://kubernetes.io/docs/admin/master-node-communication/
http://kubernetes.io/docs/admin/node-problem/


POD.spec.nodeSelector                             #OBJ. NodeSelector is a selector which must be true for the pod to fit on a node.
                                                  #Selector which must match a node's labels for the pod to be scheduled on that node.
POD.spec.nodeName                                 #NODE_NAME. NodeName is a request to schedule this pod onto a specific node.
                                                  #If it is non-empty, the scheduler simply schedules this pod onto that node, assuming that it fits resource requirements.

NODE.status.capacity                              #OBJ. Total resources of a node.
NODE.status.allocatable                           #OBJ. Resources of a node that are available for scheduling. Defaults to Capacity.

NODE.status.nodeInfo                              #NODESYSTEMINFO.
NODESYSTEMINFO.machineID                          #STR
NODESYSTEMINFO.systemUUID                         #STR
NODESYSTEMINFO.bootID                             #STR
NODESYSTEMINFO.kernelVersion                      #STR. From uname -r, e.g. 3.16.0-0.bpo.4-amd64
NODESYSTEMINFO.osImage                            #STR. From /etc/os-release, e.g. Debian GNU/Linux 7 (wheezy)
NODESYSTEMINFO.containerRuntimeVersion            #STR. From runtime remote API, e.g. docker://1.5.0
NODESYSTEMINFO.kubeletVersion                     #STR
NODESYSTEMINFO.kubeProxyVersion                   #STR
NODESYSTEMINFO.operatingSystem                    #STR
NODESYSTEMINFO.architecture                       #STR

NODE.spec.providerID                              #STR. ID of the node assigned by the cloud provider in the format: <ProviderName>://<ProviderSpecificNodeID>

NODE.status.conditions                            #NODE_CONDITION_ARR.
NODE_CONDITION.type                               #STR. Type of node condition.
NODE_CONDITION.lastHeartbeatTime                  #Instead of NODE_CONDITION.lastProbeTime

                                  ┌─────────────────────┐
                                  │   NODE SCHEDULING   │
                                  └─────────────────────┘

NODE.spec.unschedulable                           #BOOL (def: false). Node schedulability of new pods.

kubectl [un]cordon NODE                           #Mark node as unschedulable|schedulable

kubectl drain NODE                                #Drain node in preparation for maintenance.
                                                  #The given node will be marked unschedulable to prevent new pods from arriving.
                                                  #Then drain 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 or Job--,
                                                  #then drain will not delete any pods unless you use --force.
                                                  #When you are ready to put the node back into service, use kubectl uncordon, which will make the node schedulable again.
--delete-local-data BOOL                          #Continue even if there are pods using emptyDir (local data that will be deleted when the node is drained). Def: false
--force BOOL                                      #Continue even if there are pods not managed by a ReplicationController, ReplicaSet, Job, or DaemonSet. Def: false
--ignore-daemonsets BOOL                          #Ignore DaemonSet-managed pods. Def: false

kubectl taint NODE_RESC... VAL ...                #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 253 characters.
                                                  #The value must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to 253 characters.
                                                  #The effect must be NoSchedule or PreferNoSchedule.
                                                  #Currently taint can only apply to node.
                                                  #VAL can be:
                                                  #  - KEY=VAL:EFFECT: add|change one effect
                                                  #  - KEY:EFFECT-: remove one effect
                                                  #  - KEY-: remove all effects


kubelet ...                                       #
--register-node                                   #Register the node with the apiserver (defaults to true if --api-servers is set) (default true)
--register-schedulable                            #Register the node as schedulable. No-op if register-node is false. [default=true] (default true)

                                  ┌─────────────┐
                                  │   BINDING   │
                                  └─────────────┘

BINDING.target                                    #OBJREF. The target object that you want to bind to the standard object.
                                                  #Required

                                  ┌─────────┐
                                  │   POD   │
                                  └─────────┘

http://kubernetes.io/docs/user-guide/pods/
http://kubernetes.io/docs/tasks/debug-application-cluster/determine-reason-pod-failure/
http://kubernetes.io/docs/user-guide/pods/single-container/
http://kubernetes.io/docs/user-guide/pods/multi-container/
http://kubernetes.io/docs/user-guide/pod-states/


POD.spec.restartPolicy                            #STR. Restart policy for all containers within the pod. Can be: "Always" (def), "OnFailure" or "Never"
POD.spec.activeDeadlineSeconds                    #UINT. Optional duration in seconds the pod may be active on the node relative to POD.status.StartTime before the system will actively try
                                                  #to mark it failed and kill associated containers.

POD.status.phase                                  #STR. Current condition of the pod.
POD.status.message                                #STR. A human readable message indicating details about why the pod is in this condition.
POD.status.reason                                 #STR. A brief CamelCase message indicating details about why the pod is in this state. e.g. "OutOfDisk"
POD.status.startTime                              #"DATETIME". RFC 3339 date and time at which the object was acknowledged by the Kubelet.
                                                  #This is before the Kubelet pulled the container image(s) for the pod.

POD.status.conditions                             #POD_CONDITION_ARR.
POD_CONDITION.type                                #Type, among: "Ready"


POD.spec.containers                               #CONTAINER_ARR
                                                  #There must be at least one container in a Pod.
                                                  #Read-only. Required
POD.status.containerStatuses                      #CONTAINER.status_ARR. The list has one entry per container in the manifest.
                                                  #Each entry is currently the output of docker inspect.

                                  ┌──────────────────┐
                                  │   POD TEMPLATE   │
                                  └──────────────────┘

http://kubernetes.io/docs/user-guide/pod-templates/


PODTEMPLATE.template.metadata                     #METADATA
PODTEMPLATE.template.spec                         #POD.spec

                                  ┌───────────────────────┐
                                  │   CONTAINER RUNTIME   │
                                  └───────────────────────┘

kubelet|minikube start ...                        #
--container-runtime STR                           #The container runtime to use. Possible values: 'docker', 'rkt'. Default: 'docker'. (default "docker")

kubelet ...                                       #
--container-runtime-endpoint FILE                 #The unix socket endpoint of remote runtime service. 
                                                  #If not empty, this option will override --container-runtime. This is an experimental feature. Intended for testing only.
--image-service-endpoint FILE                     #The unix socket endpoint of remote image service. If not specified, it will be the same with container-runtime-endpoint by default. 
                                                  #This is an experimental feature. Intended for testing only.

kubelet ...                                       #
--docker HOST                                     #Docker endpoint (default "unix:///var/run/docker.sock")
--docker-endpoint HOST                            #Use this for the docker endpoint to communicate with (default "unix:///var/run/docker.sock")
--docker-env-metadata-whitelist ENVVAR,...        #A comma-separated list of environment variable keys that needs to be collected for docker containers
--docker-exec-handler STR                         #Handler to use when executing a command in a container. Valid values are 'native' and 'nsenter'. Defaults to 'native'. (default "native")
--docker-only BOOL                                #Only report docker containers in addition to root stats

kubelet ...                                       #
--rkt-path FILE                                   #Path of rkt binary. Leave empty to use the first rkt in $PATH.  Only used if --container-runtime 'rkt'.
--rkt-api-endpoint URI                            #The endpoint of the rkt API service to communicate with. Only used if --container-runtime 'rkt'. (default "localhost:15441")

                                  ┌───────────┐
                                  │   IMAGE   │
                                  └───────────┘

http://kubernetes.io/docs/user-guide/images.md


NODE.status.images                                #CONTAINERIMAGE_ARR
CONTAINERIMAGE.names                              #CONTAINER_NAME_ARR
CONTAINERIMAGE.sizeBytes                          #NUM


CONTAINER.image                                   #IMAGE_NAME
CONTAINER.status.image                            #IMAGE_NAME
CONTAINER.status.imageID                          #IMAGE_ID

kubectl run ...                                   #
--image IMAGE                                     #The image for the container to run.
kubectl create deployment|dep ...                 #
--image IMAGE,...                                 #Image name to run.

kubectl set image DAEMONSET|DEPLOYMENT|POD|
 REPLICASET|REPLICACONTROLLER_RESC...
 CONTAINER=IMAGE ...                              #Update existing container image(s) of resources.


CONTAINER.imagePullPolicy                         #STR, among:
                                                  #  - "Always" (def if :latest TAG)
                                                  #  - "Never"
                                                  #  - "IfNotPresent" (def otherwise)
kubectl run|rolling-update ...                    #
--image-pull-policy STR                           #The image pull policy for the container.
                                                  #If left empty, this value will not be specified by the client and defaulted by the server.
                                                  #With rolling-update: required when --image is same as existing image, ignored otherwise.


--serialize-image-pulls                           #Pull images one at a time. We recommend *not* changing the default value on nodes that run docker daemon with version < 1.9 or an Aufs storage backend. 
                                                  #Issue #10959 has more details. [default=true] (default true)


minikube start ...                                #
--insecure-registry HOST[:PORT]                   
--registry-mirror HOST                            #Passed to dockerd

                                  ┌───────────────┐
                                  │   ISOLATION   │
                                  └───────────────┘

kubelet ...                                       #
--host-network-sources STR,...                    #Comma-separated list of sources from which the Kubelet allows pods to use of host network. [default="*"] (default [*])
--pod-infra-container-image IMAGE                 #The image whose network/ipc namespaces containers in each pod will use. (default "gcr.io/google_containers/pause-amd64:3.0")

kubelet ...                                       #
--host-pid-sources STR,...                        #Comma-separated list of sources from which the Kubelet allows pods to use the host pid namespace. [default="*"] (default [*])
POD.spec.hostPID                                  #BOOL. Use the host's pid namespace.

kubelet ...                                       #
--host-ipc-sources STR,...                        #Comma-separated list of sources from which the Kubelet allows pods to use the host ipc namespace. [default="*"] (default [*])
POD.spec.hostIPC                                  #BOOL. Use the host's ipc namespace.

kubelet ...
--cgroup-root STR                                 #Optional root cgroup to use for pods. 
                                                  #This is handled by the container runtime on a best effort basis. Default: '', which means use the container runtime default.
--kubelet-cgroups STR                             #Optional absolute name of cgroups to create and run the Kubelet in.
--runtime-cgroups STR                             #Optional absolute name of cgroups to create and run the runtime in.
--system-cgroups STR                              #Optional absolute name of cgroups in which to place all non-kernel processes that are not already inside a cgroup under /. 

                                  ┌───────────────┐
                                  │   CONTAINER   │
                                  └───────────────┘

http://kubernetes.io/docs/user-guide/simple-nginx/
http://kubernetes.io/docs/user-guide/configuring-containers/
http://kubernetes.io/docs/user-guide/production-pods/
http://kubernetes.io/docs/user-guide/containers/


CONTAINER.*                                       #All read-only, except standard-streams-related properties

CONTAINER.name                                    
CONTAINER.status.name                             #CONTAINER_NAME. This must be a DNS_LABEL.
CONTAINER.status.containerID                      #"docker://CONTAINER_ID"


kubectl run[-container] IMAGE                     #Create and run a particular image, possibly replicated.
                                                  #Creates a deployment or job to manage the created container(s).
--quiet BOOL                                      #If true (def: false), suppress prompt messages.


CONTAINER.workingDir                              #STR
                                                  #If not specified, the container runtime's default will be used, which might be configured in the container image.

                                  ┌─────────────────────┐
                                  │   CONTAINER STATE   │
                                  └─────────────────────┘

CONTAINER.status.restartCount                     #NUM. The number of times the container has been restarted, currently based on the number of dead containers that have not yet been removed.
                                                  #Note that this is calculated from dead containers.
                                                  #But those containers are subject to garbage collection.
                                                  #This value will get capped at 5 by GC.

CONTAINER.status.state|lastState                  #CONTAINERSTATE. Details about the container's current|last condition.
CONTAINERSTATE.waiting                            #CONTAINERSTATEWAITING
CONTAINERSTATEWAITING.reason                      #STR. Brief reason the container is not yet running.
CONTAINERSTATEWAITING.message                     #STR. Message regarding why the container is not yet running.
CONTAINERSTATE.running                            #CONTAINERSTATERUNNING
CONTAINERSTATERUNNING.startedAt                   #"DATETIME". Time at which the container was last (re-)started
CONTAINERSTATE.terminated                         #CONTAINERSTATETERMINATED
CONTAINERSTATETERMINATED.exitCode                 #NUM
CONTAINERSTATETERMINATED.signal                   #SIGNAL_NUM
CONTAINERSTATETERMINATED.reason                   #STR. Brief reason from the last termination of the container 
CONTAINERSTATETERMINATED.message                  #STR. Message regarding the last termination of the container 
CONTAINERSTATETERMINATED.started|finishedAt       #"DATETIME"
CONTAINERSTATETERMINATED.containerID              #"docker://CONTAINER_ID"

                                  ┌───────────────────────┐
                                  │   CONTAINER COMMAND   │
                                  └───────────────────────┘

http://kubernetes.io/docs/tasks/configure-pod-container/define-command-argument-container/


CONTAINER.command                                 #STR_ARR (def: image's ENTRYPOINT). Entrypoint.
                                                  #Not executed within a shell.
                                                  #Can use $(ENVVAR)
CONTAINER.args                                    #STR_ARR (def: image's CMD). Arguments to the entrypoint.
                                                  #Can use $(ENVVAR)
kubectl run ...                                   #
--command BOOL                                    #If true (def: false) and extra arguments are present, use them as the 'command' field in the container, rather than the 'args' field which is the default.

                                  ┌─────────────────────────┐
                                  │   CONTAINER LIFECYCLE   │
                                  └─────────────────────────┘

http://kubernetes.io/docs/user-guide/container-environment/


CONTAINER.lifecycle                               #LIFECYCLE. Actions that the management system should take in response to container lifecycle events.
LIFECYCLE.postStart                               #HANDLER. PostStart is called immediately after a container is created.
                                                  #If the handler fails, the container is terminated and restarted according to its restart policy.
                                                  #Other management of the container blocks until the hook completes.
LIFECYCLE.preStop                                 #HANDLER. PreStop is called immediately before a container is terminated.
                                                  #The container is terminated after the handler completes.
                                                  #The reason for termination is passed to the handler.
                                                  #Regardless of the outcome of the handler, the container is eventually terminated.
                                                  #Other management of the container blocks until the hook completes.

                                  ┌────────────────────┐
                                  │   CONTAINER EXIT   │
                                  └────────────────────┘

kubectl run ...                                   #
--restart STR                                     #The restart policy for this Pod.
                                                  #Legal values [Always, OnFailure, Never].
                                                  #If set to 'Always' (def) a deployment is created for this pod, 
                                                  #if set to 'OnFailure', a job is created for this pod, if set to 'Never', a regular pod is created.
                                                  #For the latter two --replicas must be 1.  Default 'Always'

CONTAINER.terminationMessagePath                  #PATH (def: "/dev/termination-log").
                                                  #File to which the container's termination message will be written is mounted into the container's filesystem.
                                                  #Message written is intended to be brief final status, such as an assertion failure message.

                                  ┌────────────┐
                                  │   ENVVAR   │
                                  └────────────┘

http://kubernetes.io/docs/user-guide/environment-guide/
http://kubernetes.io/docs/tasks/configure-pod-container/define-environment-variable-container/


$(ENVVAR)                                         #Expanded in ENVVAR.value and CONTAINER.command|args, using the container's environment
                                                  #If a variable cannot be resolved, the reference in the input string will be unchanged.
                                                  #Can be escaped as $$(ENVVAR)

CONTAINER.env                                     #ENVVAR_ARR. Environment variables to set in the container.
ENVVAR.name                                       #STR
ENVVAR.value                                      #STR (def: "")
                                                  #Can use $(ENVVAR)
ENVVAR.valueFrom                                  #ENVVARSOURCE. Source for the environment variable's value.
                                                  #Cannot be used if value is not empty.
ENVVARSOURCE.fieldRef                             #OBJFIELDSELECTOR. Selects a field of the pod: supports metadata.name|namespace|labels|annotations, spec.nodeName|serviceAccountName, status.podIP.
ENVVARSOURCE.resourceFieldRef                     #RESOURCEFIELDSELECTOR. Selects a resource of the container: only resources limits and requests (limits.cpu|memory, requests.cpu|memory) are currently supported.
ENVVARSOURCE.configMapKeyRef                      #CONFIGMAPKEYSELECTOR. Selects a key of a ConfigMap.
ENVVARSOURCE.secretKeyRef                         #SECRETKEYSELECTOR. Selects a key of a secret in the pod's namespace

kubectl run ...                                   #
--env VAR=VAL,...                                 #Environment variables to set in the container

minikube start ...                                #
--docker-env ENVVAR=VAL                           #Passed to dockerd

                                  ┌──────────────────┐
                                  │   DOWNWARD API   │
                                  └──────────────────┘

https://github.com/kubernetes/kubernetes/blob/master/docs/design/downward_api_resources_limits_requests.md
http://kubernetes.io/docs/user-guide/downward-api/
http://kubernetes.io/docs/user-guide/downward-api/volume/


VOLUME.downwardAPI                                #DOWNWARDAPIVOLUMESOURCE about the pod that should populate this volume

DOWNWARDAPIVOLUMESRC.items                        #DOWNWARDAPIVOLUMEFILE_ARR
DOWNWARDAPIVOLUMEFILE.path                        #PATH. Relative path name of the file to be created.
                                                  #Must not be absolute or contain the .. path.
                                                  #Must be utf-8 encoded.
                                                  #The first item of the relative path must not start with ..
                                                  #Required.
DOWNWARDAPIVOLUMEFILE.fieldRef                    #OBJFIELDSELECTOR. Selects a field of the pod: only annotations, labels, name and namespace are supported.
                                                  #Required.
DOWNWARDAPIVOLUMEFILE.resourceFieldRef            #RESOURCEFIELDSELECTOR. Selects a resource of the container: only resources limits and requests (limits|requests.cpu|memory) are currently supported.

DOWNWARDAPIVOLUMESRC.defaultMode                  
DOWNWARDAPIVOLUMEFILE.mode                        #Like KEYTOPATH.mode

                                  ┌──────────────────────┐
                                  │   STANDARD STREAMS   │
                                  └──────────────────────┘

CONTAINER.stdin                                   #BOOL (def: false). Whether this container should allocate a buffer for stdin in the container runtime.
                                                  #If this is not set, reads from stdin in the container will always result in EOF. 
kubectl run ...                                   #
-i
--stdin BOOL                                      #Keep stdin open on the container(s) in the pod, even if nothing is attached. Def: false

CONTAINER.stdinOnce                               #BOOL (def: false). Whether the container runtime should close the stdin channel after it has been opened by a single attach.
                                                  #When stdin is true the stdin stream will remain open across multiple attach sessions.
                                                  #If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, 
                                                  #and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted.
                                                  #If this flag is false, a container processes that reads from stdin will never receive an EOF.
kubectl run ...                                   #
--leave-stdin-open BOOL                           #If the pod is started in interactive mode or with stdin, leave stdin open after the first attach completes. 
                                                  #By default (false), stdin will be closed after the first attach completes.

CONTAINER.tty                                     #BOOL (def: false). Whether this container should allocate a TTY for itself, also requires stdin to be true. 
kubectl run ...                                   #
-t
--tty BOOL                                        #Allocated a TTY for each container in the pod. Def: false

                                  ┌────────────┐
                                  │   ATTACH   │
                                  └────────────┘

GET|POST /pods/NAME/attach                        #Uses QOBJ:
                                                  #  - stdin|stdout|stderr BOOL (def: false|true|true). Redirects the standard stream of the pod for this call.
                                                  #  - tty BOOL (def: false). TTY if true indicates that a tty will be allocated for the attach call. 
                                                  #    This is passed through the container runtime so the tty is allocated on the worker node by the container runtime. 
                                                  #  - container CONTAINER: The container in which to execute the command. Defaults to only container if there is only one container in the pod.

kubectl attach POD                                #Attach to a process that is already running inside an existing container.
-i
--stdin BOOL                                      
-t
--tty BOOL                                        #Like kubectl run
-c
--container CONTAINER_NAME                        #Like kubectl log

kubectl run ...                                   #
--attach BOOL                                     #If true, wait for the Pod to start running, and then attach to the Pod as if 'kubectl attach ...' were called.
                                                  #Default false, unless '-i/--stdin' is set, in which case the default is true. 
                                                  #With '--restart Never' the exit code of the container process is returned.

                                  ┌──────────┐
                                  │   EXEC   │
                                  └──────────┘

http://kubernetes.io/docs/user-guide/getting-into-containers/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/command_execution_port_forwarding.md


GET|POST /pods/NAME/exec                          #Uses same QOBJ as /pods/NAME/attach, plus:
                                                  #  - command STR: remote command to execute. argv array. Not executed within a shell.

kubectl exec POD                                  #Execute a command in a container
-p
--pod POD                                         #
-i
--stdin BOOL                                      
-t
--tty BOOL                                        #Like kubectl run
-c
--container CONTAINER_NAME                        #Like kubectl log

                                  ┌────────────┐
                                  │   VOLUME   │
                                  └────────────┘

http://kubernetes.io/docs/user-guide/volumes.md


POD.spec.volumes                                  #VOLUME_ARR. Volumes that can be mounted by containers belonging to the pod.

NODE.status.volumesInUse                          #VOLUME_NAME_ARR
NODE.status.volumesAttached                       #ATTACHEDVOLUME_ARR
ATTACHEDVOLUME.name                               #VOLUME_NAME
ATTACHEDVOLUME.devicePath                         #PATH

CONTAINER.volumeMounts                            #VOLUMEMOUNT_ARR. Pod volumes to mount into the container's filesystem.
VOLUMEMOUNT.name                                  #VOLUME_NAME
VOLUMEMOUNT.readOnly                              #BOOL (def: false)
VOLUMEMOUNT.mountPath                             #STR. Path within the container at which the volume should be mounted.
VOLUMEMOUNT.subPath                               #STR (def: "", i.e. root). Path within the volume from which the container's volume should be mounted.

VOLUME.name                                       #VOLUME_NAME. Must be a DNS_LABEL
VOLUME.hostPath                                   #HOSTPATHVOLUMESOURCE. Pre-existing file or directory on the host machine that is directly exposed to the container.
                                                  #This is generally used for system agents or other privileged things that are allowed to see the host machine.
                                                  #Most containers will NOT need this.
HOSTPATHVOLUMESOURCE.path                         #PATH
VOLUME.emptyDir                                   #EMPTYDIRVOLUMESOURCE. Temporary directory that shares a pod's lifetime.
EMPTYDIRVOLUMESOURCE.medium                       #What type of storage medium should back this directory, among:
                                                  #  - "" (def): node's default medium
                                                  #  - "Memory"

VOLUME.awsElasticBlockStore                       #EBSVOLUMESOURCE. AWS EBS volume that is attached to a kubelet's host machine and then exposed to the pod.
EBSVOLUMESOURCE.volumeID                          #STR
EBSVOLUMESOURCE.fsType                            #STR (def: "ext4"). Filesystem type of the volume
                                                  #Must ensure that the filesystem type is supported by the host operating system.
EBSVOLUMESOURCE.partition                         #NUM. The partition in the volume that you want to mount.
                                                  #If omitted, the default is to mount by volume name.
                                                  #Examples: For volume /dev/sda1, you specify the partition as "1". Similarly, the volume partition for /dev/sda is "0" (or you can leave the property empty).
EBSVOLUMESOURCE.readOnly                          #BOOL (def: false). Force and set the ReadOnly property in VolumeMounts to "true".

VOLUME.gitRepo                                    #GITREPOVOLUMESOURCE. Git repository at a particular revision.
GITREPOVOLUMESOURCE.repository                    #Repository 'URL'
GITREPOVOLUMESOURCE.revision                      #'COMMIT_HASH'
GITREPOVOLUMESOURCE.directory                     #Target 'DIR'.
                                                  #Must not contain or start with ...
                                                  #If . is supplied, the volume directory will be the git repository.
                                                  #Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.

VOLUME.flexVolume                                 #FLEXVOLUMESOURCE. Generic volume resource that is provisioned/attached using an exec based plugin.
FLEXVOLUMESOURCE.driver                           #DRIVER_NAME
FLEXVOLUMESOURCE.secretRef                        #LOCALOBJREF. Reference to the secret object containing sensitive information to pass to the plugin scripts.
                                                  #Optional
FLEXVOLUMESOURCE.options                          #OBJ. Extra command options
FLEXVOLUMESOURCE.fsType                           #Like EBSVOLUMESOURCE
FLEXVOLUMESOURCE.readOnly                         #Like EBSVOLUMESOURCE

VOLUME.nfs
VOLUME.iscsi
VOLUME.glusterfs
VOLUME.cephfs
VOLUME.rbd
VOLUME.flocker
VOLUME.quobyte
VOLUME.gcePersistentDisk                          #Other volume drivers available for: 
VOLUME.azureFile|Disk                             #  - NFS, ISCSI, GlusterFS, CephFS, Rados Block Device, Flocker, Quobyte
VOLUME.cinder                                     #  - Google Cloud Engine, Azure, OpenStack (Cinder), VMWare VSphere
VOLUME.vsphereVolume                              #  - Fibre Channel
VOLUME.fc                                         #See online doc

                                  ┌───────────────────────┐
                                  │   PERSISTENT VOLUME   │
                                  └───────────────────────┘

http://kubernetes.io/docs/user-guide/persistent-volumes.md
http://kubernetes.io/docs/user-guide/persistent-volumes/walkthrough/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/persistent-storage.md


PERSISTENTVOLUME[CLAIM].status.phase              #STR. Indicates if a volume is available, bound to a claim, or released by a claim.
PERSISTENTVOLUME.status.message                   #STR. A human-readable message indicating details about why the volume is in this state.
PERSISTENTVOLUME.status.reason                    #STR. Reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI.


PERSISTENTVOLUM.spec.persistentVolumeReclaimPolicy#STR. What happens to a persistent volume when released from its claim.
                                                  #Can be: 
                                                  #  - "Retain" (def)
                                                  #  - "Recycle": must be supported by the volume plugin underlying this persistent volume.

PERSISTENTVOLUME.spec.hostPath
PERSISTENTVOLUME.spec.gcePersistentDisk|
awsElasticBlockStore|glusterfs|nfs|rbd|
iscsi|cinder|cephfs|fc|flocker|flexVolume|
azureFile|vsphereVolume|quobyte|azureDisk         #Like VOLUME


PERSISTENTVOLUME.spec.claimRef                    #OBJREF pointing to PERSISTENTVOLUMECLAIM.
PERSISTENTVOLUMECLAIM.spec.volumeName             #PERSISTENTVOLUME_NAME


VOLUME.persistentVolumeClaim                      #PERSISTENTVOLUMECLAIMSOURCE.
PERSISTENTVOLUMECLAIMVOLUMESOURCE.claimName       #PERSISTENTVOLUMECLAIM_NAME
PERSISTENTVOLUMECLAIMVOLUMESOURCE.readOnly        #Like EBSVOLUMESOURCE


PERSISTENTVOLUME.spec.accessModes                 #OBJ_ARR. All ways the volume can be mounted.
PERSISTENTVOLUMECLAIM.spec.accessModes            #OBJ_ARR. Desired access modes the volume should have.
PERSISTENTVOLUMECLAIM.status.accessModes          #OBJ_ARR. Actual access modes the volume has


PERSISTENTVOLUME.spec.capacity                    #OBJ. A description of the persistent volume's resources and capacity.
PERSISTENTVOLUMECLAIM.status.capacity             #OBJ. Actual resources of the underlying volume.


PERSISTENTVOLUMECLAIM.spec.selector               #LABELSELECTOR. A label query over volumes to consider for binding.


kube-controller-manager ...                       #
--pv-recycler-increment-timeout-nfs value         #The increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod (default 30)
--pv-recycler-minimum-timeout-hostpath value      #The minimum ActiveDeadlineSeconds to use for a HostPath Recycler pod.
                                                  #This is for development and testing only and will not work in a multi-node cluster. (default 60)
--pv-recycler-minimum-timeout-nfs value           #The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod (default 300)
--pv-recycler-pod-template-filepath-hostpath STR  #The file path to a pod definition used as a template for HostPath persistent volume recycling. 
                                                  #This is for development and testing only and will not work in a multi-node cluster.
--pv-recycler-pod-template-filepath-nfs string    #The file path to a pod definition used as a template for NFS persistent volume recycling
--pv-recycler-timeout-increment-hostpath value    #The increment of time added per Gi to ActiveDeadlineSeconds for a HostPath scrubber pod.
                                                  #This is for development and testing only and will not work in a multi-node cluster. (default 30)

                                  ┌───────────────────────────────┐
                                  │   KUBE-APISERVER NETWORKING   │
                                  └───────────────────────────────┘

kube-apiserver ...                                #
--bind-address IP                                 #The IP address on which to listen for the --secure-port port.
                                                  #The associated interface(s) must be reachable by the rest of the cluster, and by CLI/web clients.
                                                  #If blank, all interfaces will be used (0.0.0.0). (default 0.0.0.0)
--secure-port NUM                                 #The port on which to serve HTTPS with authentication and authorization.
                                                  #If 0, don't serve HTTPS at all. (default 6443)
--advertise-address IP                            #The IP address on which to advertise the apiserver to members of the cluster.
                                                  #This address must be reachable by the rest of the cluster.
                                                  #If blank, the --bind-address will be used.
                                                  #If --bind-address is unspecified, the host's default interface will be used.
--insecure-bind-address IP                        #The IP address on which to serve the --insecure-port (set to 0.0.0.0 for all interfaces).
                                                  #Defaults to localhost. (default 127.0.0.1)
--insecure-port NUM                               #The port on which to serve unsecured, unauthenticated access.
                                                  #Default 8080. It is assumed that firewall rules are set up such that this port is not reachable from outside of the cluster and that port 443 
                                                  #on the cluster's public address is proxied to this port.
                                                  #This is performed by nginx in the default setup. (default 8080)

kube-apiserver ...                                #
--tls-cert-file FILE                              
--tls-private-key-file FILE                       
--cert-dir DIR                                    #Like kubelet
--client-ca-file PATH                             #If set, any request presenting a client certificate signed by one of the authorities in the client-ca-file is authenticated 
                                                  #with an identity corresponding to the CommonName of the client certificate.

kube-apiserver ...                                #
--ssh-keyfile PATH                                #If non-empty, use secure SSH proxy to the nodes, using this user keyfile
--ssh-user USER                                   #If non-empty, use secure SSH proxy to the nodes, using this user name

kube-apiserver ...                                #
--cors-allowed-origins STR,...                    #List of allowed origins for CORS, comma separated.
                                                  #An allowed origin can be a regular expression to support subdomain matching.
                                                  #If this list is empty CORS will not be enabled. (default [])


kube-proxy|controller-manager|scheduler ...
--master URL                                      #The address of the Kubernetes API server (overrides any value in kubeconfig)

                                  ┌───────────────────────────────────┐
                                  │   KUBE-CONTROLLER-MANAGER NETWK   │
                                  └───────────────────────────────────┘

kube-controller-manager ...                       #
--address IP                                      #The IP address to serve on (set to 0.0.0.0 for all interfaces) (default 0.0.0.0)
--port NUM                                        #The port that the controller-manager's http service runs on (default 10252)

kube-controller-manager ...                       #
--cluster-signing-cert-file string                #Filename containing a PEM-encoded X509 CA certificate used to issue cluster-scoped certificates (default "/etc/kubernetes/ca/ca.pem")
--cluster-signing-key-file string                 #Filename containing a PEM-encoded RSA or ECDSA private key used to sign cluster-scoped certificates (default "/etc/kubernetes/ca/ca.key")

                                  ┌───────────────────────────────┐
                                  │   KUBE-SCHEDULER NETWORKING   │
                                  └───────────────────────────────┘

kube-scheduler ...                                #
--address IP                                      #The IP address to serve on (set to 0.0.0.0 for all interfaces) (default "0.0.0.0")
--port NUM                                        #The port that the scheduler's http service runs on (default 10251)

                                  ┌────────────────────────┐
                                  │   KUBELET NETWORKING   │
                                  └────────────────────────┘

kubelet ...                                       #
--address IP                                      #The IP address for the Kubelet to serve on (set to 0.0.0.0 for all interfaces) (default 0.0.0.0)
--port NUM                                        #The port for the Kubelet to serve on. (default 10250)

kubelet ...                                       #
--tls-cert-file FILE                              #File containing x509 Certificate for HTTPS.  
                                                  #(CA cert, if any, concatenated after server cert). 
                                                  #If --tls-cert-file and --tls-private-key-file are not provided, 
                                                  #a self-signed certificate and key are generated for the public address and saved to the directory passed to --cert-dir.
--tls-private-key-file FILE                       #File containing x509 private key matching --tls-cert-file.
--cert-dir DIR                                    #The directory where the TLS certs are located (by default /var/run/kubernetes). 
                                                  #If --tls-cert-file and --tls-private-key-file are provided, this flag will be ignored. (default "/var/run/kubernetes")

kubelet ...                                       #
--iptables-drop-bit 0-31                          #The bit of the fwmark space to mark packets for dropping. Must be within the range [0, 31]. (default 15)
--iptables-masquerade-bit 0-31                    #The bit of the fwmark space to mark packets for SNAT. Must be within the range [0, 31].
                                                  #Please match this parameter with corresponding parameter in kube-proxy. (default 14)
--make-iptables-util-chains                       #If true, kubelet will ensure iptables utility rules are present on host. (default true)

kubelet ...                                       #
--node-ip IP                                      #IP address of the node. If set, kubelet will use this IP address for the node
--pod-cidr CIDR                                   #The CIDR to use for pod IP addresses, only used in standalone mode.  In cluster mode, this is obtained from the master.
--non-masquerade-cidr CIRD                        #Traffic to IPs outside this range will use IP masquerade. (default "10.0.0.0/8")
--reconcile-cidr                                  #Reconcile node CIDR with the CIDR specified by the API server. No-op if register-node or configure-cbr0 is false. [default=true] (default true)

kubelet ...
--hairpin-mode STR                                #How should the kubelet setup hairpin NAT. This allows endpoints of a Service to loadbalance back to themselves 
                                                  #if they should try to access their own Service. 
                                                  #Valid values are "promiscuous-bridge", "hairpin-veth" and "none". (default "promiscuous-bridge")


kube-apiserver ...                                #
--kubelet-certificate-authority PATH              #Path to a cert file for the certificate authority.
--kubelet-client-certificate PATH                 #Path to a client cert file for TLS.
--kubelet-client-key PATH                         #Path to a client key file for TLS.
--kubelet-https                                   #Use https for kubelet connections. (default true)
--kubelet-timeout DUR                             #Timeout for kubelet operations. (default 5s)
--insecure-experimental-approve-all-kubelet-
 csrs-for-group STR                               #The group for which the controller-manager will auto approve all CSRs for kubelet client certificates.
 

                                  ┌─────────────────────┐
                                  │   NODE NETWORKING   │
                                  └─────────────────────┘

NODE.status.addresses                             #NODEADDR_ARR. List of addresses reachable to the node.
                                                  #Queried from cloud provider, if available.
NODEADDR.address                                  #"IP"
NODEADDR.type                                     #STR, among: "Hostname", "ExternalIP" or "InternalIP".

NODE.status.daemonEndpoints                       #NODEDAEMONENDPOINTS. Endpoints of daemons running on the Node.
NODEDAEMONENDPOINTS.kubeletEndpoint               #DAEMONENDPOINT. Endpoint on which Kubelet is listening.
DAEMONENDPOINT.Port                               #PORT_NUM.

NODE.spec.podCIDR                                 #CIDR. Pod IP range assigned to the node.

                                  ┌────────────────────┐
                                  │   POD NETWORKING   │
                                  └────────────────────┘

http://kubernetes.io/docs/admin/networking/


POD.spec.hostNetwork                              #BOOL (def: false). Host networking requested for this pod.
                                                  #Use the host's network namespace.
                                                  #If this option is set, the ports that will be used must be specified.
POD.status.hostIP                                 #STR. IP address of the host to which the pod is assigned.
                                                  #Empty if not yet scheduled.
POD.status.podIP                                  #STR. IP address allocated to the pod.
                                                  #Routable at least within the cluster.
                                                  #Empty if not yet allocated.


kube-proxy ...                                    #
--cluster-cidr CIDR                               #The CIDR range of pods in the cluster.
                                                  #It is used to bridge traffic coming from outside of the cluster. 
                                                  #If not provided, no off-cluster bridging will be performed.
kube-controller-manager ...                       #
--cluster-cidr CIDR                               #CIDR Range for Pods in cluster.

                                  ┌──────────────────────────┐
                                  │   CONTAINER NETWORKING   │
                                  └──────────────────────────┘

http://kubernetes.io/docs/admin/ovs-networking/

CONTAINER.ports                                   #CONTAINERPORT_ARR. Ports to expose from the container.
                                                  #Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational.
                                                  #Not specifying a port here DOES NOT prevent that port from being exposed.
                                                  #Any port which is listening on the default "0.0.0.0" address inside a container will be accessible from the network.
CONTAINERPORT.name                                #PORT_STR
                                                  #Name for the port that can be referred to by services.
CONTAINERPORT.hostPort                            #PORT_NUM. Number of port to expose on the host.
                                                  #Most containers do not need this.
CONTAINERPORT.containerPort                       #PORT_NUM. Number of port to expose on the pod's IP address.
CONTAINERPORT.protocol                            #STR, among "TCP" (def) or "UDP"
CONTAINERPORT.hostIP                              #'IP'. What host IP to bind the external port to.


kubectl run ...                                   #
--expose BOOL                                     #If true (def: false), a public, external service is created for the container(s) which are run
--hostport NUM                                    #The host port mapping for the container port.
                                                  #To demonstrate a single-machine container.
                                                  #DeF: -1
--port NUM                                        #The port that this container exposes.
                                                  #If --expose is true, this is also the port used by the service that is created.
                                                  #Def: -1

                                  ┌───────────┐
                                  │   PROXY   │
                                  └───────────┘

http://kubernetes.io/docs/user-guide/accessing-the-cluster/
http://kubernetes.io/docs/tasks/access-kubernetes-api/http-proxy-access-api/
http://kubernetes.io/docs/user-guide/connecting-to-applications-proxy/


METHOD /RESOURCE/NAME/proxy?path=PATH             #Several syntaxes for the same thing:
METHOD /RESOURCE/NAME/proxy/PATH                  #  - METHOD: GET|PUT|POST|DELETE
METHOD /proxy/[namespaces/NS/]/RESOURCE/NAM[/PATH]#  - RESOURCE: pods|services|nodes
                                                  #  - no other field in QOBJ

kubectl proxy                                     #Run a proxy to the Kubernetes API server
                                                  #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'
--accept-hosts REGEXP                             #Def: '^localhost$,^127\.0\.0\.1$,^\[::1\]$'   
                                                  #Regular expression for hosts that the proxy should accept.
--accept-paths REGEXP                             #Def: '^/.*'
                                                  #Regular expression for paths that the proxy should accept.
--address IP                                      #The IP address on which to serve on. Def: 127.0.0.1
--api-prefix STR                                  #Prefix to serve the proxied API under. Def: '/'
--disable-filter BOOL                             #If true (def: false), disable request filtering in the proxy. 
                                                  #This is dangerous, and can leave you vulnerable to XSRF attacks, when used with an accessible port.
-p
--port NUM                                        #The port on which to run the proxy. Set to 0 to pick a random port. Def: 8001
--reject-methods REGEXP,...                       #Regular expression for HTTP methods that the proxy should reject.
                                                  #Def: 'POST,PUT,PATCH'
--reject-paths REGEXP,...                         #Def: '^/api/.*/pods/.*/exec,^/api/.*/pods/.*/attach'              
                                                  #Regular expression for paths that the proxy should reject.
-u
--unix-socket FILE                                #Unix socket on which to run the proxy. Def: ''
-w
--www DIR                                         #Also serve static files from the given directory under the specified prefix. Def: ''
-P
--www-prefix PATH                                 #Prefix to serve static files under, if static file directory is specified. Def: '/static/'


kube-proxy                                        #The Kubernetes network proxy runs on each node.
                                                  #This reflects services as defined in the Kubernetes API on each node and can do simple TCP,UDP stream forwarding or round robin TCP,UDP forwarding 
                                                  #across a set of backends.
                                                  #Service cluster ips and ports are currently found through Docker-links-compatible environment variables specifying ports opened by the service proxy.
                                                  #There is an optional addon that provides cluster DNS for these cluster IPs.
                                                  #The user must create a service with the apiserver API to configure the proxy.
--bind-address IP                                 #The IP address for the proxy server to serve on (set to 0.0.0.0 for all interfaces) (default 0.0.0.0)
--proxy-port-range NUM-NUM2                       #Range of host ports (beginPort-endPort, inclusive) that may be consumed in order to proxy service traffic.
                                                  #If unspecified (0-0) then ports will be randomly chosen.
--proxy-mode STR                                  #Which proxy mode to use: 'userspace' (older) or 'iptables' (faster).
                                                  #If blank, look at the Node object on the Kubernetes API and respect the 'net.experimental.kubernetes.io/proxy-mode' annotation if provided.
                                                  #Otherwise use the best-available proxy (currently iptables).
                                                  #If the iptables proxy is selected, regardless of how, but the system's kernel or iptables versions are insufficient, 
                                                  #this always falls back to the userspace proxy.
--conntrack-max-per-core NUM                      #Maximum number of NAT connections to track per CPU core (0 to leave the limit as-is and ignore conntrack-min). (default 32768)
--conntrack-min NUM                               #Minimum number of conntrack entries to allocate, regardless of conntrack-max-per-core (set conntrack-max-per-core=0 to leave the limit as-is). 
                                                  #(default 131072)
--conntrack-tcp-timeout-established DUR           #Idle timeout for established TCP connections (0 to leave as-is) (default 24h0m0s)
--udp-timeout DUR                                 #How long an idle UDP connection will be kept open (e.g. '250ms', '2s').
                                                  #Must be greater than 0.
                                                  #Only applicable for proxy-mode=userspace (default 250ms)
--iptables-masquerade-bit 0-31                    #Like kubelet
--iptables-sync-period DUR                        #How often iptables rules are refreshed (e.g. '5s', '1m', '2h22m').
                                                  #Must be greater than 0. (default 30s)
--masquerade-all                                  #If using the pure iptables proxy, SNAT everything
--cleanup-iptables                                #If true cleanup iptables rules and exit.
--config-sync-period DUR                          #How often configuration from the apiserver is refreshed.
                                                  #Must be greater than 0. (default 15m0s)

                                  ┌─────────────┐
                                  │   SERVICE   │
                                  └─────────────┘

http://kubernetes.io/docs/user-guide/services/
http://kubernetes.io/docs/tutorials/kubernetes-basics/expose-intro/
http://kubernetes.io/docs/tutorials/stateless-application/expose-external-ip-address-service/
http://kubernetes.io/docs/tutorials/stateless-application/expose-external-ip-address/
http://kubernetes.io/docs/user-guide/quick-start/
http://kubernetes.io/docs/user-guide/connecting-applications/
http://kubernetes.io/docs/user-guide/services/operations/
http://kubernetes.io/docs/user-guide/load-balancer/
http://kubernetes.io/docs/user-guide/services-firewalls/
http://kubernetes.io/docs/admin/static-pods/


SERVICE.spec.ports                                #SERVICEPORT_ARR
SERVICEPORT.port                                  #PORT_NUM. Exposed port
kubectl expose ...                                #
--port NUM                                        #The port that the service should serve on. Copied from the resource being exposed, if unspecified
kubectl create service ...
--tcp PORT:TARGET_PORT,...                        #Port pairs can be specified as '<port>:<targetPort>'.
SERVICEPORT.name                                  #NAME. This must be a DNS_LABEL. Corresponds to ENDPOINTPORT.name. Optional if only one SERVICEPORT in this SERVICE
SERVICEPORT.protocol                              #Among: "TCP" (def) and "UDP"
kubectl expose ...                                #
--protocol PROTO                                  #The network protocol for the service to be created. Default is 'TCP'.
SERVICEPORT.targetPort                            #PORT_STR. Number or name of the port to access on the pods targeted by the service.
                                                  #If this is specified, it will be looked up as a named port in the target Pod's container ports.
                                                  #If this is not specified, the value of the port field is used (an identity map).
                                                  #This field is ignored for services with clusterIP=None, and should be omitted or set equal to the port field. 
kubectl expose ...                                #
--target-port NUM                                 #Name or number for the port on the container that the service should direct traffic to. Optional.
SERVICEPORT.nodePort                              #PORT_NUM. The port on each node on which this service is exposed when type=NodePort or LoadBalancer.
                                                  #Assigned by the system
                                                  #If specified, it will be allocated to the service if unused or else creation of the service will fail.
                                                  #Default is to auto-allocate a port if the ServiceType of this Service requires one.
kubectl expose ...                                #
--container-port NUM                              #Name or number for the port on the container that the service should direct traffic to. Optional.

SERVICE.spec.type                                 #How the SERVICE is exposed, among:
                                                  #  - "ExternalName": maps to the specified externalName. 
                                                  #  - "ClusterIP" (def):
                                                  #     - allocates a cluster-internal IP address for load-balancing to endpoints. 
                                                  #     - Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object. 
                                                  #     - If clusterIP is "None", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a stable IP. 
                                                  #  - "NodePort": builds on ClusterIP and allocates a port on every node which routes to the clusterIP. 
                                                  #  - "LoadBalancer": builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the clusterIP. 
kubectl expose ...                                #
--type STR                                        #Type for this service: ClusterIP, NodePort, or LoadBalancer. Default is 'ClusterIP'.
--create-external-load-balancer BOOL              #If true (def: false), create an external load balancer for this service (trumped by --type). 
                                                  #Implementation is cloud provider dependent.

(SERVICE type "ExternalName")
SERVICE.spec.externalName                         #STR. External reference that kubedns or equivalent will return as a CNAME record for this service. 
                                                  #No proxying will be involved. 
                                                  #Must be a valid DNS name

(SERVICE type "ClusterIP|NodePort|LoadBalancer")
SERVICE.spec.selector                             #OBJ. Route service traffic to pods with label keys and values matching this selector.
                                                  #If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify.
kubectl expose ...                                #
--selector STR                                    #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.
SERVICE.spec.clusterIP                            #'IP' of the service. Usually assigned randomly by the master.
                                                  #If an address is specified manually and is not in use by others, it will be allocated to the service; otherwise, creation of the service will fail.
                                                  #Read-only
                                                  #Can also be:
                                                  #  - ""
                                                  #  - "None": for headless services when proxying is not required. 
kubectl expose ...                                #
--cluster-ip IP                                   #ClusterIP to be assigned to the service. Leave empty to auto-allocate, or set to 'None' to create a headless service.
kubectl create service clusterip ...              #
--clusterip IP                                    #Assign your own ClusterIP or set to 'None' for a 'headless' service (no loadbalancing).

(SERVICE type "LoadBalancer")
SERVICE.spec.loadBalancerIP                       #'IP'. LoadBalancer will get created with the IP specified in this field. 
kubectl expose ...                                #
--load-balancer-ip IP                             #IP to assign to the Load Balancer. If empty, an ephemeral IP will be created and used (cloud-provider specific).
SERVICE.spec.loadBalancerSourceRanges             #'IP'_ARR. Restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. 
SERVICE.status.loadBalancer                       #LOADBALANCER.status
LOADBALANCER.status.ingress                       #LOADBALANCERSTATUSINGRESS_ARR. Ingress points for the load-balancer.
                                                  #Traffic intended for the service should be sent to these ingress points.
LOADBALANCERSTATUSINGRESS.ip                      #'IP' is set for load-balancer ingress points that are IP based (typically GCE or OpenStack load-balancers)
LOADBALANCERSTATUSINGRESS.hostname                #'HOSTNAME' is set for load-balancer ingress points that are DNS based (typically AWS load-balancers)

(all SERVICE types)
SERVICE.spec.externalIPs                          #'IP'_ARR for which nodes in the cluster will also accept traffic for this service. 
                                                  #These IPs are not managed by Kubernetes. 
                                                  #The user is responsible for ensuring that traffic arrives at a node with this IP. 
                                                  #A common example is external load-balancers that are not part of the Kubernetes system. 
kubectl expose ...                                #
--external-ip IP                                  #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.
SERVICE.spec.sessionAffinity                      #Among: 
                                                  #  - "ClientIP"
                                                  #  - "None" (def)
kubectl expose ...                                #
--session-affinity STR                            #If non-empty, set the session affinity for the service to this; legal values: 'None', 'ClientIP'


kubectl create service 
 clusterip|loadbalancer|nodeport SERVICE          #Create a clusterIP|LoadBalancer|NodePort service.

kubectl expose DEPLOYMENT|POD|REPLICASET|         #Take a replication controller, service, deployment or pod and expose it as a new Kubernetes Service
 REPLICACONTROLLER|SERVICE_RESC...                #Expose a resource as a new Kubernetes service.
                                                  #Looks up a deployment, service, replica set, replication controller or pod by name and uses the selector 
                                                  #for that resource as the selector for a new service on the specified port. 
                                                  #A deployment or replica set will be exposed as a service only if its selector is convertible to a selector that service supports, 
                                                  #i.e. when the selector contains only the matchLabels component. 
                                                  #Note that if no port is specified via --port and the exposed resource has multiple ports, all will be re-used by the new service. 
                                                  #Also if no labels are specified, the new service will re-use the labels from the resource it exposes.
--name STR                                        #The name for the newly created object.


kube-apiserver ...                                #
--kubernetes-service-node-port 0|1                #If non-zero, the Kubernetes master service (which apiserver creates/maintains) will be of type NodePort, using this as the value of the port.
                                                  #If zero, the Kubernetes master service will be of type ClusterIP.
--service-cluster-ip-range CIDR                   #A CIDR notation IP range from which to assign service cluster IPs.
                                                  #This must not overlap with any IP ranges assigned to nodes for pods.
--service-node-port-range NUM-NUM2                #A port range to reserve for services with NodePort visibility.
                                                  #Example: '30000-32767'.
                                                  #Inclusive at both ends of the range. (default 30000-32767)


kube-controller-manager ...                       #
--service-cluster-ip-range string                 #CIDR Range for Services in cluster.

                                  ┌─────────────┐
                                  │   INGRESS   │
                                  └─────────────┘

http://kubernetes.io/docs/user-guide/ingress/


INGRESS.spec.backend                              #INGRESSBACKEND. A default backend capable of servicing requests that don't match any rule.
                                                  #At least one of backend or rules must be specified.
                                                  #This field is optional to allow the loadbalancer controller or defaulting logic to specify a global default.
HTTPINGRESSPATH.backend                           #INGRESSBACKEND. Backend defines the referenced service endpoint to which the traffic will be forwarded to.
                                                  #Required
INGRESSBACKEND.serviceName                        #SERVICE_NAME of the referenced service.
INGRESSBACKEND.servicePort                        #SERVICE PORT_STR of the referenced service.

INGRESS.spec.tls                                  #INGRESSTLS_ARR. TLS configuration.
                                                  #Currently the Ingress only supports a single TLS port, 443.
                                                  #If multiple members of this list specify different hosts, they will be multiplexed on the same port according to the hostname
                                                  #specified through the SNI TLS extension, if the ingress controller fulfilling the ingress supports SNI.
INGRESSTLS.hosts                                  #HOST_ARR included in the TLS certificate.
                                                  #The values in this list must match the name/s used in the tlsSecret.
                                                  #Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified.
INGRESSTLS.secretName                             #SECRET_NAME used to terminate SSL traffic on 443.
                                                  #Field is left optional to allow SSL routing based on SNI hostname alone.
                                                  #If the SNI host in a listener conflicts with the "Host" header field used by an IngressRule, 
                                                  #the SNI host is used for termination and value of the Host header is used for routing.

INGRESS.spec.rules                                #INGRESSRULE_ARR. Host rules used to configure the Ingress.
                                                  #If unspecified, or no rule matches, all traffic is sent to the default backend.
INGRESSRULE.host                                  #HOST. Fully qualified domain name of a network host, as defined by RFC 3986.
                                                  #Note the following deviations from the "host" part of the URI as defined in the RFC: 
                                                  #  1. IPs are not allowed.
                                                  #     Currently an IngressRuleValue can only apply to the IP in the Spec of the parent Ingress.  
                                                  #  2. The : delimiter is not respected because ports are not allowed.
                                                  #     Currently the port of an Ingress is implicitly :80 for http and :443 for https.
                                                  #Both these may change in the future.
                                                  #Incoming requests are matched against the host before the IngressRuleValue.
                                                  #If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue.
INGRESSRULE.http                                  #HTTPINGRESSRULEVALUE
HTTPINGRESSRULEVALUE.paths                        #HTTPINGRESSPATH_ARR. Paths that map requests to backends.
                                                  #Required
HTTPINGRESSPATH.path                              #PATH_REGEXP. Extended POSIX regex as defined by IEEE Std 1003.1, (i.e this follows the egrep/unix syntax, not the perl syntax) 
                                                  #matched against the path of an incoming request.
                                                  #Currently it can contain characters disallowed from the conventional "path" part of a URL as defined by RFC 3986. 
                                                  #Paths must begin with a /.
                                                  #If unspecified, the path defaults to a catch all sending traffic to the backend.

INGRESS.status.loadBalancer                       #LOADBALANCER.status

                                  ┌──────────────┐
                                  │   ENDPOINT   │
                                  └──────────────┘

ENDPOINT.subsets                                  #ENDPOINTSUBSET_ARR. The set of all endpoints is the union of all subsets.
                                                  #Addresses are placed into subsets according to the IPs they share.
                                                  #A single address with multiple ports, some of which are ready and some of which are not (because they come from different containers)
                                                  #will result in the address being displayed in different subsets for the different ports.
                                                  #No address will appear in both ENDPOINTSUBSET.Addresses and ENDPOINTSUBSET.NotReadyAddresses in the same subset.
                                                  #Sets of addresses and ports that comprise a service.
                                                  #Required

ENDPOINTSUBSET.addresses                          #ENDPOINTADDR_ARR. IP addresses which offer the related ports that are marked as ready.
                                                  #These endpoints should be considered safe for load balancers and clients to utilize.
ENDPOINTSUBSET.notReadyAddresses                  #ENDPOINTADDR_ARR. IP addresses which offer the related ports but are not currently marked as ready because 
                                                  #they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check.
ENDPOINTADDR.ip                                   #'IP'. The IP of this endpoint.
                                                  #May not be loopback (127.0.0.0/8), link-local (169.254.0.0/16), or link-local multicast ((224.0.0.0/24). 
                                                  #IPv6 is also accepted but not fully supported on all platforms.
                                                  #Also, certain kubernetes components, like kube-proxy, are not IPv6 ready.
ENDPOINTADDR.hostname                             #STR
ENDPOINTADDR.nodeName                             #NODE_NAME. Optional: Node hosting this endpoint.
                                                  #This can be used to determine endpoints local to a node.
ENDPOINTADDR.targetRef                            #OBJREF. Reference to object providing the endpoint.

ENDPOINTSUBSET.ports                              #ENDPORT_ARR. Port numbers available on the related IP addresses.
ENDPOINTPORT.name                                 #STR. The name of this port (corresponds to SERVICEPORT.Name). Optional only if one port is defined.
ENDPOINTPORT.port                                 #PORT_NUM
ENDPOINTPORT.protocol                             #'UDP' or 'TCP' (def)

                                  ┌─────────────────────┐
                                  │   PORT FORWARDING   │
                                  └─────────────────────┘

http://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/
http://kubernetes.io/docs/user-guide/connecting-to-applications-port-forward/


GET|POST /pods/NAME/portforward                   #Uses no QOBJ

kubectl port-forward POD 
 [LOCAL_PORT]:REMOTE_PORT ...                     #Forward one or more local ports to a pod 
-p
--pod POD                                         #

                                  ┌────────────────────┐
                                  │   NETWORK POLICY   │
                                  └────────────────────┘

http://kubernetes.io/docs/user-guide/networkpolicies/
http://kubernetes.io/docs/getting-started-guides/network-policy/walkthrough/
http://kubernetes.io/docs/getting-started-guides/network-policy/calico/
http://kubernetes.io/docs/getting-started-guides/network-policy/romana/


NETWORKPOLICY.spec.podSelector                    #LABELSELECTOR. Selects the pods to which this NetworkPolicy object applies.
                                                  #The array of ingress rules is applied to any pods selected by this field.
                                                  #Multiple network policies can select the same set of pods.
                                                  #In this case, the ingress rules for each are combined additively.
                                                  #This field is NOT optional and follows standard label selector semantics.
                                                  #An empty podSelector matches all pods in this namespace.
                                                  #Required.

NETWORKPOLICY.spec.ingress                        #NETWORKPOLICYINGRESSRULE_ARR. List of ingress rules to be applied to the selected pods.
                                                  #Traffic is allowed to a pod if namespace.networkPolicy.ingress.isolation is undefined and cluster policy allows it, OR if the traffic source 
                                                  #is the pod's local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod.
                                                  #If this field is empty then this NetworkPolicy does not affect ingress isolation.
                                                  #If this field is present and contains at least one rule, this policy allows any traffic which matches at least one of the ingress rules in this list.

NETWORKPOLICYINGRESSRULE.ports                    #NETWORKPOLICYPORT_ARR. List of ports which should be made accessible on the pods selected for this rule.
                                                  #Each item in this list is combined using a logical OR.
                                                  #If this field is not provided, this rule matches all ports (traffic not restricted by port).
                                                  #If this field is empty, this rule matches no ports (no traffic matches).
                                                  #If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list.
NETWORKPOLICYPORT.protocol                        #STR, among "TCP" (def) or "UDP"
                                                  #The protocol which traffic must match.
NETWORKPOLICYPORT.port                            #PORT_STR. If specified, the port on the given protocol.
                                                  #This can either be a numerical or named port on a pod.
                                                  #If this field is not provided, this matches all port names and numbers.
                                                  #If present, only traffic on the specified protocol AND port will be matched.

NETWORKPOLICYINGRESSRULE.from                     #NETWORKPOLICYPEER_ARR. List of sources which should be able to access the pods selected for this rule.
                                                  #Items in this list are combined using a logical OR operation.
                                                  #If this field is not provided, this rule matches all sources (traffic not restricted by source).
                                                  #If this field is empty, this rule matches no sources (no traffic matches).
                                                  #If this field is present and contains at least on item, this rule allows traffic only if the traffic matches at least one item in the from list.
NETWORKPOLICYPEER.podSelector                     #LABELSELECTOR. Selects Pods in this namespace.
                                                  #This field follows standard label selector semantics.
                                                  #If not provided, this selector selects no pods.
                                                  #If present but empty, this selector selects all pods in this namespace.
NETWORKPOLICYPEER.namespaceSelector               #LABELSELECTOR. Selects Namespaces using cluster scoped-labels.
                                                  #This matches all pods in all namespaces selected by this label selector.
                                                  #This field follows standard label selector semantics.
                                                  #If omitted, this selector selects no namespaces.
                                                  #If present but empty, this selector selects all namespaces.

                                  ┌─────────┐
                                  │   DNS   │
                                  └─────────┘

http://kubernetes.io/docs/admin/dns/

kubeadm init ...
--api-external-dns-names NAME,...                 #The DNS names to advertise, in case you have configured them yourself
--service-dns-domain NAME                         #Use alternative domain for services, e.g. "myorg.internal" (default "cluster.local")

kubelet ...
--cluster-dns IP                                  #IP address for a cluster DNS server. This value is used for containers' DNS server in case of Pods with "dnsPolicy=ClusterFirst"
--cluster-domain DOMAIN                           #Domain for this cluster. If set, kubelet will configure all containers to search this domain in addition to the host's search domains
--resolv-conf FILE                                #Resolver configuration file used as the basis for the container DNS resolution configuration. (default "/etc/resolv.conf")

POD.spec.dnsPolicy                                #Set DNS policy for containers within the pod. Either "ClusterFirst" (def) or "Default"

POD.spec.hostname                                 #STR. Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.
POD.spec.subdomain                                #STR . If specified, the fully qualified Pod hostname will be "<hostname>.<subdomain>.<pod namespace>.svc.<cluster domain>". 
                                                  #If not specified, the pod will not have a domainname at all.
kubelet|kube-proxy ...
--hostname-override HOSTNAME                      #Use this string as identification instead of the actual hostname.

kube-apiserver ...                                #
--external-hostname string                        #The hostname to use when generating externalized URLs for this master (e.g. Swagger API Docs).

                                  ┌───────────────────────┐
                                  │   HIGH AVAILABILITY   │
                                  └───────────────────────┘

http://kubernetes.io/docs/admin/high-availability/

kube-apiserver
--apiserver-count NUM                             #The number of apiservers running in the cluster. (default 1)

kube-controller-manager|scheduler
--leader-elect                                    #Start a leader election client and gain leadership before executing the main loop. 
                                                  #Enable this when running replicated components for high availability. (default true)
--leader-elect-lease-duration DUR                 #The duration that non-leader candidates will wait after observing a leadership renewal until attempting to acquire leadership of a led
                                                  #but unrenewed leader slot.
                                                  #This is effectively the maximum duration that a leader can be stopped before it is replaced by another candidate. 
                                                  #This is only applicable if leader election is enabled. (default 15s)
--leader-elect-renew-deadline DUR                 #The interval between attempts by the acting master to renew a leadership slot before it stops leading. 
                                                  #This must be less than or equal to the lease duration. 
                                                  #This is only applicable if leader election is enabled. (default 10s)
--leader-elect-retry-period DUR                   #The duration the clients should wait between attempting acquisition and renewal of a leadership. 
                                                  #This is only applicable if leader election is enabled. (default 2s)

                                  ┌────────────────┐
                                  │   FEDERATION   │
                                  └────────────────┘

http://kubernetes.io/docs/user-guide/federation/
http://kubernetes.io/docs/user-guide/federation/federated-services/
http://kubernetes.io/docs/admin/federation/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/federated-replicasets.md
https://github.com/kubernetes/kubernetes/blob/master/docs/design/federated-services.md
https://github.com/kubernetes/kubernetes/blob/master/docs/design/federation-phase-1.md

                                  ┌──────────────────┐
                                  │   HEALTHCHECKS   │
                                  └──────────────────┘

http://kubernetes.io/docs/user-guide/liveness/


CONTAINER.livenessProbe                           #PROBE. Periodic probe of container liveness.
                                                  #Container will be restarted if the probe fails.
CONTAINER.readinessProbe                          #PROBE. Periodic probe of container service readiness.
                                                  #Container will be removed from service endpoints if the probe fails.
CONTAINER.status.ready                            #BOOL (def: false). Specifies whether the container has passed its readiness probe.
PROBE.exec|httpGet|tcpSocket                      #Like HANDLER.*
PROBE.initialDelaySeconds                         #NUM. Number of seconds after the container has started before liveness probes are initiated.
PROBE.timeoutSeconds                              #NUM (def: 1, in secs, min 1). Number of seconds after which the probe times out.
PROBE.periodSeconds                               #NUM (def: 10, in secs, min 1). How often (in seconds) to perform the probe.
PROBE.successThreshold                            #NUM (def: 1, in secs, min 1). Minimum consecutive successes for the probe to be considered successful after having failed.
                                                  #Must be 1 for liveness.
PROBE.failureThreshold                            #NUM (def: 3, in secs, min1). Minimum consecutive failures for the probe to be considered failed after having succeeded.


kubelet|kube-proxy ...
--healthz-bind-address IP                         #The IP address for the healthz server to serve on, defaulting to 127.0.0.1 (set to 0.0.0.0 for all interfaces) (default 127.0.0.1)
--healthz-port NUM                                #The port of the localhost healthz endpoint. Use 0 to disable. (default 10248 for kubelet, 10249 for kube-proxy)

kubelet ...
--node-status-update-frequency DUR                #Specifies how often kubelet posts node status to master. 
                                                  #Note: be cautious when changing the constant, it must work with --node-monitor-grace-period in nodecontroller. Default: 10s (default 10s)

kube-controller-manager ...                       #
--node-monitor-grace-period DUR                   #Amount of time which we allow running Node to be unresponsive before marking it unhealthy. 
                                                  #Must be N times more than kubelet's nodeStatusUpdateFrequency, where N means number of retries allowed for kubelet to post node status. (default 40s)
--node-startup-grace-period DUR                   #Amount of time which we allow starting Node to be unresponsive before marking it unhealthy. (default 1m0s)

                                  ┌──────────────────────┐
                                  │   COMPONENT STATUS   │
                                  └──────────────────────┘

COMPONENTSTATUS.conditions                        #COMPONENT_CONDITION_ARR
                                                  #Does not have COMPONENT_CONDITION.lastProbeTime|lastTransitionTime
COMPONENT_CONDITION.type                          #Type, among: "Healthy"

                                  ┌─────────────────┐
                                  │   PERFORMANCE   │
                                  └─────────────────┘

kube-apiserver ...                                #
--deserialization-cache-size NUM                  #Number of deserialized json objects to cache in memory.
--watch-cache                                     #Enable watch caching in the apiserver (default true)
--watch-cache-sizes STR,...                       #List of watch cache sizes for every resource (pods, nodes, etc.), comma separated.
                                                  #The individual override format: resource#size, where size is a number. 
                                                  #It takes effect when watch-cache is enabled. (default [])

kube-controller-manager ...                       #
--concurrent-deployment-syncs NUM                 #The number of deployment objects that are allowed to sync concurrently.
                                                  #Larger number = more responsive deployments, but more CPU (and network) load (default 5)
--concurrent-endpoint-syncs NUM                   #The number of endpoint syncing operations that will be done concurrently.
                                                  #Larger number = faster endpoint updating, but more CPU (and network) load (default 5)
--concurrent-gc-syncs NUM                         #The number of garbage collector workers that are allowed to sync concurrently. (default 20)
--concurrent-namespace-syncs NUM                  #The number of namespace objects that are allowed to sync concurrently.
                                                  #Larger number = more responsive namespace termination, but more CPU (and network) load (default 2)
--concurrent-replicaset-syncs NUM                 #The number of replica sets that are allowed to sync concurrently.
                                                  #Larger number = more responsive replica management, but more CPU (and network) load (default 5)
--concurrent-resource-quota-syncs NUM             #The number of resource quotas that are allowed to sync concurrently.
                                                  #Larger number = more responsive quota management, but more CPU (and network) load (default 5)
--concurrent-service-syncs NUM                    #The number of services that are allowed to sync concurrently.
                                                  #Larger number = more responsive service management, but more CPU (and network) load (default 1)
--concurrent-serviceaccount-token-syncs NUM       #The number of service account token objects that are allowed to sync concurrently.
                                                  #Larger number = more responsive token generation, but more CPU (and network) load (default 5)
--concurrent_rc_syncs NUM                         #The number of replication controllers that are allowed to sync concurrently.
                                                  #Larger number = more responsive replica management, but more CPU (and network) load (default 5)

kube-controller-manager ...                       #
--daemonset-lookup-cache-size NUM                 #The the size of lookup cache for daemonsets.
                                                  #Larger number = more responsive daemonsets, but more MEM load. (default 1024)
--daemonset-lookup-cache-size NUM                 #The the size of lookup cache for daemonsets.
                                                  #Larger number = more responsive daemonsets, but more MEM load. (default 1024)
--replicaset-lookup-cache-size NUM                #The the size of lookup cache for replicatsets.
                                                  #Larger number = more responsive replica management, but more MEM load. (default 4096)
--replication-controller-lookup-cache-size NUM    #The the size of lookup cache for replication controllers.
                                                  #Larger number = more responsive replica management, but more MEM load. (default 4096)

kube-controller-manager ...                       #
--node-monitor-period DUR                         #The period for syncing NodeStatus in NodeController. (default 5s)
--node-sync-period DUR                            #The period for syncing nodes from cloudprovider. 
                                                  #Longer periods will result in fewer calls to cloud provider, but may delay addition of new nodes to cluster. (default 10s)
--deployment-controller-sync-period DUR           #Period for syncing the deployments. (default 30s)
--horizontal-pod-autoscaler-sync-period DUR       #The period for syncing the number of pods in horizontal pod autoscaler. (default 30s)
--min-resync-period DUR                           #The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod (default 12h0m0s)
--namespace-sync-period DUR                       #The period for syncing namespace life-cycle updates (default 5m0s)
--resource-quota-sync-period DUR                  #The period for syncing quota usage status in the system (default 5m0s)
--pvclaimbinder-sync-period duration              #The period for syncing persistent volumes and persistent volume claims (default 15s)
--service-sync-period DUR                         #The period for syncing services with their external load balancers (default 5m0s)

kubelet ...
--file-check-frequency DUR                        #Duration between checking config files for new data (default 20s)
--http-check-frequency DUR                        #Duration between checking http for new data (default 20s)
--sync-frequency DUR                              #Max period between synchronizing running containers and config (default 1m0s)
                                                  #Empty for no container. Rolling back the flag requires a reboot. (Default: "").

                                  ┌────────────────────┐
                                  │   RESOURCE QUOTA   │
                                  └────────────────────┘

http://kubernetes.io/docs/admin/resourcequota/
http://kubernetes.io/docs/admin/resourcequota/walkthrough/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/admission_control_resource_quota.md


RESQUOTA.spec.hard                                #OBJ. Set of desired hard limits for each named resource.
kubectl create [resource]quota ...                #
--hard TYPE=NUM,...                               #A comma-delimited set of resource=quantity pairs that define a hard limit.

RESQUOTA.status.hard                              #OBJ. Set of enforced hard limits for each named resource.


RESQUOTA.spec.scopes                              #OBJ_ARR. A collection of filters that must match each object tracked by a quota.
kubectl create [resource]quota ...                #
--scopes STR,...                                  #A comma-delimited set of quota scopes that must all match each object tracked by the quota.

RESQUOTA.status.used                              #OBJ. Current observed total usage of the resource in the namespace.


kubectl create [resource]quota QUOTA              #Create a quota with the specified name.

                                  ┌─────────────────┐
                                  │   LIMIT RANGE   │
                                  └─────────────────┘

http://kubernetes.io/docs/admin/limitrange/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/admission_control_limit_range.md
http://kubernetes.io/docs/user-guide/compute-resources/ 
http://kubernetes.io/docs/tasks/configure-pod-container/assign-cpu-ram-container/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/resource-qos.md


LIMITRANGE.spec.limits                            #LIMITRANGEITEM_ARR
                                                  #Required

LIMITRANGEITEM.type                               #STR. Type of resource that this limit applies to.
LIMITRANGEITEM.min|max                            #OBJ. Min|max usage constraints on this kind by resource name.
LIMITRANGEITEM.default                            #OBJ. Default resource requirement limit value by resource name if resource limit is omitted.
LIMITRANGEITEM.defaultRequest                     #OBJ. Default resource requirement request value by resource name if resource request is omitted.
LIMITRANGEITEM.maxLimitRequestRatio               #OBJ. If specified, the named resource must have a request and limit that are both non-zero where limit
                                                  #divided by request is less than or equal to the enumerated value; this represents the max burst for the named resource.


PERSISTENTVOLUMECLAIM.spec.resources              #RESOURCEREQ. Resources represents the minimum resources the volume should have.
CONTAINER.resources                               #RESOURCEREQ. Compute Resources required by this container.
                                                  #Read-only.

RESOURCEREQ.limits                                #OBJ. Maximum amount of compute resources allowed.
RESOURCEREQ.requests                              #OBJ. Requests describes the minimum amount of compute resources required.
                                                  #If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value.


kubectl run ...                                   #
--limits TYPE=VAL,...                             #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.
kubectl run ...                                   #
--requests TYPE=VAL,...                           #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.


kubelet ...
--kube|system-reserved RESOURCE=QUANT,...         #A set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for kubernetes [non-]system components. 
                                                  #Currently only cpu and memory are supported. [default=none]

                                  ┌────────────┐
                                  │   LIMITS   │
                                  └────────────┘

kubelet|kube-proxy|controller-manager|scheduler   #
--kube-api-qps NUM                                #QPS to use while talking with kubernetes apiserver (default 5|5|20|50)
kubelet ...                                       #
--registry-qps NUM                                #If > 0, limit registry pull QPS to this value.  If 0, unlimited. [default=5.0] (default 5)
kubelet|kube-proxy|controller-manager|scheduler   #
--kube-api-burst value                            #Burst to use while talking with kubernetes apiserver (default 10|10|30|100)
kubelet ...
--registry-burst NUM                              #Maximum size of a bursty pulls, temporarily allows pulls to burst to this number, while still not exceeding registry-qps.
                                                  #Only used if --registry-qps > 0 (default 10)

kubelet ...
--max-open-files NUM                              #Number of files that can be opened by Kubelet process. [default=1000000] (default 1000000)
--max-pods NUM                                    #Number of Pods that can run on this Kubelet. (default 110)
--pods-per-core NUM                               #Number of Pods per core that can run on this Kubelet. 
                                                  #The total number of Pods on this Kubelet cannot exceed max-pods, 
                                                  #so max-pods will be used if this calculation results in a larger number of Pods allowed on the Kubelet. 
                                                  #A value of 0 disables this limit.

kubelet ...
--low-diskspace-threshold-mb NUM                  #The absolute free disk space, in MB, to maintain. When disk space falls below this threshold, new pods would be rejected. Default: 256
--outofdisk-transition-frequency DUR              #Duration for which the kubelet has to wait before transitioning out of out-of-disk node condition status. Default: 5m0s (default 5m0s)
kubelet|kube-proxy ...
--oom-score-adj -1000-1000                        #The oom-score-adj value for this process. Values must be within the range [-1000, 1000] (default -999)

kubelet ...
--cpu-cfs-quota                                   #Enable CPU CFS quota enforcement for containers that specify CPU limits (default true)


kube-apiserver ...                                #
--max-connection-bytes-per-sec NUM                #If non-zero, throttle each user connection to this number of bytes/sec.
                                                  #Currently only applies to long-running requests.
--max-requests-inflight NUM                       #The maximum number of requests in flight at a given time.
                                                  #When the server exceeds this, it rejects requests. 
                                                  #Zero for no limit. (default 400)
--long-running-request-regexp REGEXP              #A regular expression matching long running requests which should be excluded from maximum inflight request handling. 
                                                  #(default "(/|^)((watch|proxy)(/|$)|(logs?|portforward|exec|attach)/?$)")
--target-ram-mb NUM                               #Memory limit for apiserver in MB (used to configure sizes of caches, etc.)


minikube start ...                                #
--cpus NUM                                        #For the VM. Def: 2
--memory NUM                                      #For the VM. Def: 2048
--disk-size NUM                                   #For the VM. Def: 20g

                                  ┌──────────────┐
                                  │   DELETION   │
                                  └──────────────┘

http://kubernetes.io/docs/admin/out-of-resource/
http://kubernetes.io/docs/user-guide/garbage-collection/
http://kubernetes.io/docs/admin/garbage-collection/


DELETEOPTS                                        #DELETE /RESOURCE/NAME request body
EVICTION.deleteOptions                            #DELETEOPTS


DELETEOPTS.preconditions                          #PRECOND. Must be fulfilled before a deletion is carried out.
                                                  #If not possible, a 409 Conflict status will be returned.
PRECOND.uid                                       #Target UID.


METADATA.finalizers                               #STR_ARR. Must be empty before the object is deleted from the registry.
NAMESPACE.spec.finalizers                         #Each entry is an identifier for the responsible component that will remove the entry from the list.
                                                  #If the deletionTimestamp of the object is non-nil, entries in this list can only be removed.
DELETEOPTS.orphanDependents                       #BOOL (def: false). Should the dependent objects be orphaned.
                                                  #If true|false, the "orphan" finalizer will be added to|removed from the object's finalizers list.


DELETEOPTS.gracePeriodSeconds                     #UINT. The duration in seconds before the object should be deleted. 
                                                  #0 indicates delete immediately.
                                                  #If this value is nil, the default grace period for the specified type will be used.
                                                  #Defaults to a per object value if not specified.
METADATA.deletionGracePeriodSeconds               #UINT. Number of seconds allowed for this object to gracefully terminate before it will be removed from the system.
                                                  #Only set when METADATA.deletionTimestamp is also set.
                                                  #Read-only.
POD.spec.terminationGracePeriodSeconds            #UINT. Optional duration in seconds the pod needs to terminate gracefully.
                                                  #May be decreased in delete request.
                                                  #0 indicates delete immediately.
                                                  #If this value is nil, the default grace period will be used instead.
                                                  #The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time 
                                                  #when the processes are forcibly halted with a kill signal. 
                                                  #Set this value longer than the expected cleanup time for your process. 
                                                  #Defaults to 30 seconds.
kubelet ...                                       #
--eviction-max-pod-grace-period NUM               #Maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met.  
                                                  #If negative, defer to pod specified value.
--eviction-soft-grace-period STR                  #A set of eviction grace periods (e.g. memory.available=1m30s) that correspond to how long a 
                                                  #soft eviction threshold must hold before triggering a pod eviction.
kubectl delete|replace|drain ...                  #
--grace-period NUM                                #Period of time in seconds given to the resource to terminate gracefully. Ignored if negative (def: -1)
kubectl delete ...                                #
--now BOOL                                        #If true (def: false), resources are force terminated without graceful deletion (same as --grace-period 0).


METADATA.deletionTimestamp                        #DATE.
                                                  #Read-only, set by server.


kubectl delete|replace                            #
--cascade BOOL                                    #If true, cascade the deletion of the resources managed by this resource (e.g. Pods created by a ReplicationController). 
                                                  #Def: true for delete, false for replace.
METADATA.ownerReferences                          #OWNERREF_ARR. List of objects depended by this object. 
                                                  #If ALL objects in the list have been deleted, this object will be garbage collected.
                                                  #If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true.
                                                  #There cannot be more than one managing controller.
OWNERREF.uid                                      #UID of the referent.
OWNERREF.controller                               #BOOL. If true, this reference points to the managing controller.

kubectl run ...                                   #
--rm BOOL                                         #If true (def: false), delete resources created in this command for attached containers.


kube-apiserver ...                                #
--delete-collection-workers NUM                   #Number of workers spawned for DeleteCollection call.
                                                  #These are used to speed up namespace cleanup. (default 1)

                                  ┌────────────────────────┐
                                  │   GARBAGE COLLECTION   │
                                  └────────────────────────┘

kubelet ...                                       #
--image-gc-high-threshold NUM                     #The percent of disk usage after which image garbage collection is always run. Default: 90% (default 90)
--image-gc-low-threshold NUM                      #The percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to. Default: 80% (default 80)
--minimum-image-ttl-duration DUR                  #Minimum age for an unused image before it is garbage collected.  Examples: '300ms', '10s' or '2h45m'. Default: '2m'

kube-apiserver|controller-manager ...
--enable-garbage-collector                        #Enables the generic garbage collector.
                                                  #MUST be synced with the corresponding flag of the kube-controller-manager. (default true)

kubelet ...                                       #
--eviction-soft STR                               #A set of eviction thresholds (e.g. memory.available<1.5Gi) that if met over a corresponding grace period would trigger a pod eviction.
--eviction-hard STR                               #A set of eviction thresholds (e.g. memory.available<1Gi) that if met would trigger a pod eviction. (default "memory.available<100Mi")
--eviction-minimum-reclaim STR                    #A set of minimum reclaims (e.g. imagefs.available=2Gi) that describes the minimum amount of resource the kubelet will reclaim 
                                                  #when performing a pod eviction if that resource is under pressure.
--eviction-pressure-transition-period DUR         #Duration for which the kubelet has to wait before transitioning out of an eviction pressure condition. (default 5m0s)

kubelet ...
--global-housekeeping-interval DUR                #Interval between global housekeepings (default 1m0s)
--housekeeping-interval DUR                       #Interval between container housekeepings (default 10s)

kube-controller-manager ...                       #
--terminated-pod-gc-threshold NUM                 #Number of terminated pods that can exist before the terminated pod garbage collector starts deleting terminated pods.
                                                  #If <= 0, the terminated pod garbage collector is disabled. (default 12500)
--node-eviction-rate NUM                          #Number of nodes per second on which pods are deleted in case of node failure when a zone is healthy 
                                                  #(see --unhealthy-zone-threshold for definition of healthy/unhealthy). 
                                                  #Zone refers to entire cluster in non-multizone clusters. (default 0.1)
--secondary-node-eviction-rate NUM                #Number of nodes per second on which pods are deleted in case of node failure when a zone is unhealthy 
                                                  #(see --unhealthy-zone-threshold for definition of healthy/unhealthy). 
                                                  #Zone refers to entire cluster in non-multizone clusters. 
                                                  #This value is implicitly overridden to 0 if the cluster size is smaller than --large-cluster-size-threshold. (default 0.01)
--unhealthy-zone-threshold NUM                    #Fraction of Nodes in a zone which needs to be not Ready (minimum 3) for zone to be treated as unhealthy.  (default 0.55)
--large-cluster-size-threshold value              #Number of nodes from which NodeController treats the cluster as large for the eviction logic purposes. 
                                                  #--secondary-node-eviction-rate is implicitly overridden to 0 for clusters this size or smaller. (default 50)
--pod-eviction-timeout DUR                        #The grace period for deleting pods on failed nodes. (default 5m0s)

                                  ┌─────────────────┐
                                  │   CONCURRENCY   │
                                  └─────────────────┘

[LIST_]METADATA.resourceVersion                   #STR. Version of this object, i.e. updated when object is updated
                                                  #Is opaque, should only be used to check "has it changed", e.g. for concurrency
                                                  #If changed, REST API returns 409
                                                  #Read-only

kubectl scale|label|annotate ...                  #
--resource-version STR                            #If non-empty, will only succeed if this is the current resource-version for the object.
                                                  #Only valid when specifying a single resource.


METADATA.generation                               #NUM. A sequence number representing a specific generation of the desired state.
                                                  #Read-only, set by server.
REPLICATIONCONTROLLER|AUTOSCALER|DEPLOYMENT|
 REPLICASET.status.observedGeneration             #NUM. Most recent generation observed

                                  ┌────────────────────┐
                                  │   AUTHENTICATION   │
                                  └────────────────────┘

http://kubernetes.io/docs/admin/accessing-the-api/
http://kubernetes.io/docs/admin/authentication/
http://kubernetes.io/docs/admin/authorization/
http://kubernetes.io/docs/admin/admission-controllers/


kubectl ...                                       #Sets a user entry in kubeconfig
kubectl config set-credentials NAME ....          #Specifying a name that already exists will merge new fields on top of existing values.
--client-certificate FILE                         #Path to a client certificate file for TLS
--client-key FILE                                 #Path to a client key file for TLS
--username STR                                    #Username for basic authentication to the API server
--password STR                                    #Password for basic authentication to the API server
--token STR                                       #Bearer token for authentication to the API server

kubectl config set-credentials NAME               #Sets a user entry in kubeconfig
                                                  #Specifying a name that already exists will merge new fields on top of existing values.
--auth-provider STR                               #Auth provider for the user entry in kubeconfig
--auth-provider-arg VAR=VAL,...                   #'key=value' arugments for the auth provider
--embed-certs BOOL                                #Embed client cert/key
                                                  #Def: false

kubectl ...                                       #
--as STR                                          #Username to impersonate for the operation


kubelet ...
--read-only-port NUM                              #The read-only port for the Kubelet to serve on with no authentication/authorization (set to 0 to disable) (default 10255)


kube-apiserver
--admission-control STR,...                       #Ordered list of plug-ins to do admission control of resources into cluster.
                                                  #Comma-delimited list of: AlwaysAdmit, AlwaysDeny, AlwaysPullImages, DefaultStorageClass, DenyEscalatingExec, DenyExecOnPrivileged, ImagePolicyWebhook, 
                                                  #InitialResources, LimitPodHardAntiAffinityTopology, LimitRanger, NamespaceAutoProvision, NamespaceExists, NamespaceLifecycle, PersistentVolumeLabel, 
                                                  #PodSecurityPolicy, ResourceQuota, SecurityContextDeny, ServiceAccount. (default "AlwaysAdmit")
--admission-control-config-file PATH              #File with admission control configuration.
--authentication-token-webhook-cache-ttl DUR      #The duration to cache responses from the webhook token authenticator. Default is 2m. (default 2m0s)
--authentication-token-webhook-config-file PATH   #File with webhook configuration for token authentication in kubeconfig format.
                                                  #The API server will query the remote service to determine authentication for bearer tokens.
--authorization-mode STR,...                      #Ordered list of plug-ins to do authorization on secure port.
                                                  #Comma-delimited list of: AlwaysAllow,AlwaysDeny,ABAC,Webhook,RBAC. (default "AlwaysAllow")
--authorization-policy-file PATH                  #File with authorization policy in csv format, used with --authorization-mode=ABAC, on the secure port.
--authorization-rbac-super-user USER              #If specified, a username which avoids RBAC authorization checks and role binding privilege escalation checks, to be used with --authorization-mode=RBAC.
--authorization-webhook-cache-authorized-ttl DUR  #The duration to cache 'authorized' responses from the webhook authorizer. Default is 5m. (default 5m0s)
--authorization-webhook-cache-unauthorized-ttl DUR#The duration to cache 'unauthorized' responses from the webhook authorizer. Default is 30s. (default 30s)
--authorization-webhook-config-file PATH          #File with webhook configuration in kubeconfig format, used with --authorization-mode=Webhook.
                                                  #The API server will query the remote service to determine access on the API server's secure port.
--basic-auth-file PATH                            #If set, the file that will be used to admit requests to the secure port of the API server via http basic authentication.
--experimental-keystone-url URL                   #If passed, activates the keystone authentication plugin.
--oidc-ca-file PATH                               #If set, the OpenID server's certificate will be verified by one of the authorities in the oidc-ca-file, otherwise the host's root CA set will be used.
--oidc-client-id STR                              #The client ID for the OpenID Connect client, must be set if oidc-issuer-url is set.
--oidc-groups-claim STR,...                       #If provided, the name of a custom OpenID Connect claim for specifying user groups.
                                                  #The claim value is expected to be an array of strings.
                                                  #This flag is experimental, please see the authentication documentation for further details.
--oidc-issuer-url URL                             #The URL of the OpenID issuer, only HTTPS scheme will be accepted.
                                                  #If set, it will be used to verify the OIDC JSON Web Token (JWT).
--oidc-username-claim STR,...                     #The OpenID claim to use as the user name. Note that claims other than the default ('sub') is not guaranteed to be unique and immutable.
                                                  #This flag is experimental, please see the authentication documentation for further details. (default "sub")
--token-auth-file PATH                            #If set, the file that will be used to secure the secure port of the API server via token authentication.

                                  ┌─────────────────────┐
                                  │   SERVICE ACCOUNT   │
                                  └─────────────────────┘

http://kubernetes.io/docs/user-guide/service-accounts/
http://kubernetes.io/docs/admin/service-accounts-admin/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/service_accounts.md


POD.spec.serviceAccountName                       #SERVICEACCOUNT_NAME

kubectl create serviceaccount|sa SERVICEACCOUNT   #Create a service account with the specified name


kube-apiserver
--service-account-key-file PATH                   #File containing PEM-encoded x509 RSA private or public key, used to verify ServiceAccount tokens.
                                                  #If unspecified, --tls-private-key-file is used.
--service-account-lookup                          #If true, validate ServiceAccount tokens exist in etcd as part of authentication.

kube-controller-manager ...                       #
--service-account-private-key-file PATH           #Filename containing a PEM-encoded private RSA key used to sign service account tokens.
--root-ca-file PATH                               #If set, this root certificate authority will be included in service account's token secret.
                                                  #This must be a valid PEM-encoded CA bundle.

                                  ┌────────────┐
                                  │   SECRET   │
                                  └────────────┘

http://kubernetes.io/docs/user-guide/secrets.md 
http://kubernetes.io/docs/user-guide/secrets/walkthrough/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/secrets.md


SECRET.data                                       #OBJ. Contains the secret data.
                                                  #Each key must be a valid DNS_SUBDOMAIN or leading dot followed by valid DNS_SUBDOMAIN.
                                                  #The serialized form of the secret data is a base64 encoded string, representing the arbitrary (possibly non-string) data value here.
                                                  #Described in https://tools.ietf.org/html/rfc4648#section-4
SECRET.stringData                                 #OBJ. Allows specifying non-binary secret data in string form.
                                                  #It is provided as a write-only convenience method.
                                                  #All keys and values are merged into the data field on write, overwriting any existing values.
                                                  #It is never output when reading from the API.
SECRET.type                                       #STR. Used to facilitate programmatic handling of secret data.


kubectl create secret docker-registry SECRET      #Create a secret for use with a Docker registry
                                                  #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.
                                                  #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.
--docker-email STR                                #Email for Docker registry
--docker-password STR                             #Password for Docker registry authentication
--docker-server URI                               #Def: 'https://index.docker.io/v1/'
                                                  #Server location for Docker registry
--docker-username STR                             #Username for Docker registry authentication

kubectl create secret generic SECRET              #Create a secret from a local file, directory or 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).
--type STR                                        #The type of secret to create
--from-file FILE|DIR,...                          #Key files can be specified using their file path, in which case a default name will be given to them, or optionally with a name and file path, 
                                                  #in which case the given name will be used.
                                                  #Specifying a directory will iterate each named file in the directory that is a valid configmap key.
--from-literal VAR=VAL,...                        #Specify a key and literal value to insert in configmap (i.e. mykey=somevalue)

kubectl create secret tls SECRET                  #Create a TLS secret
                                                  #The public/private key pair must exist before hand. The public key certificate must be .PEM encoded and match the given private key.
--cert FILE                                       #Path to PEM encoded public key certificate.
--key FILE                                        #Path to private key associated with given certificate.


POD.spec.imagePullSecrets                         #LOCALOBJREF_ARR. Optional list of references to secrets to use for pulling any of the images used by this POD|SERVICEACCOUNT.
SERVICEACCOUNT.imagePullSecrets                   #If specified, these secrets will be passed to individual puller implementations for them to use. 
                                                  #For example, in the case of docker, only DockerConfig type secrets are honored.
                                                  #ImagePullSecrets are distinct from Secrets because Secrets can be mounted in the pod, but ImagePullSecrets are only accessed by the kubelet.
SERVICEACCOUNT.secrets                            #OBJREF_ARR. Secrets is the list of secrets allowed to be used by pods running using this ServiceAccount.


VOLUME.secret                                     #SECRETVOLUMESOURCE. Secret represents a secret that should populate this volume.
SECRETVOLUMESOURCE.secretName                     #SECRET_NAME. Name of the secret to use.
SECRETVOLUMESOURCE.items                          #KEYTOPATH_ARR. If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file 
                                                  #whose name is the key and content is the value.
                                                  #If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present.
                                                  #If a key is specified which is not present in the Secret, the volume setup will error.
                                                  #Paths must be relative and may not contain the .. path or start with ...
SECRETVOLUMESOURCE.defaultMode                    #Like KEYTOPATH.mode

                                  ┌──────────────┐
                                  │   SECURITY   │
                                  └──────────────┘

http://kubernetes.io/docs/user-guide/security-context/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/security_context.md
https://github.com/kubernetes/kubernetes/blob/master/docs/design/selinux.md
http://kubernetes.io/docs/admin/apparmor/


CONTAINER.securityContext                         #SECURITYCONTEXT. Security options the container should run with.
POD.spec.securityContext                          #PODSECURITYCONTEXT. Security options the pod's containers should run with.

SECURITYCONTEXT.readOnlyRootFilesystem            #BOOL (def: false). Whether this container has a read-only root filesystem.

PODSECURITYCONTEXT.supplementalGroups             #GID_NUM_ARR. A list of groups applied to the first process run in each container, in addition to the container's primary GID.
                                                  #If unspecified, no groups will be added to any container.
PODSECURITYCONTEXT.fsGroup                        #GID_NUM. A special supplemental group that applies to all containers in a pod.
                                                  #Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:
                                                  #  1. The owning GID will be the FSGroup 
                                                  #  2. The setgid bit is set (new files created in the volume will be owned by FSGroup)
                                                  #  3. The permission bits are OR'd with rw-rw

SECURITYCONTEXT.capabilities                      #CAPS. The capabilities to add/drop when running containers.
                                                  #Defaults to the default set of capabilities granted by the container runtime.
CAPS.add|drop                                     #STR_ARR. Added|removed capabilities
SECURITYCONTEXT.privileged                        #BOOL (def: false). Run container in privileged mode.
                                                  #Processes in privileged containers are essentially equivalent to root on the host.
kubelet|kube-apiserver ...                        #
--allow-privileged                                #If true, allow containers to request privileged mode. [default=false]

[POD]SECURITYCONTEXT.seLinuxOptions               #SELINUXOPTS. The SELinux context to be applied to the pod|container.
SELINUXOPTS.user|role|type|level                  #STR. SELinux user|role|type|level label that applies to the pod|container.

[POD]SECURITYCONTEXT.runAsUser                    #UID_NUM. The UID to run the entrypoint of the containers process.
                                                  #Defaults to user specified in image metadata if unspecified.
[POD]SECURITYCONTEXT.runAsNonRoot                 #BOOL (def: false). Indicates that the containers must run as a non-root user.
                                                  #If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does.


kubelet ...                                       #
--seccomp-profile-root DIR                        #Directory path for seccomp profiles.
--experimental-allowed-unsafe-sysctls STR,...     #Comma-separated whitelist of unsafe sysctls or unsafe sysctl patterns (ending in *). Use these at your own risk. (default [])
--protect-kernel-defaults                         #Default kubelet behaviour for kernel tuning. If set, kubelet errors if any of kernel tunables is different than kubelet defaults.

                                  ┌───────────┐
                                  │   EVENT   │
                                  └───────────┘

https://github.com/kubernetes/kubernetes/blob/master/docs/design/event_compression.md


GET /watch/RESOURCE[/NAME]                        #Same as GET /RESOURCE[/NAME], except:
                                                  #  - response body is EVENT
                                                  #  - output type:
                                                  #     - cannot be application/yaml
                                                  #     - application/TYPE -> application/TYPE;stream=watch
                                                  #  - not for ComponentStatus
QOBJ(GET|DELETE /RESOURCE).watch                  #Alternative way to do it
                                                  #Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. 
QOBJ(GET|DELETE /RESOURCE).resourceVersion        #When specified with a watch call, shows changes that occur after that particular METADATA.resourceVersion of a resource.
                                                  #Defaults to changes from the beginning of history.

kubectl get ...                                   #
-w
--watch BOOL                                      #After listing/getting the requested object, watch for changes. Def: false
--watch-only BOOL                                 #Watch for changes to the requested object(s), without listing/getting first. Def: false


EVENT.first|lastTimestamp                         #"DATETIM". The time at which the event was first|last recorded.
EVENT.count                                       #NUM. The number of times this event has occurred.
EVENT.type                                        #STR, among "Normal" or "Warning"
EVENT.reason                                      #STR. Short, machine understandable string that gives the reason for the transition into the object's current status.
EVENT.message                                     #STR. A human-readable description of the status of this operation.
EVENT.involvedObject                              #OBJREF. The object that this event is about.
                                                  #Required
EVENT.source                                      #EVENTSOURCE. The component reporting this event.
EVENTSOURCE.component                             #STR. Component from which the event is generated.
EVENTSOURCE.host                                  #STR. Hostname on which the event is generated.


kubectl describe ...                              #
--show-events BOOL                                #If true (def), display events related to the described object.


kubelet ...
--event-burst NUM                                 #Maximum size of a bursty event records, temporarily allows event records to burst to this number, while still not exceeding event-qps. 
                                                  #Only used if --event-qps > 0 (default 10)
--event-qps NUM                                   #If > 0, limit event creations per second to this value. If 0, unlimited. (default 5)
--event-storage-age-limit TYPE=DUR,...            #Max length of time for which to store events (per type). 
                                                  #Value is a comma separated list of key values, where the keys are event types (e.g.: creation, oom) or "default" and the value is a duration. 
                                                  #Default is applied to all non-specified event types (default "default=0")
--event-storage-event-limit TYPE=NUM,...          #Max number of events to store (per type). 
                                                  #Value is a comma separated list of key values, where the keys are event types (e.g.: creation, oom) or "default" and the value is an integer. 
                                                  #Default is applied to all non-specified event types (default "default=0")

kube-apiserver ...                                #
--event-ttl DUR                                   #Amount of time to retain events. Default is 1h. (default 1h0m0s)

                                  ┌─────────────┐
                                  │   LOGGING   │
                                  └─────────────┘

http://kubernetes.io/docs/getting-started-guides/logging/
http://kubernetes.io/docs/getting-started-guides/logging-elasticsearch/


GET /pods/NAME/log                                #Uses QOBJ:
                                                  #  - pretty BOOL (def: false): see above
                                                  #  - container CONTAINER: The container for which to stream logs. Defaults to only container if there is one container in the pod.
                                                  #  - follow BOOL (def: false): Follow the log stream of the pod.
                                                  #  - previous BOOL (def: false): Return previous terminated container logs.
                                                  #  - sinceSeconds DATE_NUM: A relative time in seconds before the current time from which to show logs. 
                                                  #    If this value precedes the time a pod was started, only logs since the pod start will be returned. 
                                                  #    If this value is in the future, no logs will be returned. Only one of sinceSeconds or sinceTime may be specified.
                                                  #  - sinceTime DATE: An RFC3339 timestamp from which to show logs. 
                                                  #    If this value precedes the time a pod was started, only logs since the pod start will be returned. 
                                                  #    If this value is in the future, no logs will be returned. Only one of sinceSeconds or sinceTime may be specified.
                                                  #  - timestamps BOOL: If true (def: false), add an RFC3339 or RFC3339Nano timestamp at the beginning of every line of log output.
                                                  #  - tailLines NUM: If set, the number of lines from the end of the logs to show. 
                                                  #    If not specified, logs are shown from the creation of the container or sinceSeconds or sinceTime
                                                  #  - limitBytes NUM: If set, the number of bytes to read from the server before terminating the log output. 
                                                  #    This may not display a complete final line of logging, and may return slightly more or slightly less than the specified limit.
                                                  #Extra possible output type: text/plain (def)

kubectl log[s] POD                                #Print the logs for a container in a pod.
-c
--container CONTAINER_NAME                        #Def: first pod's container
-f
--follow BOOL                                     #Specify if the logs should be streamed. Def: false
--interactive BOOL                                #If true (def: false), prompt the user for input when required.
--limit-bytes NUM                                 #Maximum bytes of logs to return. Defaults to no limit. Def: 0
-p
--previous BOOL                                   #If true (def: false), print the logs for the previous instance of the container in a pod if it exists.
--since DUR                                       #Only return logs newer than a relative duration like 5s, 2m, or 3h. Defaults to all logs. Only one of since-time / since may be used. Def: 0
--since-time DATE                                 #Only return logs after a specific date (RFC3339). Defaults to all logs. Only one of since-time / since may be used. Def: ''
--tail NUM                                        #Lines of recent log file to display. Defaults to -1, showing all log lines.
--timestamps BOOL                                 #Include timestamps on each line in the log output. Def: false

kubelet|kubectl|minikube ...                      #
--alsologtostderr BOOL                            #Log to standard error as well as files
--log-backtrace-at NUM                            #When logging hits line file:N, emit a stack trace (default :0)
--log-dir DIR                                     #If non-empty, write log files in this directory
--log-flush-frequency DUR                         #Maximum number of seconds between log flushes (default 5s)
--logtostderr BOOL                                #Log to standard error instead of files (default true)
--stderrthreshold NUM                             #Logs at or above this threshold go to stderr (default 2)
--v value                                         #Log level for V logs
--vmodule STR                                     #Comma-separated list of pattern=N settings for file-filtered logging

                                  ┌───────────────┐
                                  │   AUDIT LOG   │
                                  └───────────────┘

kube-apiserver
--audit-log-maxage NUM                            #The maximum number of days to retain old audit log files based on the timestamp encoded in their filename.
--audit-log-maxbackup NUM                         #The maximum number of old audit log files to retain.
--audit-log-maxsize NUM                           #The maximum size in megabytes of the audit log file before it gets rotated. Defaults to 100MB.
--audit-log-path PATH                             #If set, all requests coming to the apiserver will be logged to this file.

                                  ┌────────────────┐
                                  │   MONITORING   │
                                  └────────────────┘

kubectl top POD|NODE_RESC...                      #Display Resource (CPU/Memory/Storage) usage.
                                                  #The top command allows you to see the resource consumption for nodes or pods.
                                                  #Due to the metrics pipeline delay, they may be unavailable for a few minutes since creation (for pods)
--containers BOOL                                 #If present, print usage of containers within a pod. Only for pods.
                                                  #Def: false

kubelet ...                                       #
--application-metrics-count-limit NUM             #Max number of application metrics to store (per container) (default 100)
--enable-custom-metrics                           #Support for gathering custom metrics.


kubelet ...
--volume-stats-agg-period DUR                     #Specifies interval for kubelet to calculate and cache the volume disk usage for all pods and volumes.
                                                  #To disable volume calculations, set to 0.  Default: '1m' (default 1m0s)

                                  ┌───────────────┐
                                  │   DEBUGGING   │
                                  └───────────────┘

kube-apiserver|controller-manager|scheduler ...
--profiling                                       #Enable profiling via web interface host:port/debug/pprof/ (default true)

                                  ┌─────────────┐
                                  │   TESTING   │
                                  └─────────────┘

kubelet ...                                       #
--chaos-chance NUM                                #If > 0.0, introduce random client errors and latency. Intended for testing. [default=0.0]
--containerized                                   #Experimental support for running kubelet in a container.  Intended for testing. [default=false]
--really-crash-for-testing                        #If true, when panics occur crash. Intended for testing.

                                  ┌───────────────────┐
                                  │   DOCUMENTATION   │
                                  └───────────────────┘

kube-apiserver ...                                #
--enable-swagger-ui                               #Enables swagger ui on the apiserver at /swagger-ui

                                  ┌─────────────┐
                                  │   PLUGINS   │
                                  └─────────────┘

http://kubernetes.io/docs/admin/network-plugins/


kubelet|minikube start ...
--network-plugin STR                              #<Warning: alpha feature> The name of the network plugin to be invoked for various events in kubelet/pod lifecycle
kubelet ...
--network-plugin-dir DIR                          #<Warning: alpha feature> The full path of the directory in which to search for network plugins or CNI config
--network-plugin-mtu NUM                          #<Warning: alpha feature> The MTU to be passed to the network plugin, to override the default. Set to 0 to use the default 1460 MTU.

kubelet ...
--cni-bin-dir DIR                                 #<Warning: alpha feature> The full path of the directory in which to search for CNI plugin binaries. Default: /opt/cni/bin
--cni-conf-dir DIR                                #<Warning: alpha feature> The full path of the directory in which to search for CNI config files. Default: /etc/cni/net.d

kubelet ...
--volume-plugin-dir DIR                           #<Warning: alpha feature>
kube-controller-manager ...                       #The full path of the directory in which to search for additional third party volume plugins 
--flex-volume-plugin-dir string                   #Def: "/usr/libexec/kubernetes/kubelet-plugins/volume/exec/"

                                  ┌──────────────────────────┐
                                  │   THIRD PARTY RESOURCE   │
                                  └──────────────────────────┘

http://kubernetes.io/docs/user-guide/thirdpartyresources/
https://github.com/kubernetes/kubernetes/blob/master/docs/design/extending-api.md


THIRDPARTYRESOURCE.description                    #STR (def: false)
THIRDPARTYRESOURCE.versions                       #APIVERSION_ARR
APIVERSION.name                                   #STR. E.g. v1

                                  ┌──────────────────┐
                                  │   EXPERIMENTAL   │
                                  └──────────────────┘

ALPHA ==>                                         #The following is not documented because only in alpha: 
                                                  #  - PetSet (renamed to StatefulSet):
                                                  #     - http://kubernetes.io/docs/user-guide/petset/
                                                  #     - http://kubernetes.io/docs/user-guide/petset/bootstrapping/
                                                  #     - https://rawgit.com/kubernetes/kubernetes/master/docs/api-reference/apps/v1beta1/definitions.html
                                                  #     - https://rawgit.com/kubernetes/kubernetes/master/docs/api-reference/apps/v1beta1/operations.html
                                                  #  - StorageClass: 
                                                  #     - kubernetes.io/docs/api-reference/storage.k8s.io/v1beta1/definitions.html
                                                  #     - kubernetes.io/docs/api-reference/storage.k8s.io/v1beta1/operations.html
                                                  #  - PodSecurityContext
                                                  #     - https://github.com/kubernetes/kubernetes/blob/master/docs/proposals/pod-security-context.md
                                                  #  - ScheduledJob (renamed to CronJob)
                                                  #     - https://github.com/kubernetes/kubernetes/blob/master/docs/proposals/scheduledjob.md
                                                  #     - http://kubernetes.io/docs/user-guide/cron-jobs/
                                                  #     - kubectl run --schedule STR
                                                  #  - TokenReview:
                                                  #     - kubernetes.io/docs/api-reference/authentication.k8s.io/v1beta1/definitions.html
                                                  #     - kubernetes.io/docs/api-reference/authentication.k8s.io/v1beta1/operations.html
                                                  #  - SubjectAccessReview:
                                                  #     - http://kubernetes.io/docs/api-reference/authorization.k8s.io/v1beta1/definitions/
                                                  #     - http://kubernetes.io/docs/api-reference/authorization.k8s.io/v1beta1/operations/
                                                  #     - https://github.com/kubernetes/kubernetes/blob/master/docs/design/enhance-pluggable-policy.md
                                                  #  - CertificateSigningRequest:
                                                  #     - http://kubernetes.io/docs/api-reference/certificates.k8s.io/v1alpha1/definitions/
                                                  #     - http://kubernetes.io/docs/api-reference/certificates.k8s.io/v1alpha1/operations/
                                                  #  - [Cluster]Role[Binding]:
                                                  #     - http://kubernetes.io/docs/admin/authorization/
                                                  #     - http://kubernetes.io/docs/api-reference/rbac.authorization.k8s.io/v1alpha1/definitions/
                                                  #     - http://kubernetes.io/docs/api-reference/rbac.authorization.k8s.io/v1alpha1/operations/
                                                  #  - PodDisruptionBudget:
                                                  #     - http://kubernetes.io/docs/admin/disruptions/
                                                  #     - https://rawgit.com/kubernetes/kubernetes/master/docs/api-reference/policy/v1beta1/definitions.html
                                                  #     - https://rawgit.com/kubernetes/kubernetes/master/docs/api-reference/policy/v1beta1/operations.html
                                                  #Still document them???

kubelet ...
--enable-controller-attach-detach                 #Enables the Attach/Detach controller to manage attachment/detachment of volumes scheduled to this node, 
                                                  #and disables kubelet from executing any attach/detach operations (default true)
--enable-debugging-handlers                       #Enables server endpoints for log collection and local running of containers and commands (default true)
--enable-load-reader BOOL                         #Whether to enable cpu load reader

kubelet ...
--experimental-nvidia-gpus 0|1                    #Number of NVIDIA GPU devices on this node. Only 0 (default) and 1 are currently supported.

kube-proxy|apiserver|controller-manager|scheduler|
kubelet ...
--feature-gates value                             #A set of key=value pairs that describe feature gates for alpha/experimental features. Options are:
                                                  #  - AllAlpha=true|false (ALPHA - default=false)
                                                  #  - AllowExtTrafficLocalEndpoints=true|false (ALPHA - default=false)
                                                  #  - AppArmor=true|false (BETA - default=true)
                                                  #  - DynamicKubeletConfig=true|false (ALPHA - default=false)
                                                  #  - DynamicVolumeProvisioning=true|false (ALPHA - default=true)

                                  ┌──────────────┐
                                  │   MINIKUBE   │
                                  └──────────────┘

VERSION ==>                                       #0.12.2

GOAL ==>                                          #Single-node cluster, for local development
                                                  #Install master components on current machine, and launches a VM for the single-node.
                                                  #Uses "localkube"


minikube ...                                      #
--show-libmachine-logs                            #Whether or not to show logs from libmachine.

minikube addons ...                               #Modify minikube's kubernetes addons
--format GOTMP                                    #OBJ: AddonName STR, AddonStatus STR (def: "- {{.AddonName}}: {{.AddonStatus}}\n")

minikube addons disable|enable ADDON_NAME         #

minikube addons list                              #Lists all available minikube addons as well as there current status (enabled/disabled)

minikube completion SHELL                         #Outputs minikube shell completion for the given shell (bash)

minikube config                                   #Modify minikube config
                                                  #Configurable fields: 
                                                  #  - vm-driver
                                                  #  - v
                                                  #  - cpus
                                                  #  - disk-size
                                                  #  - host-only-cidr
                                                  #  - memory
                                                  #  - show-libmachine-logs
                                                  #  - log_dir
                                                  #  - kubernetes-version
                                                  #  - WantUpdateNotification
                                                  #  - ReminderWaitPeriodInHours
                                                  #  - WantReportError
                                                  #  - WantReportErrorPrompt
                                                  #  - dashboard
                                                  #  - addon-manager
                                                  #  - kube-dns

minikube config get                               #Gets the value of PROPERTY_NAME from the minikube config file

minikube config set                               #Sets an individual value in a minikube config file

minikube config unset                             #Unsets an individual value in a minikube config file

minikube config view                              #Display values currently set in the minikube config file
--format GOTMP                                    #OBJ: ConfigKey STR, ConfigValue OBJ (def: "- {{.ConfigKey}}: {{.ConfigValue}}\n")

minikube dashboard                                #Opens/displays the kubernetes dashboard URL for your local cluster
--url                                             #Display the kubernetes dashboard in the CLI instead of opening it in the default browser

minikube delete                                   #Deletes a local kubernetes cluster.
                                                  #This command deletes the VM, and removes all associated files.

minikube docker-env                               #sets up docker env variables; similar to '$(docker-machine env)'
--no-proxy                                        #Add machine IP to NO_PROXY environment variable
--shell SHELL                                     #Force environment to be configured for a specified shell: [fish, cmd, powershell, tcsh, bash, zsh], default is auto-detect
-u
--unset                                           #Unset variables instead of setting them

minikube get-k8s-versions                         #Gets the list of available kubernetes versions available for minikube.

minikube ip                                       #Retrieve the IP address of the running cluster.

minikube logs                                     #Gets the logs of the running localkube instance, used for debugging minikube, not user code.

minikube service                                  #Gets the kubernetes URL(s) for the specified service in your local cluster
--format GOTMP                                    #Def for each URL: "http://{{.IP}}:{{.Port}}"
--https                                           #Open the service URL with https instead of http
--url                                             #Display the kubernetes service URL in the CLI instead of opening it in the default browser

minikube service list                             #Lists services' URLs

minikube ssh                                      #Log into or run a command on a machine with SSH; similar to 'docker-machine ssh'

minikube start                                    #Starts a local kubernetes cluster.
--extra-config COMPONENT.VAR=VAL                  #CLI flags passed to COMPONENT: apiserver, controller-manager, scheduler, etcd, proxy, kubelet
                                                  #VAR should be titleized
--vm-driver STR                                   #Can be:
                                                  #  - Linux: "virtualbox" (def) or "kvm"
                                                  #  - OSX: xhyve, "virtualbox", "vmware"
                                                  #  - Windows: "hyperv", "virtualbox"
--host-only-cidr CIDR                             #The CIDR to be used for the VM (if --vm-driver "virtualbox") (default "192.168.99.1/24")
--hyperv-virtual-switch STR                       #hyperv virtual switch name (if --vm-driver "hyperv"). Defaults to first found.
--kvm-network STR                                 #The KVM network name (if --vm-driver "kvm"). Def: "default"
--iso-url URL                                     #Location of the minikube VM image

minikube status                                   #Gets the status of a local kubernetes cluster.
--format GOTMP                                    #OBJ: MinikubeStatus STR, LocalkubeStatus STR (def: "minikubeVM: {{.MinikubeStatus}}\nlocalkube: {{.LocalkubeStatus}}\n")

minikube stop                                     #Stops a running local kubernetes cluster.
                                                  #This command stops the VM itself, leaving all files intact.
                                                  #The cluster can be started again with the "start" command.