Please enable JavaScript.

Coggle requires JavaScript to display documents.

Containerization (Orchestrator Tools (Kubernetes (Software (Pods (One or…

- - - - Node
        
        Single machine in your cluster, can be physical or virtual
        
        Each node has a set of CPU and RAM resources that can be used
        
        Smallest unit of computing hardware
        
        kubelet - application that runs on the node and comunicates with the master kubernetes node
        
        Runs a pod
      - Cluster
        
        Group of nodes that pool together their resources to form a more "powerful machine"
      - Persistent Volumes
        
        Since programs running on a cluster aren't guaranteed to run on a specific node, data can't be saved locally.
        
        Local or cloud drives can be attached to cluster as persistent volume. This volumes are not associated with any particular node.
    - - Containers
        
        Programs packaged as linux containers
        
        Ability to create self-contained Linux execution environments with any program and all its dependencies
        
        Should limit one process per container, if possible
        
        Better to have many small containers than one large one
        
        More easy to deploy and issues are easier to diagnose
      - Pods
        
        One or more containers
        
        Share the same resources and local network
        
        Containers can easily communicate with other containers in the same pod as though they were on the same machine while maintaining a degree of isolation from others
        
        Unit of replication
        
        Should remain as small as possible, typically holding only a main process and its tightly-coupled helper containers (usually mentioned as side-cars)
      - Deployments
        
        Primary purpose is to declare how many replicas of a pod should be running at a time.
        
        When a deployment is added to the cluster, it will automatically spin up the requested number of pods and then monitor them.
        
        No need to deal with pods manually, just declare the desired state of the system and will be managed for you automatically
        
        We can have specific strategies, like canary deployments
        
        Execute multiple deployments.yaml with different docker images, and use a loadbalancer as a service.
      - Ingress
        
        Kubernetes provides isolation between pods by default
        
        Ingress is a channel for communication with outside world
        
        "Ingress controller" or a "loadbalancer"
      - Service
        
        Is an abstraction which defines a logical set of Pods and a policy by which to access them
        
        Handles requests
        
        Can be think as load balancers for pods: services provide an IP address that consumers can use and will balance the requests among the pods that are under it
      - Labels & Selectors
        
        Labels are key/value pairs that you can define as you want since they're used to identify objects
        
        Selector is needed to select objects using one or more labels
    - - istio
    - - Amazon Elastic Container Service for Kubernetes (EKS)
        
        Runs the Kubernetes management infrastructure across multiple AWS availability zones. Is certified Kubernetes conformant.
      - Google Container Engine (GKE)
        
        Is a management and orchestration system for Docker container and container clusters that run within Google's public cloud services. Google Container Engine is based on Kubernetes, Google's open source container management system.
      - Azure Kubernetes Service (AKS)
        
        Fully managed Kubernetes container orchestration service
    - - Is a open-source system for automating deployment, scaling and management of containerized applications
        
        Since it's open-source, allows you to create your own building blocks to enhance what’s already on the platform.
      - Takes a declare state of what/how you want your microservices and makes it happen across different machines (pool of resources)
    - - Failure strategy
        
        You can keep a few old deployment controllers active with zero pods for each environment
        
        You can automatically resize the controllers back again, when you need to rollback
        
        Also has rollout history and undo functions to rollback to a previous deployment manually
    - - Reducing the Time of Release Cycles
        
        A manual CI/CD process leads to more code-merge collisions, as well as the time that customers have to wait for patches and updates.
      - Solving Outages
        
        A manual infrastructure management process causes headaches for coding teams because someone has to remain alert in case any outages happen. If your app is down, with an automated platform such as Kubernetes, you can automate patches and updates to solve these outages.
      - Server Usage Efficiency
        
        If your apps are not packed efficiently onto servers, you may be overpaying for capacity. Kubernetes maximizes the efficiency of your server usage to ensure you’re not overdoing it or under doing it.
      - Ability to Containerize the Code
        
        You can run your apps in containers and this ensures they have the resources and libraries necessary, while also preventing common issues that arise between library versions and application components. Containerizing the code makes your app portable between environments, while also making them easy to replicate and scale.
      - Orchestrate Deployment with the Platform
        
        Deployment easier in many different ways
        
        Running apps on containers doesn’t solve every problem in the CI/CD pipeline as you still need to manage these apps.
        
        The platform can do everything from deploying them to monitoring their health and scaling them to meet customer demand.
- - - - Pull
      - Run
      - Build
      - Push
    - - Build -> DockerFile -> Docker Image
      - Run -> Docker Image -> Container
    - - When a destroy a new container, all data is lost by default
      - Concept of "volumes" to persists data for different containers
    - - Manipulate and manage different instances of docker host
    - - Used by docker, kubernetes CRI and others
      - Everything that you need to build a container platform without having to deal with the underlying OS details
      - It was designed to be used by container platforms that want to abstract away syscalls or OS specific functionality to run containers in any OS.
    - - Open platform for developers and sysadmins to build, ship and run distributed applications, whether on laptops, data center VMs or the cloud. No more "works on my machine" :smiley:
    - - List of instructions
      - Describes the build process for an image
      - Manifesto
      - Can be run to automatically create an image
      - Contains all the commands necessary to build the image and run your application
    - - +300% Faster Time to Market
        
        Better development and operational agility
      - +1300% Developer Productivity
        
        Reduce frequency on setup development environments, managing dependencies. Ship new code faster and easier
      - +60% Deployment Velocity
        
        Accelerate deployments and frequency
      - -40% IT Infrasctructure Reduction
        
        Better utilization of servers and reduce of licenses
      - +40% IT Operational Efficiency
        
        Streamline and automate management of infrastructure
      - +72% Faster Issue Resolution
        
        Easily roll-back and deploy fixes
  - - - Docker is focused on being universal container for applications
      - Docker is best compared to an onion, where all internal layers are read-only and only the last layer is writeable
      - Docker allows easy prototyping as well as reusability of the work made by others with adding your own changes on top if desired
      - Docker doesn't allow easily to an administrator remotely log into the container and just add some monitoring, backup, etc.
      - LXD is building on top of a container technology called LXC (used by docker before)
      - LXD allows you to have access to a virtual server like a hypervisor, but without the operating systems being duplicated
      - LXD has an Apache license and is available on github
      - Docker is light-weight, simplistic and is well-suited for isolating applications from each other.
    - - Hypervisor make sure Windows runs on top of an Ubuntu host (linux containers can not support windows on top)
      - Docker containers host the next generation scale out solution
      - LXD will be best for all your standard linux workloads that you just want to move as is, without the need to update the applications or the tools that get integrated into them
- - - - Scalable Microservices with Kubernetes
    - - Fundamentals of Containers, Kubernetes, and Red Hat OpenShift
    - - https://digitaldefynd.com/best-kubernetes-tutorial-training-course/
- - - - Python
      - Approach: Declarative and imperative
      - Method: Push
    - - Ruby
      - Approach: declarative
      - Method: Pull
    - - Go
      - Approach: declarative
      - Method: Push
    - - Ruby
      - Approach: Declarative and imperative
      - Method: Pull
- - - - Language independent
      - Iterate at will/devops pipeline
      - Less risk in change
      - Independent scaling
      - Small teams
    - - Complex networking
      - Overhead
        
        Knowledge in terms of architecture, containerization, orchestrations, etc.
        
        Dynamically manage databases, servers, containers, etc.
  - - - Highly dependent
      - Language / Framework
      - Growth
      - Hero Deployment
      - Scaling