Please enable JavaScript.

Coggle requires JavaScript to display documents.

NET Microservices for Containerized NET Applications (305 Key Takeways…

- - - - https://github.com/dotnet-architecture/eShopOnContainers
- - - - A package with all the dependencies and information needed to create a container.
        An image includes all the dependencies (such as frameworks) plus deployment and execution
        configuration to be used by a container runtime. Usually, an image derives from multiple base images
        that are layers stacked on top of each other to form the container’s filesystem. An image is immutable
        once it has been created.
    - - An instance of a Docker image. A container represents the execution of a single
        application, process, or service. It consists of the contents of a Docker image, an execution
        environment, and a standard set of instructions. When scaling a service, you create multiple instances
        of a container from the same image. Or a batch job can create multiple containers from the same
        image, passing different parameters to each instance.
    - - A mark or label you can apply to images so that different images or versions of the same image
        (depending on the version number or the target environment) can be identified.
    - - An instance of a Docker image. A container represents the execution of a single
        application, process, or service. It consists of the contents of a Docker image, an execution
        environment, and a standard set of instructions. When scaling a service, you create multiple instances
        of a container from the same image. Or a batch job can create multiple containers from the same
        image, passing different parameters to each instance.
    - - The action of building a container image based on the information and context provided by its
        Dockerfile, plus additional files in the folder where the image is built. You can build images with the
        Docker docker build command.
    - - A collection of related Docker images, labeled with a tag that indicates the image
        version. Some repos contain multiple variants of a specific image, such as an image containing SDKs
        (heavier), an image containing only runtimes (lighter), etc. Those variants can be marked with tags. A
        single repo can contain platform variants, such as a Linux image and a Windows image.
    - - A service that provides access to repositories. The default registry for most public images is
        Docker Hub (owned by Docker as an organization). A registry usually contains repositories from
        multiple teams. Companies often have private registries to store and manage images they’ve created.
        Azure Container Registry is another example.
    - - A public registry to upload images and work with them. Docker Hub provides Docker
        image hosting, public or private registries, build triggers and web hooks, and integration with GitHub
        and Bitbucket.
    - - A public resource for working with Docker images and its components in
        Azure. This provides a registry that is close to your deployments in Azure and that gives you control
        over access, making it possible to use your Azure Active Directory groups and permissions.
    - - Docker registry service (from Docker) that can be installed onpremises so it lives within the organization’s datacenter and network. It is convenient for private
        images that should be managed within the enterprise. Docker Trusted Registry is included as part of
        the Docker Datacenter product. For more information, see Docker Trusted Registry (DTR).
    - - Development tools for Windows and macOS for building, running,
        and testing containers locally. Docker CE for Windows provides development environments for both
        Linux and Windows Containers. The Linux Docker host on Windows is based on a Hyper-V virtual
        machine. The host for Windows Containers is directly based on Windows. Docker CE for Mac is based
        on the Apple Hypervisor framework and the xhyve hypervisor, which provides a Linux Docker host
        virtual machine on Mac OS X. Docker CE for Windows and for Mac replaces Docker Toolbox, which
        was based on Oracle VirtualBox.
    - - A command-line tool and YAML file format with metadata for defining and running multicontainer applications. You define a single application based on multiple images with one or more
        .yml files that can override values depending on the environment. After you have created the
        definitions, you can deploy the whole multi-container application with a single command (dockercompose up) that creates a container per image on the Docker host
    - - A collection of Docker hosts exposed as if it were a single virtual Docker host, so that the
        application can scale to multiple instances of the services spread across multiple hosts within the
        cluster. Docker clusters can be created with Docker Swarm, Mesosphere DC/OS, Kubernetes, and
        Azure Service Fabric. (If you use Docker Swarm for managing a cluster, you typically refer to the
        cluster as a swarm instead of a cluster.)
    - - A tool that simplifies management of clusters and Docker hosts. Orchestrators enable
        you to manage their images, containers, and hosts through a command line interface (CLI) or a
        graphical UI. You can manage container networking, configurations, load balancing, service discovery,
        high availability, Docker host configuration, and more. An orchestrator is responsible for running,
        distributing, scaling, and healing workloads across a collection of nodes. Typically, orchestrator
        products are the same products that provide cluster infrastructure, like Mesosphere DC/OS,
        Kubernetes, Docker Swarm, and Azure Service Fabric
- - - - Data volumes that mount to the host
        
        https://docs.docker.com/engine/admin/volumes/volumes/#start-a-container-with-a-volume
        
        Data volumes are directories mapped from the host OS to directories in containers. When code in the
        container has access to the directory, that access is actually to a directory on the host OS. This
        directory is not tied to the lifetime of the container itself, and the directory can be accessed from code
        running directly on the host OS or by another container that maps the same host directory to itself.
        Thus, data volumes are designed to persist data independently of the life of the container. If you delete a container or an image from the Docker host, the data persisted in the data volume is not
        deleted. The data in a volume can be accessed from the host OS as well.
      - Data volume containers that provide shared storage across containers using an external
        container
        
        Data volume containers are an evolution of regular data volumes. A data volume container is a
        simple container that has one or more data volumes within it. The data volume container provides
        access to containers from a central mount point. This method of data access is convenient because it
        abstracts the location of the original data. Other than that, its behavior is similar to that of a regular
        data volume, so data is persisted in this dedicated container independently of the lifecycle of the
        application’s containers.
        
        when Docker containers are managed by an orchestrator, containers might “move”
        between hosts, depending on the optimizations performed by the cluster. Therefore, it is not
        recommended that you use data volumes for business data. But they are a good mechanism to work
        with trace files, temporal files, or similar that will not impact business data consistency
      - Volume plugins that mount volumes to remote services, providing long-term persistence.
        
        Volume plugins like Flocker provide data access across all hosts in a cluster. While not all volume
        plugins are created equally, volume plugins typically provide externalized persistent reliable storage
        from immutable containers.
      - Azure Storage, which provides geo-distributable storage, providing a good long-term
        persistence solution for containers
        
        Azure Storage. Business data usually will need to be placed in external resources or databases, like
        Azure Storage. Azure Storage, in concrete, provides the following services in the cloud:
        
        Blob storage stores unstructured object data. A blob can be any type of text or binary data,
        such as document or media files (images, audio, and video files). Blob storage is also referred
        to as Object storage.
        • File storage offers shared storage for legacy applications using standard SMB protocol. Azure
        virtual machines and cloud services can share file data across application components via
        mounted shares. On-premises applications can access file data in a share via the File service
        REST API.
        • Table storage stores structured datasets. Table storage is a NoSQL key-attribute data store,
        which allows rapid development and fast access to large quantities of data.
      - Remote relational databases like Azure SQL Database or NoSQL databases like Azure Cosmos
        DB, or cache services like Redis
        
        Remote data sources and cache tools like Azure SQL Database, Azure Cosmos DB, or a remote cache
        like Redis can be used in containerized applications the same way they are used when developing
        without containers. This is a proven way to store business application data
  - - - Big central brokers
      - central orchestrators at the organization level
      - Enterprise service bus
  - - - Monitoring and health checks of the services and infrastructure.
      - Scalable infrastructure for the services (that is, cloud and orchestrators)
      - Security design and implementation at multiple levels: authentication, authorization, secrets
        management, secure communication, etc
      - Rapid application delivery, usually with different teams focusing on different microservices.
      - DevOps and CI/CD practices and infrastructure.
    - - not every microservice must be self-hosted
    - - p. 39 Challeng no. 1: How to define the boundaries of each microservice
      - p. 39 Challenge no. 2 How to create queries that retrieve data from several microservices
      - p. 41 Challenge no. 3 How to achieve consistency across multiple microservices
      - p. 42 Challenge no. 4 How to design communication across microservice boundaries
        
        Minimize chains of request
        
        only use asynchronous interaction
    - - Microsoft.Diagnostic.Flow
      - Application Insights
        
        https://azure.microsoft.com/en-us/services/application-insights/
      - OMS
        
        https://github.com/Azure/diagnostics-eventflow#oms-operations-management-suite
      - Azure Diagnostics
        
        https://docs.microsoft.com/en-us/azure/monitoring-and-diagnostics/azure-diagnostics
      - Splunk
        
        https://www.splunk.com/goto/Splunk_Log_Management?ac=ga_usa_log_analysis_phrase_Mar17&_kk=logs%20analysis&gclid=CNzkzIrex9MCFYGHfgodW5YOtA