Please enable JavaScript.

Coggle requires JavaScript to display documents.

Learning (containers) (Running (Docker (Docker-Compose, Docker cli),…

- - - - Minikube
      - Kubernetes Developed
        
        kubeadm
        
        kubectl
        Kubectl book
        
        CLI tool to create and manage Kubernetes.
        Only use 1 management technique.
        
        Imperative commands
        
        Imperative Object Configuration
        
        Declarative Object Configuration
        
        The Kubernetes.io site has excellent trade-off examples between the different management types.
        
        Imperative Commands
        
        Use case Development | Live Objects | 1+ Support Writers
        Operations directly on live objects in a cluster.
        Provide arguments or flags directly to the Kubectl command.
        ie:
        Kubectl run nginx --image nginx
        or
        Kubectl create deployment nginx --image nginx
        
        Imperative Object Configurations
        
        Use case Production | Individual Files | 1 Supported Writers
        Uses kubectl with at least a full definition of the object in YAML or JSON format.
        ie:
        kubectl create -f nginx.yaml
        or
        kubectl replace -f nginx.yaml
        Updating live objects but not the configuration file means files will be lost on next replacement cycle.
        
        Declarative Object Configuration
        
        Use case Production | Directories of files | 1+ Supported Writers
        Most complex scenario.
        Change made to live objects are retained.
        Reads configs/ and automatically decides to create, updates, or delete.
        ie:
        kubectl diff -f configs/
        kubectl apply -f configs/
        
        kubelet
        
        The "node agent" that dns on each node. This registers the node with the apiserver using either the hostname, a flag to override the hostname, or a specific logic fro a cloud provider.
      - Rancher.io
        
        K3s
      - CRI-O
        Container runtime for kubernetes
    - - Replica Sets
        
        Maintain a set number of identical Pods
      - Secrets
        
        Managed through the k8s API or Managed by a Controller
      - Controllers
        
        Creates and manages multiple pods.
        Performs self-healing at the cluster scope.
        Generally use a Pod Template to be responsible for the cluster.
        
        Pods
        
        Each pod is meant to be a single instance of an application.
        All the resources are shared and containers are co-located and co-schedueld inside of pods.
        Typically handled via Controllers.
        
        Smallest deployable object
        
        Represents a process running on your Cluster
        
        Groups containerized components
        
        Basic scheduling unit in K8s
        
        Unique Pod IP address(ephemeral address)
        
        Containers within the pod can communicate on localhost
        
        Must talk to other pods using Services
        
        Defines a volume
        
        ConfigMaps
        
        Volumes
        
        Container data is ephemeral. So, K8s does volume abstraction to solve non-trivial problems.
        
        Networking
        
        Containers within the pod talk via localhost.
        Every container shares the same network namespace and ports.
        To talk outside the pod they need to coordinate network resources.
        
        Containers
        
        Can be a single container
        Or multiple within the Pod.
        Tightly coupled (work together).
        Live within same networking namespace.
        Are co-located within the same instance.
        
        Pod Templates
        
        Pod specifications included in other objects.
        Pod templates are like cookies of the cookie cutter. There is no desired state here.
        Once the cookie has been cut the pods created exist on their own. There is no call back if the template cookie cutter is changed.
        
        Replication Controllers
        
        Surpassed by ReplicaSet and more importantly Deployment which uses ReplicaSet
        As the name implies, this makes sure that "a pod or homogenous set of pods is always up and available."
        Primitive type meant to be keep certain pods replicated by other automated means changing is config.
        Identifies its items by labels.
        Abbreviations are "rc" or "res"
        Too few pods more are created. Too many and they're deleted or destroyed.
        You can delete a replication controller without deleting the pods.
        ie
        kubectl delete --cascade=false
        You can delete a controller and all the pods its pods
        kubectl delete
        
        Write the Spec
        
        Needs:
        
        apiVersion
        
        kind
        
        metadata
        
        Jobs
        
        Jobs "run to completion" .
        A job creates one or more Pods, then it ensures the same number terminates.
        
        DaemonSets
        
        Deployments
        
        Provides declarative updates to Pods and ReplicaSets.
        Describe a desired state and the Deployment Controller manages the actual state at a controlled rate.
        Common Use Cases:
        
        Deploy a ReplicaSet
        
        the ReplicaSet creates Pods
        
        Declare new state of Pods
        
        update the PodTemplateSpec of the deployment.
        
        a new ReplicaSet is created and deployment manages the Pods from old to new.
        
        Rollback to earlier Deployment
        
        if the current deployment is not stable
        
        Scale up the Deployment
        
        Pause the Deployment
        
        pause to fix the PodTemplateSpec, then resume
        
        Use status of Deployment to identify a stuck rollout.
        
        Clean up older ReplicaSets
- - - - File System
        Filesystem Bundle
        How a container and it's config data are stored on a local filesystem.
        Contains the following:
        
        config.json
        
        REQUIRED FILE must reside in the root of the bundle dir
        
        MUST be name config.json
        
        containers root filesystem: the directory reference by root.path if in config.json
        
        Config.json file
        Config.json
        Includes:
        
        process to run
        
        environment vars
        
        sandbox ing
        -etc
        
        Referrence is on the page of a complete config.json
        This is config is the "inspect" command on pod man or docker cli.
        
        Machine type Specific for Configurations
        
        Types:
        
        Linux
        
        Solaris
        
        Windows
        
        Virtual Machines
      - Runtime and Lifecycle
        Runtime and lifecycle
        A runtime must use the following operations specified to create a container.
        |
        The following properties must be part of the state:
        
        ociVersion (required)
        
        id (required)
        
        status (required)
        
        creating
        
        created
        
        running
        
        stopped
        
        more MAY be defined but not be the above
        
        pid (required)
        
        bundle (required)
        
        annotations (optional)
        
        key:value
        
        |
        Lifeycle
        The container lifecycle is a simple 10 point process outlined on the page. The gist is below:
        
        create command
        
        MUST use config.json file
        
        start command
        
        pre-start hooks
        
        MUST run user-specified program process
        
        post-start hooks
        
        container process exits for a reason
        
        delete command
        
        MUST destroy reversing steps in point 2
        
        Post-Stop hooks
        
        |
        Operations that MUST be supported
        
        Query State
        
        state <container-id>
        
        Create
        
        create <container-id> <path-to-bundle>
        
        Start
        
        start <container-id>
        
        Kill
        
        kill <container-id> <signal>
        
        Delete
        
        delete <container-id>
        
        Hooks
        
        actions that happen pre or post of the above operations
    - - Image Manifest Spec
        Image Manifest
        Provides a configuration and set of layers for a single container image for a specific architecture and operating system.
        Set of properties:
        
        schemaVersion
        
        mediaType
        
        config
        
        mediaType
        
        layers
        
        mediaType
        
        annotations
      - Image Index Spec
        OCI Image index specification
        Defines the application/vnd.oci.image.index.v1+json media type.
        Link contains example json.
        Set of properties:
        
        schemaVersion
        
        mediaType
        
        manifests
        
        mediaType
        
        platform
        
        architecture
        
        os
        
        os.version
        
        os.features
        
        variant
        
        annotations