-
The NIST Cloud Definition (2011)
- Breakdown of the NIST’s five essential cloud characteristics, deployment models, and service models.
-
Overview of Major Cloud Providers
- Key players in the cloud space (AWS, Azure, Google Cloud, etc.).
- Comparing evolution.
-
Cloud Service/Abstraction Models
- IaaS, PaaS, SaaS revisited, with modern examples.
- The evolution of abstraction models, including FaaS and Containers-as-a-Service (CaaS).
-
Introduction to CNCF
- Role of the Cloud Native Computing Foundation (CNCF) in the cloud ecosystem.
- CNCF Landscape: technologies, tools, and projects.
-
Popular Technologies
- Kubernetes: Container orchestration in cloud-native environments.
- eBPF: Extending kernel capabilities for monitoring and security.
- OpenTelemetry: Observability standards and practices in modern cloud systems.
By the end of this lecture, students will be able to:
- Describe the NIST cloud definition and its significance in the modern cloud landscape.
- Identify the major cloud providers and tell about their evolution.
- Differentiate between cloud service models and discuss their evolution, including modern abstraction models like CaaS.
- Explain the role of CNCF and analyze the CNCF landscape to identify key technologies and trends.
- Provide an overview of Kubernetes, eBPF, and OpenTelemetry, explaining their impact on cloud-native development.
- What are the five essential characteristics of cloud computing according to NIST, and how do they apply to modern cloud services?
- Identify 3 main cloud providers.
- What are the differences between IaaS, PaaS, and SaaS? Give examples of each in today's cloud ecosystem.
- What is the CNCF, and why is it important in the context of cloud-native technologies?
- How does Kubernetes help in managing containerized applications in cloud-native environments?
- What is eBPF, and what advantages does it provide in terms of system monitoring and security?
- Explain the role of OpenTelemetry in modern cloud systems. How does it contribute to observability?
- NIST 2011 Cloud Computing Definition
- CNCF Cloud Native Landscape
- Introduction to Kubernetes
- Understanding eBPF
- OpenTelemetry Documentation
- Get a GitHub or GitLab or Bitbucket account
- Play with Codespaces, Gitpod or IDX
Here’s the documentation for the new lecture:
-
Introduction to Spring Boot
- Evolution of Spring to Spring Boot: Understanding how Spring Boot simplifies Spring applications, focusing on convention over configuration.
- Spring Initializr: A web-based tool for quickly creating Spring Boot projects with customizable dependencies.
- Key Dependencies:
- Web: Building RESTful web services and web applications.
- Actuator: Providing production-ready features such as monitoring and health checks.
- application.properties: Configuration of application settings in Spring Boot projects.
- Spring Boot Project Structure: Understanding the typical structure of a Spring Boot project and how it facilitates development.
-
Overview of Cloud-Based IDEs
- GitHub Codespaces: Cloud-hosted development environments integrated with GitHub, enabling easy setup and collaboration.
- Gitpod: Automating cloud-based development workspaces with pre-configured environments.
- Advantages of cloud-based IDEs for Spring Boot development: instant setup, collaboration, and scalability.
By the end of this lecture, students will be able to:
- Describe the evolution of Spring to Spring Boot and how Spring Boot improves application development.
- Use Spring Initializr to create Spring Boot projects with appropriate dependencies.
- Understand and configure application properties using
application.propertiesin Spring Boot. - Identify the key components and structure of a typical Spring Boot project.
- Compare GitHub Codespaces and Gitpod, and explain how cloud-based IDEs enhance Spring Boot development workflows.
- What are the key differences between traditional Spring and Spring Boot?
- How does Spring Initializr simplify the creation of Spring Boot projects, and what are some essential dependencies you might include?
- What role does the
application.propertiesfile play in a Spring Boot project? - What can you derive from the following code snippet:
@GetMapping("/hello/{name}")
public String sayHelloWithParameter(@PathVariable String name){
return "Hallo, "+name;
}- How does GitHub Codespaces or Gitpod make it easier to develop Spring Boot applications in a cloud environment?
- What are the key benefits of using a cloud-based IDE over a local development environment for any kind of development?
- Spring Boot Documentation
- Spring Initializr
- Spring Boot Actuator Documentation
- GitHub Codespaces Documentation
- Gitpod Documentation
- Baeldung Actuator
- Build a Spring Boot Hello, World REST API Project using Codespaces or GitPod
-
Development in distributed teams withouth containers and the potential problems:
- Polyglot application landscapes are challenging as all work environments need to match all runtime requirements for all languages
- Transporting application from environment A to environment B introduces challenges and problems with mismatching runtimes
-
Containers
- Isolate Applications from each other
- Package Applications along with all Runtime requirements for easy execution and transportation between working environments
- Simplify configuration of working environments -> only container engine needed
- handling of all application containers through same mechanisms: docker build, docker run
-
Docker
- Docker ecosystem consists of the Docker Daemon, Docker CLI and Docker Hub+
- Creation of Dockerfiles
- Building Images
- Running Containers
-
Exercises
- Exercises can be found at: https://lecture.new.trainings.nvtc.io/basics/container/
- What is Docker, and how does it differ from traditional virtual machines?
- Explain the concept of a Docker image and a Docker container. How are they related?
- What are the main components of a Dockerfile? Describe the purpose of each component.
- How does Docker ensure isolation and security between containers?
- What is a container registry, and how do you use Docker Hub to share or deploy images?
- Describe the process of building and running a containerized application using Docker, including common commands.
- Get a Dockerhub account
- Work through the exercises
-
Distributed Systems Theory
- CAP Theorem: Understanding the trade-offs between Consistency, Availability, and Partition Tolerance in distributed systems.
- Conway's Law: Exploring how software design reflects organizational structure and its implications for distributed systems.
- 12-Factor Applications: Best practices for building scalable, maintainable applications, focusing on principles like configuration, dependencies, and logging.
- Microservices: Basic concept of microservices, its advantages, and challenges in distributed systems.
-
Introduction to Persistence, ORM, Spring Data, and Spring Data JPA
- Persistence and ORM: Discussed the importance of persistence for long-term data storage, introducing ORM as a way to map objects to relational database tables seamlessly.
- Spring Data JPA: Explored how Spring Data JPA simplifies data access through repository interfaces, enabling easy CRUD operations and custom queries without boilerplate code.
By the end of this lecture, students will be able to:
-
Describe the CAP Theorem, its components, and how it affects design choices in distributed systems.
-
Explain Conway’s Law and its influence on software architecture, especially in the context of microservices.
-
List and apply the 12 factors for building scalable, portable, and maintainable applications.
-
Define and differentiate microservices architecture from other architectural styles.
-
Explain the concepts of persistence and ORM and identify their importance in distributed, database-driven applications.
-
Set up Spring Data JPA to interact with a relational database and configure it using Docker Compose.
Be able to relate the concepts of CAP theorem and the 12-factor apps to the technologies we are covering in the lecture, e.g. how do technologies like Spring Boot (or other frameworks/languages), Docker, Kubernetes incorporate or implement those aspects
- What are the components of the CAP Theorem, and why can’t a distributed system fully achieve all three?
- How does Conway’s Law impact the structure of a distributed system, especially when adopting a microservices architecture?
- What are the key factors of a 12-factor app, and how do they contribute to application scalability and resilience?
- Describe microservices concepts and some of its advantages over a monolithic architecture.
- What is Object-Relational Mapping (ORM), and why is it beneficial for a database-backed application?
- Explain how Spring Data JPA helps in managing CRUD operations in a database.
- Understanding the CAP Theorem
- Conway’s Law - A Key Consideration in Architecture
- The Twelve-Factor App
- Microservices Architecture Documentation
-
API and REST
- HTTP Basics: Core concepts of HTTP for APIs, including request/response structure.
- Introduction to REST: Understanding the foundational ideas of REST as defined by Roy Fielding and how RESTful APIs communicate.
- Nouns and Verbs: Structuring REST APIs around resources (nouns) and actions (verbs).
- Representation: Data formats in REST (e.g., JSON, XML) and the role of content negotiation.
- HTTP Return Codes: Standard HTTP status codes, their meanings, and when to use each in API responses.
- Idempotency: Ensuring repeatable requests yield the same results to prevent unintended side effects.
- Richardson's Maturity Model: Levels of RESTful maturity, from Level 0 (HTTP as a tunnel) to Level 3 (HATEOAS), to understand API design progression.
- OpenAPI and Swagger: Using OpenAPI for defining APIs, ensuring consistency, and employing Swagger UI for visualization and testing.
-
Docker-Compose for Multi-Component Applications
- Setting up multi-component applications using Docker Compose, integrating backend APIs, databases, and frontends in a single
docker-compose.ymlfile. - Configuration of service communication, externalized settings, and container networking to simplify deployment and scaling.
- Setting up multi-component applications using Docker Compose, integrating backend APIs, databases, and frontends in a single
Students should be able to:
- Describe the foundational principles of REST and explain the HTTP concepts that underpin REST APIs.
- Use OpenAPI to define REST APIs and visualize them with Swagger UI.
- Create and configure a Docker Compose file to integrate multiple application components and enable effective communication between services.
- What are the core principles of REST, and how do they align with HTTP concepts?
- Explain the importance of structuring REST APIs around resources (nouns) and actions (verbs). Provide examples.
- What is Richardson’s Maturity Model, and how does it help assess the maturity of a REST API?
- Why is idempotency important in REST APIs? Give an example of an idempotent and a non-idempotent HTTP method.
- Describe the advantages of using OpenAPI for REST API documentation.
- How does Docker Compose enable multi-component application setups, and what are the benefits of externalized configuration?
- Explain the role of container networking in Docker Compose and how it facilitates service communication.
- Watch the recordings from the previous session - priority on cloud-native theory!
This lecture explores advanced Docker features that are essential for managing containerized applications in cloud-native environments. Students will learn about Docker networking modes, data persistence with volumes, and orchestrating multi-container applications using Docker Compose. By mastering these topics, students will be able to design, deploy, and manage robust containerized systems effectively.
By the end of this lecture, students will be able to:
- Explain Docker's network modes and create custom networks to manage container communication.
- Differentiate between bind mounts and named volumes, and apply them for persistent data storage.
- Design and implement multi-container applications using Docker Compose.
- Optimize container setups by combining networking and volume management best practices.
- What are the main differences between Docker’s bridge and host network modes?
- How does a named volume differ from a bind mount, and when should each be used?
- In a
docker-compose.ymlfile, how do you define a custom network and attach services to it? - What is the purpose of Docker’s internal DNS service, and how does it enhance container communication?
- How can you persist data for a containerized database across container restarts?
-
Networking Practice:
- Create a custom Docker network and deploy two containers to communicate within it.
- Verify connectivity using tools like
pingand DNS resolution.
-
Volume Management:
- Set up named volumes for a container to persist data.
- Demonstrate sharing a volume between multiple containers.
-
Compose Application:
- Build and deploy a web application with a backend database using Docker Compose.
- Define networks and volumes in the
docker-compose.ymlfile.
-
Introduction to Kubernetes
- What is Kubernetes?: High-level overview of Kubernetes as a container orchestration platform.
- Why Kubernetes?: Key benefits, including scalability, fault tolerance, and management of containerized applications.
-
Kubernetes Cluster Architecture
- Control Plane and Worker Nodes: Explanation of the roles and responsibilities of the control plane and worker nodes in a Kubernetes cluster.
- Key Components: Overview of critical components like
kube-apiserver,etcd,kube-scheduler,kube-controller-manager, andkubelet.
-
Declarative Working Mode
- Configuration as Code: Introduction to Kubernetes' declarative approach for managing application state using YAML manifests.
- Reconciliation Loop: How Kubernetes ensures desired state matches the actual state through its control loop.
-
Most Important API Objects
- Pods: The smallest deployable unit in Kubernetes, representing one or more containers.
- ReplicaSets: Ensuring the desired number of pod replicas are running.
- Deployments: Managing updates and rollbacks for applications.
- Services: Enabling communication between pods and exposing applications to external users.
Students should be able to:
- Explain what Kubernetes is, why it is used, and its primary benefits.
- Describe the architecture of a Kubernetes cluster and the roles of its key components.
- Demonstrate understanding of the declarative approach for managing applications in Kubernetes.
- Identify and explain the purpose of key Kubernetes API objects, including pods, ReplicaSets, deployments, and services.
- What is Kubernetes, and why is it essential for managing containerized applications?
- Describe the roles of the control plane and worker nodes in a Kubernetes cluster.
- What is the function of the
kube-apiserverandetcdin Kubernetes? - Explain Kubernetes’ declarative working mode. How does the reconciliation loop ensure consistency?
- What is a pod in Kubernetes, and how does it differ from a container?
- How do ReplicaSets help ensure application reliability?
- What are deployments in Kubernetes, and how do they simplify updates and rollbacks?
- How do services in Kubernetes enable communication between pods and expose applications externally?
Different ways to access a Kubernetes environment (Public Cloud, Codespace, local (Kind, Minikube,...))
This lecture provides an introduction to Kubernetes deployment options and revisits essential Kubernetes API objects in greater detail. Students will explore free Kubernetes trials offered by major cloud providers, local deployment tools like Minikube and Kind, and how to use Kubernetes in cloud-based IDEs like GitHub Codespaces. The session also deepens understanding of fundamental API objects such as Pods, Deployments, and Services, equipping students with practical knowledge for managing containerized applications in Kubernetes.
By the end of this lecture, students will be able to:
- Identify and compare Kubernetes deployment options, including cloud trials and local setups.
- Set up a Kubernetes cluster locally using tools like Minikube or Kind, and within GitHub Codespaces.
- Describe the roles and relationships of basic Kubernetes API objects, including Pods, Deployments, and Services.
- Deploy and manage containerized applications using Kubernetes API objects.
- What are the advantages and limitations of using Kubernetes free trials from cloud providers compared to local tools like Minikube?
- How does Minikube enable Kubernetes functionality within a GitHub Codespaces environment?
- What is the role of a Pod in Kubernetes, and how does it differ from a Deployment?
- How do Services enable communication between Kubernetes Pods and external clients?
- How can you use a Deployment to ensure high availability for an application in Kubernetes?
- show slides and theory about services and recap API objects
- scale, fail, observe, udpate, patch apps in Kubernetes