Please enable JavaScript.

Coggle requires JavaScript to display documents.

fit5225 Cloud, docker engine #, A Computer Network: Is…

- - - - Symmetric Multi-processors (SMP)
        
        All global resources are shared among processors
        
        Nodes run the same OS
      - Non-Uniform Memory Access (NUMA)
        
        Each processor has a global view of the available memory
      - Clusters
        
        Collection of workstations interconnected by a high-speed network, with nodes running a single
        system image
      - Distributed Systems
        
        Grids/P2P/Internet Computing/Clouds
      - Massively Parallel Processors (MPP)
        
        100+ nodes with a high-speed interconnection network/switch
        
        Each node has 1+ processors, sharing of the main memory
        
        Separate copy of OS runs on each node
    - - • Shared Memory
        
        master thread forks a number of sub-threads and divides tasks between them
        
        e.g. OpenMP --> API for multi-threaded, shared memory parallel programming
      - • Threads
      - • Message Passing
        
        :star:Message Passing interface (MPI)
        
        for inter-process communication in parallel systems
        
        multi-process (independent)--> MPI
        multi-thread (share) --> OpenMP
      - • Data Parallel
      - • Hybrid
      - :star:Amdahl’s Law
        
        speedup = 1/[(1-P)+P/N]
        P = parallel fraction
        N = number of processors
        1-P = serial fraction
        speedup v.s. resource will never be linear
        ==> P=0, speedup = 1(i.e. no speedup)
        ==> P=1,speedup = ∞
    - - Phase parallel
        
        all independent --> sync --> all independent --> sync
      - Divide and conquer
        
        divide & merge
      - Process farm
        
        master (sequential process)
        slaves (parallel processes)
        multi-level master-slave is possible
      - Work pool
        
        load balancing
        pool(collect works) vs processes
      - Pipeline
        
        stages (sequential & no sync in between)
    - - automatic parallelization
      - parallel libraries
      - Major recoding
    - - overhead can offset the speedup
      - error handling due to concurrency
      - cost of communication & overhead process
  - - - e.g. LB cluster, HA cluster, Web farms
    - - e.g. Nimrod, PARMON, Condor
    - - middleware: illusion of single system
      - elasticity: fast enough to adopt scalability
      - scalability: add/reduce resourece to keep speed
      - program: code for communication & division of tasks
  - - - UI
      - RB (resource broker)
      - Information System
      - Computing Element (CE)
      - Storage Element (SE)
    - - Intragrid
      - Extragrid
      - Intergrid
- - - - IAM atchitecture
  - - - block tools (e.g. ICMP protocol)
        
        randomised dynamic IP allocation
- - - - economy
      - reliability
      - availability
      - scalability
    - - hardware
      - software
      - power/memory/bandwidth etc.
  - - - resource with varying characteristics
        (e.g. networks, hardware, OS, prog lang)
        --> API
        --> middleware
        --> use standard protocols (somtimes)
        --> align data type & message format
    - - can extend system by add resource (both hard & soft)
    - - confidentiality (unauth access)
        
        integrity (unauth alteration)
        
        availability (for attack at access e.g. DoS attack)
        
        encryption (e.g. RSA, ACL)
        
        Authentication (e.g. pw)
        
        Authorization (ACL)
    - - Increasing No. of users
        --> resource cost (e.g. server),
        performance loss(e.g. scalable algorithm), resource availability(e.g. IP range),
        bottleneck(e.g. decentralized algorithm)
    - - detect: e.g. checksum
        
        mask: e.g. timeout & message retrans
        
        tolerate: e.g. report error to user
        
        recovery: e.g. roll back
        
        redundancy: e.g. use redundant component to ensure availability
    - - make access sequential
    - - hide component complexity
        
        access
        
        location
        
        concurrency
        
        replication
        
        failure
        etc.
    - - • Reliability
      - • Security
      - • Performance
      - • Adaptability
      - • Availability
  - - - salesforce.com
    - - Google App Engine
    - - AWS EC2/S3
- - - - IDL = WSDL
        --> doc for how to use the web service
      - Simple Object Access Prortocol --> need protocol
      - XML only
      - object not message
      - HTTP / ICMP / ... protocols
    - - URL + GET/POST/PUT/DELETE
        
        get: safe, idempotent
        
        put(update): idempotent, not safe
        
        delete idempotent, not safe
        
        post(create/update): not idempotent, not safe
      - representational state transfer
      - stateless
      - diff data structure
      - no protocol
      - only HTTP
- - - - I/O
        
        One virtual device on VMM, every VM access it
        
        I/O requests from all VMs send to a trusted host VM
      - Memory
        
        TLB (translation lookaside buffer): stores the recent translations of virtual memory to physical memory and can be called an address-translation cache.
        
        Shadow Page Tables: VMM maps virtual pages to physical pages
      - processor
        
        Time-Shared CPU by using context switching
        
        Instruction / mode
        
        privileged --> Kernel level (Mem/CPU/hardware)
        
        user mode --> App level
        
        sensitive instructions
        
        :star: - types: full virtualization / paravirtualization
        
        para: modified guest OS do the trap, before sending to hyppervisor
        
        full: hypervisor do the trap
- - - - Containerd
        
        Docker Deamon
        
        Docker client
        
        execute commands
        
        manages & build
      - keeps the container running. Keep stdin/stdout open.
  - - - 1 image = bunch of layers(lib), shared among containers
    - - Doc of commands to build the image
      - FROM python:3.6.8
        
        LABEL maintainer "yoyowong" "mwon0046@student.monash.edu"
        
        WORKDIR /app
        
        ADD iWebMath_client.py /app
        
        COPY requirements.txt requirements.txt
        
        ENV iWebMath_APP iwebmath_server.py
        
        ENV iWebMath_RUN_HOST 0.0.0.0
        
        RUN pip install -r requirements.txt
        
        COPY . .
        
        CMD ["flask", "run"] #
- - - - identity access management (e.g. identity fedration)
        
        user
        
        group
        
        policy (rules)
        
        role
        
        root account
    - - control access from external network
      - deployed in region
        
        1 subnet = 1 AZ
      - stateless ACL --> egress open manually when ingress open
        
        stateful security group --> egress open automatically when ingress open
      - VPC peering & VPC spread
        --> no transitive peering
      - Bastion host: access private subnet from public subnet
      - NAT gateway:
        
        public --> can outbound not inbound
        
        private --> connect to other VPCs
      - VPC endpoint: connect to other AWS services (e.g. S3) within AWS network
    - - :red_cross:EC2
        
        types
        
        reserved: period subscription
        
        Spot: bid (unreliable)
        
        on-demand: pay-as-u-run
        
        AMI (image)
        
        role (universal)
        
        Bootstrapping
        
        ~ deployment config
        
        placement policy
        
        Spread Placement (independent, more reliable)
        
        Clustered Placement Group (fastest)
        
        Partitioned Placement Group (replica = combination of both above, good for HDFS)
        
        deploy on defauly VPC (no custom policy)
      - :check:Lambda
        
        API Gateway
        
        serverless
        
        FaaS (function)
        
        stateless (the function will be recreated for every call)
        
        trigger = event / HTTP request
        
        all managed by AWS
    - - :check:S3
        
        read after write consistency
        
        eventual consistency
        (i.e. may be inconsistent due to concurrency & delay)
        
        ACL & access policy
        
        tiers:
        
        S3 standard
        
        S3-Infrequently Accessed (less frequent)
        
        S3-One Zone- IA (no multi AZ, cheapest)
        
        S3-Intelligent Tiering (for ML)
        
        S3 Glacier (archive with delay, cheaper)
        
        S3 Glacier Deep Archiv (archive with delay)
      - EBS (volume for EC2) (Elastic Block Store)
        
        SDD
        
        HDD
        
        archived / delete upon user choice when EC2 terminate
      - EFS (Elastic File System)
        
        fully managed elastic NFS file system for EC2 instances
        
        faster to access from VMs coz closer
      - cloudfront
        
        content delivery network (CDN), cache source from origin at Edge locations
      - storage gateway (good for data transfer)
    - - Types
        
        PostgreSQL databases.
        
        Amazon DynamoDB: non-relational
        
        Amazon Neptune: a fast, reliable, fully-managed graph database service that makes it easy to build and run applications that work with highly connected datasets.
        
        Amazon Timestream: a fast, scalable, fully managed time series database service for IoT and operational applications.
        
        Amazon DocumentDB: a fast, scalable, highly available, and fully managed document database service that supports MongoDB workloads.
        
        Redshift OLAP: massive data processing (frequent identical queries).
        
        Amazon Aurora: a MySQL and PostgreSQL compatible relational DB
        at least 6 copies
      - backup --> snapshot
      - scaling --> replica
    - - route53
    - - Message queue that can be used to store messages while for a computer to process them.
        
        decouple components (e.g. front-end in EC2 )
        
        FIFO: if processing exactly once (e.g. bank transaction)
        
        pull-based
    - - send notifications from the cloud. (e.g. SMS, email)
        
        push-based
    - - Kenisis
- - - - master vs nodes (manager & worker)
        
        nodes --> run containers
        
        orchestrator
      - pod: get 1 IP & volume but >1 containers
        
        container: application code
        communicate with other container within same pod use localhost
      - deployment: scaling, update, rollback --> a yaml file
        
        apiVersion: apps/v1
        kind: Deployment
        metadata:
        name: iwebmath-deployment
        spec:
        selector:
        matchLabels:
        app: iwebmath
        replicas: 3
        template:
        metadata:
        labels:
        app: iwebmath
        spec:
        containers:
        - name: iwebmath image: iwebmath:1.0.0 resources: limits: cpu: "0.5" requests: cpu: "0.5" ports: - containerPort: 8080
      - service: abstraction layer that define logical set of pods
        ---> set of pods share the same labels (if pod is died and recreated, new pod with new IP, register to the service automatically by labels)
        service: domain, IP, port (shared for pods with the same labels)
    - - manager vs worker node
        
        1 of the manager is the leader
        
        leader monitor swarm, managers elect leader
        
        :star:Raft
        elect method
        
        Swarm uses an implementation of the Raft consensus algorithm to power manager HA (high availability).
        
        terms: higher term be leader if 2 leaders
      - docker node ls (lists all nodes in the swarm including which are managers and which is the leader.)
        
        docker service create (is the command to create a new service.)
        
        docker service ls (lists running services in the swarm and gives basic info on the state of the service and any replicas it’s running.)
        
        docker service ps <service> (gives more detailed information about individual service replicas.)
        
        docker service inspect (gives very detailed information on a service. It accepts the --pretty flag to limit the information returned to the most)
      - nodes
        
        VXLAN (virtual overlay network)
        
        volumes (DB)
        
        service == pod in kubetl