Nane Kratzke

Lecture:

Cloud-native Programming

Published: 28 Sep 2020 (latest update: 09 Oct 2020)
Short: CloudProg
Study: Computer Science/Distributed Systems, M. Sc.
Semester: WS 2020/21

Remark: Google Cloud supports this course via Google Teaching Credits. Information on how to make use of these grants are provided in Moodle. However, this welcome support does not affect the independence of the course content and the critical examination of cloud computing topics such as vendor lock-in or portability issues of cloud-native applications.

The course Cloud-native Programming is given for Master Computer Science students at the Lübeck University of Applied Sciences. It focuses mainly on the programming specifics that are necessary to develop so-called cloud-native applications. Cloud-native applications are intentionally designed to run on cloud infrastructures and leverage the elasticity and scalability features of modern private or public cloud-platforms and -infrastructures by their design.

The course lays the necessary “Everything-as-Code” programming capabilities to understand and create the design modern of cloud-native applications. Corresponding cloud-native application architecture design patterns are covered by the follow-up course “cloud-native architectures”.

The course covers the following aspects and addresses each aspect from a practical development/programming point of view:

  • Fundamentals of Cloud Computing
    • Cloud Computing definitions and point of views
    • Cloud-service models
    • Implications of the “Cloudonomics”
  • Motivation and principles of DevOps
    • DevOps-compliant architectures
    • Continuous disciplines and deployment pipelines
    • Inside Gitlab CI/CD (Type Representative)
  • Infrastructure as a Service
    • Virtualization (Emulation, Type-1/2 Hypervisors, OS-Virtualization, SW-Virtualization)
    • Automatic provisioning approaches
    • The cloud service model Infrastructure as a Service (IaaS)
    • Infrastructure as Code
    • Inside Vagrant and Terraform (Provisioning Type Representatives)
    • Inside Google Compute Engine (IaaS Type Representative)
  • Standardization of deployment units
    • Platform as a Service and the PaaS-Problem
    • Linux-based OS-Virtualization (Containers)
    • Container runtime environments and container patterns
    • Inside Docker (Type Representative)
  • Container Orchestration
    • The scheduling problem and possible approaches
    • The orchestration problem and possible approaches
    • Inside Kubernetes (Type Representative)
    • Inside Google Kubernetes Engine (Managed K8S Service Representative)
  • Function as a Service
    • Serverless
    • Function as a Service Approaches and Platforms
    • Serverless Programming Models
    • Inside Kubeless (Self-hosted FaaS Representative)
    • Inside Google Cloud Functions (Managed FaaS Representative)
  • Polyglot Programming
    • The implication of microservices on the heterogeneity of programming languages
    • Reactive Programming
    • Network/Cloud Programming Languages
    • Inside RxPY (Reactive Programming Type Representative)
    • Inside Ballerina (Network/Cloud Programming Language Type Representative)

Closing remark: Due to the COVID19 pandemic, this course will be given in an online format composed of online lectures and online practical courses.

Material

  • Unit 01: Fundamentals of Cloud Computing
  • Unit 02: DevOps
  • Unit 03: Infrastructure as a Code
  • Unit 04: Standardization of Deployment Units
  • Unit 05: Container Orchestration
  • Unit 06: Function as a Service
  • Unit 07: Resulting Cloud-native Programming Models

Labs

  • Lab 01: Understand Cloud Workloads
  • Lab 02: Deployment Pipelines as Code
  • Lab 03: Immutable Infrastructure
  • Lab 04: Infrastructure as a Service und Infrastructure as Code
  • Lab 05: Containerization
  • Lab 06: Container Orchestration
  • Lab 07: Function as a Service