/docs/MyDocs

 - General

    apiVersion: v1                                              - version (object dependent)

    kind: <object-type>                                         - Type of object

    metadata: { name: '', ... }                                 - Names, labels, etc.

    spec: { ... }                                               - Configuration

 

 - DC/POD resources

    kind: DeploymentConfig                                      - Schedules some kind of service (permanently running pod)

    spec:

      replicas: #                                               - How many replicas we should run

      selector: { label1: value1 }                              - ?

      template: { ...pod specification... }                     - see bellow, but 'kind' and 'apiVersion' is not included inside

 

    kind: DaemonSet                                             - Allows to execute a POD service on all (or some) nodes in the cluster.

    apiVersion: extensions/v1beta1                              - This feature is still in beta

    spec:

      selector.matchLabels: { lab1: val1 }                      - Selects pods to run

      template: { ... pod specification ... }                   - Should include corresponding labels in the 'metadata/labels' dictionary.

                                                                The 'nodeSelector' (if specified) limits nodes on which the Daemonset will be running.

 

    kind: Job                                                   - Run the pod (or multiple replicas of the pod) until completion and finishes.

    spec:

      parallelism: #                                            - Specyfying how many times the pod should be schedulled and successfuly completed to finish the job.

                                                                It executs just the replicas of the same pod. Defaults to value of 'completions' parameter.

      completions: #                                            - This inidcates how many replicas should run in parallel. Defaults to 1.

      activeDeadlineSeconds: #                                  - The job will be killed if not completed after specified number of seconds (counted after schedulling of the first pod replica)

      template: { ... pod specification ... }                   - The 'restartPolicy' should be set to Never in the containers.

 

    kind: ScheduledJob                                          - Pereodically schedules the jobs

    spec:

      schedule: */1 * * * ?                                     - cron format

      jobTemplate: { spec: ... }                                - Job specifciation as described above

      

    kind: Pod

      serviceAccount: default                                   - Specifies SA to run the pod ('default' is used by default)

      nodeSelector: {label1: value1, label2: value2}            - the pods will be executed on the nodes with specified labels only

      terminationGracePeriodSeconds: #                          - Time between scheduller sends SIGTERM and SIGKILL signals to pods to allow graceful shutdown 

      strategy:

        type: Recreate/Rolling/Custom                           - With 'Recreate' strategy, the pod is first destroyed and, then, recreated. The 'Rolling' first creates the new pod.

        resources.limits: { cpu: "1m", memory: "1Mi" }          - Restrict resources per pod. The pod will be recreated if the limit is reached

        resources.requests: { cpu: "", memory: "" }             - ? Request to allocate the specified resources?

      spec:

        serviceAccountName: "<sa_name>"                         - specifies which service account should be used to run the pods

        restartPolicy: Always/Never                             - defines what should happend if container terminates (whatever successfully or not). It is restarted by default (Always).

        dnsPolicy: ClusterFirst/?                               - defines which DNS service has prirotiy

        volumes: [{                                             - defines list of volumes for pod which can be referenced from the specific containers by the name.

          name:                                                 - volume name, just will be refered by volumeMounts in the 'containers' definition

          <type>: { ...params...                                - Allows to mount OpenShift PVC/PV, Secrets/ConfigMaps, arbitrary path on the node running pod, and various network resources

            -> persistentVolumeClaim {claimName}                -> claimName specifies PVC referred by name. A single PVC can be connected multiple times.

            -> configMap { name, items: [{key, path}] }         -> Mount ConfigMap. Each key will be represented as individual file. By default the directory structure is plain and all files are in 

                                                                the same directory. With 'items' it is possible to structure the directories. E.g. if configMap is mounted under '/etc/apache2' with

                                                                'items: [{key: katrin.conf, path: vhosts.d}]', the katrin.conf will be available under /etc/apache2/vhosts.d/katrin.conf 

            -> secret { secretName }                            -> Mount secrets (again each key is represented as file)

            -> hostPath: { path }                               -> Mount path on the node running the pod

            -> glusterfs: {endpoints, name, readOnly}           -> Parameters are specifying 'ep' (which refers the members of GlusterFS cluster) and GlusterFS volume name (name) to mount

            -> nfs: {server, path, readOnly}                    -> 

 

 

          types are: persistentVolumeClaim, glusterfs, nfs, hostPath, ... Then type-specific parameters are set.

        containers: [{

          name:

          command: ["cmd", "param1", "param2", ... ]            - replaces default command to run in the container

          image: centos/httpd-24-centos7:latest

          imagePullPolicy: Always/Never/IfNotPresent            - specifies if the newer images should be automatically pulled (yes / does not pull images automatically / only pulls once, no updates)

          ports: [{ containerPort }]                            - specifies ports used by container

          volumeMounts: [{ name, subPath, mountPath }]          - refers volumes (by name) and optionally may specify subpath within volume to be mounted. 

                                                                The same volume could be could be connected multiple times to different places (and with different subPath's)

          env: [ { name,                                        - Configures environment variables

            value                                               - Just sets the value directly or from template parameters referring them by '${PARAM}'

            valueFrom: {                                        - or alternatively the location where to get value is specified

              <type>: { ... parameters ... }

                -> configMapKeyRef: { name, key }               - Gets the value from the specified key of the specified configMap

                -> secretKeyRef: { name, key}                   - Or from the secret

          

          livenessProbe: {<probe_spec> ...                      - probe to run to check if the pod is still alive (and kill it if not). Further restart is the subjected to its 'restart' policy.

          readynessProbe: {<probe_spec> ...                     - If the readiness probe fails a container, the endpoints controller ensures the container has its IP address (temporarily?) removed from the 

                                                                endpoints of all services.

            initialDelaySeconds: #                              - How long to wait after the container starts to begin the probe.

            timeoutSeconds: #                                   - How long to wait for the probe to finish before considering it failed (default: 1)

            <probe_type>: { ... parameters ...                  - probe types: 

                -> command: {[cmd, arg1, arg2]}                 -> Executed within container 

                -> tcpSocket: {port}

                -> httpGet: {port, path}

 

 - PV/PVC

    kind: PersistentVolume

    spec:

      capcity.storage: 1Gi                                      - The space available (manadatory option)

      <type>: { ... type-specific parameters ... }              - Specifies volume type (nfs, ...) and parameters specific to this type

      persistentVolumeReclaimPolicy: Retain/Recycle/Delete      - Retain instructs OpenShift to preserve PV after PVC binded to it is destroyed 

      accessModes: [ReadOnlyMany/ReadWriteMany/ReadWriteOnce]   - Is only used for matching by corresponding PVC definition  (mandatory option)

      claimRef: { namespace, name }                             - Only allow to the specified PVC to bind

 

    kind: PersistentVolumeClaim                                 - The PVC is binded to the volume selected based on the specified requirements. Only a sinlge PVC could be mapped to PV, but PVC can be

                                                                referred as many times as required in the pod specifications.

    spec:

      accessModes: [ ReadWriteMany, ... ]                       - Actually list of arbitrary lables which will be matched at corresponding PV definition (mandatory option) 

      resources.requests.storage: 1Gi                           - The space requested on the storage, this information is used to match proper pvc (mandatory option)

      volumeName: <name>                                        - Requires exactly specific volume

 

 

 - Routes

    kind: Route

    spec:

      host: <FQDN>                                              - Specifies the name to be exposed, like katrin.kit.edu (should not necessarily be from OpenShift subdomain, but FQDN is mandatory!)

      wildcardPolicy: Subdomain                                 - Instructs OpenShift that all subdomains of 'host' should be forwarded to the service as well

      path: "/adei"                                             - Defines service for the specified subpath only (optional)

      to: { kind: Service, name: <svc_name> }                   - Specifies the service to link

      port:

        targetPort: http                                        - Should be exposed if SVC defines multiple ports (otherwise all ports will be served in round-robin fashion), name or number may be used

      tls:                                                      - By default, service is only registered on port 80. This enables also encrypted HTTPS service on port 443 in parallel or instead of http.

        termination: passthrough/edge/reencrypt                 - Selects operation mode. In edge mode, the router decrypts data from client and forwards unencrypted data to simple http service,

                                                                in 'reencrypt' mode it does the same, but re-encrypts before sending to internal https service. See more details in network.txt.

        insecureEdgeTerminationPolicy: Allow/Redirect           - The service is only served on HTTPS port unless this option is specified. 'Allow' enables both HTTP/HTTPS in parallel and 'Redirect'

                                                                just redirects HTTP requests to HTTPS.

        certificate: |-                                         - Configures X509 certificate for the service (optional, OpenShift certificate will be used if not specifierd)

          -----BEGIN CERTIFICATE-----

          -----END CERTIFICATE-----

        caCertificate: |-                                       - Configures CA X509 certificate (optional)

        key: |-                                                 - Configures private key for the service (optional, OpenShift key will be used if not specifierd)

        destinationCaCertificate: |-                            - For communication with internal OpenShift nodes