Kubernetes

      K8S_SERVER="https://k8s_example.com"
      K8S_CONTEXT_USER="username"
      NAMESPACE="xxx"
      SERVICE_TOKEN=""
      CLUSTER="xxx"

      echo "$K8S_CA_CRT" > ca.crt
      kubectl config set-cluster $CLUSTER --server=$K8S_SERVER --certificate-authority=ca.crt

      kubectl config set-credentials $K8S_CONTEXT_USER --certificate-authority=ca.crt --token=$SERVICE_TOKEN

      kubectl config set-context dev-context --cluster=$CLUSTER --user=$K8S_CONTEXT_USER --namespace=$NAMESPACE

      kubectl config use-context dev-context

      # Create manually
          echo -n 'admin' | base64
          echo -n 'pwd' | base64
          echo 'MWYyZDFlMmU2N2Rm' | base64 --decode

      # write object in secret.yaml
      cat > secret.yaml <<EOF
      apiVersion: v1
      kind: Secret
      metadata:
        name: mysecret
      type: Opaque
      data:
        username: YWRtaW4=
        password: MWYyZDFlMxxxxN2Rm
      EOF
      kubectl apply -f ./secret.yaml

      # create from file
      # Create files needed for rest of example.
      echo -n 'admin' > ./username.txt
      echo -n '1f2d1xxxe67df' > ./password.txt
      kubectl create secret generic basic-secret --from-file=./username.txt --from-file=./password.txt

    ##  Expose secret as Env variable
    env:
      - name: SECRET_USERNAME
        valueFrom:
          secretKeyRef:
            name: basic-secret
            key: username

    echo $SECRET_USERNAME ## test inside a container

    ## Use secret as file from a pod

    containers:
      - image: nginx:latest
        name: nginx
        volumeMounts:
        - name: mounted-basic-secret
          mountPath: "/opt/nginx/"
          readOnly: true
    volumes:
    - name: basic-secret
      secret:
        secretName: basic-auth
        # defaultMode: 256  # ~= 0400
        volumes:
        - name: mounted-basic-secret
          secret:
            secretName: basic-secret  # username & password files will be mounted
            # to mount only specif key as file, use items
            # items:
            #  - key: username # only username  will be mounted as username.txt
            #    path: username.txt

    kubectl create secret docker-registry registry-secret --docker-username="isda" \
    --docker-password="nexusisda" --docker-server="registry.example.com" --namespace dev

    kubectl get secret registry-secret -o yaml --namespace dev

    ## Add in your manifest - in container block
      imagePullSecrets:
        - name: registry-secret

    kubectl create secret tls mon_certif-tls --key my_certificate.key --cert my_certificate.cer -n mon_namespace

    # To add in Ingress
      hosts: app.ingress.com
    tls:
    - secretName: chart-example-tls
      hosts:
          - kibana.my_app.caas-cnp-apps.com.intraorange

    htpasswd -c auth foo
    New password: <bar>
    New password:
    Re-type new password:
    Adding password for user foo

    kubectl create secret generic basic-auth --from-file=auth
    secret "basic-auth" created

    kubectl get secret basic-auth -o yaml
    apiVersion: v1
    data:
      auth: Zm9vOiRhcHIxJE9GRzNYeWJwJGNrTDBGSERBa29YWUlsSDkuY3lzVDAK
    kind: Secret
    metadata:
      name: basic-auth
      namespace: default
    type: Opaque

    apiVersion: extensions/v1beta1
    kind: Ingress
    metadata:
      name: ingress-with-auth
      annotations:
        # type of authentication
        nginx.ingress.kubernetes.io/auth-type: basic
        # name of the secret that contains the user/password definitions
        nginx.ingress.kubernetes.io/auth-secret: basic-auth
        # message to display with an appropriate context why the authentication is required
        nginx.ingress.kubernetes.io/auth-realm: 'Authentication Required - foo'
    spec:

      kubectl create configmap <map-name> <data-source>
      kubectl create configmap myconf --from-file=/path/to/

      containers:
        - name: test
          image: busybox
          volumeMounts:
            - name: config-vol
              mountPath: /etc/config
      volumes:
        - name: config-vol
          configMap:
            name: log-config
            items:
              - key: log_level
                path: log_level

      volumeMounts:
          - name: config-vol
            mountPath: /etc/config/test.cfg
            subPath: test.cfg

      volumes:
      - name: cache-volume
        emptyDir: {}

      volumes:
        - name: test-volume
          hostPath:
            # directory location on host
            path: /data
            # this field is optional
            type: Directory

      apiVersion: v1
      kind: PersistentVolume
      metadata:
        name: example-pv
      spec:
        capacity:
          storage: 100Gi
        # volumeMode field requires BlockVolume Alpha feature gate to be enabled.
        volumeMode: Filesystem
        accessModes:
        - ReadWriteOnce
        persistentVolumeReclaimPolicy: Delete
        storageClassName: local-storage
        local:
          path: /mnt/disks/ssd1
        nodeAffinity:
          required:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/hostname
                operator: In
                values:
                - example-node

      #  to manage persistent volumes: local, cloud blocks

        apiVersion: v1
        kind: PersistentVolumeClaim
        metadata:
          name: wp-pv-claim
          labels:
            app: wordpress
        spec:
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 5Gi

      # A projected volume maps several existing volume sources(secret, configMap) into the same dir

      volumes:
      - name: all-in-one
        projected:
          sources:
          - secret:
              name: mysecret
              items:
                - key: username
                  path: my-group/my-username
          - configMap:
              name: myconfigmap
              items:
                - key: config
                  path: my-group/my-config