-
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
- Watch the recordings from the previous session - priority on cloud-native theory!