Build Scalable Applications using Docker and Kubernetes from Udemy

Did you want to start learning Application Containerization, Docker, and Kubernetes but did not know where to start? Do you want something that is not just theroy, but rather a journey where you create and run an actual Application?

Then this course is for you. You will learn the concepts of Containers and how to put them to practice using Docker and Kubernetes. Better yet, you will build a Microservices Application in this course as you learn and apply the new concepts.

Course Objectives

Application Containerization
Multi-container Docker Applications
Kubernetes as a Container Orchestrator
Manage Applications using Kubernetes
Configure Applications using Kubernetes
Learn and apply the concepts of Microservices

You will build this Application

A Two-Tier Microservices Application which has
- A PHP Web Front End
- A Flask REST API Server Backend
Fully scalable, ready to scale up or down
Implemented in a Microservices Architecture, allowing Independent Deployability and Independent Scalability of each tier
Persist Important data on the server, even if the Application crashes
Apply all the concepts you will learn as you build this Application bit by bit

Technology used in the Application

The Frontend tier is built with PHP, HTML, CSS
The Backend tier is a REST API Server written in the Flask Python Framework
Containerize each tier in its own Docker Container Image
Build the end-to-end application using Docker, then using Kubernetes
Learn what Kubernetes adds on top of Docker to better manage your application

AW-11166561487

What's inside

Learning objectives

Learn the concepts of containers and docker
Use docker to containerize an application
Create multi-container applications using docker compose
Learn the concepts of container orchestration with kubernetes
Create a rest api server in a kubernetes pod

Expose your application using kubernetes service
Manage application revisions and scalability using kubernetes deployment
Persist the state of your application using kubernetes persistent volume
Manage configuration changes to your kubernetes application using configmap and portainer
Learn and apply the concepts of microservices and independent deployability

Learn the concepts of containers and docker
Use docker to containerize an application
Create multi-container applications using docker compose
Learn the concepts of container orchestration with kubernetes
Create a rest api server in a kubernetes pod
Expose your application using kubernetes service
Manage application revisions and scalability using kubernetes deployment
Persist the state of your application using kubernetes persistent volume
Manage configuration changes to your kubernetes application using configmap and portainer
Learn and apply the concepts of microservices and independent deployability

Syllabus

Lab 6: Pass Arguments to change the behaviour of a Container

Lab 7: Create a Multi-container Docker Application

Introduction

Progress Quiz 3

In this Quiz, you will review your knowledge about installing Docker and Kubernetes and running a Hello, World Container.

Traffic lights

Read about what's good

what should give you pause

and possible dealbreakers

Uses Docker and Kubernetes, which are industry-standard tools for containerization and orchestration, to build and deploy scalable applications

Covers microservices architecture, which is a popular approach for building complex applications that are independently deployable and scalable

Involves building a two-tier microservices application with a PHP frontend and a Flask REST API server backend, providing practical experience

Teaches how to persist application state using Kubernetes Persistent Volumes, which is essential for building stateful applications

Employs Docker Desktop, which may require learners to ensure their operating system meets the minimum requirements for running the software

Includes preparing for a Kubernetes certification, which may require additional study materials and exam fees not included in the course

Reviews summary

Build scalable apps with docker and kubernetes

According to learners, this course provides a practical, hands-on approach to building scalable applications using Docker and Kubernetes. Students appreciate the clear explanations of complex concepts and the real-world application project involving a two-tier microservice architecture. Many find it an excellent starting point for containerization and orchestration. The course is generally well-received, with a largely positive sentiment, though some users noted potential challenges with technical setup or desired more advanced topics beyond the introduction.

Pace works for beginners, might lack depth for others.

"The pace was just right for someone new to these technologies."

"While great for basics, I wished it went into more advanced Kubernetes topics."

"Felt a bit fast-paced in some sections, needed to rewatch lectures."

"Covers the essentials well, but isn't an in-depth deep dive into every K8s feature."

Course covers essential and current technologies.

"The focus on Docker, Kubernetes, and Microservices is highly relevant for today's tech roles."

"Appreciate that the course uses technologies like Flask and PHP in the project."

"The concepts covered align well with modern DevOps practices."

"It felt current and applicable to real-world application development."

Excellent for beginners in Docker/Kubernetes.

"This course is a fantastic starting point for anyone new to Docker and Kubernetes."

"Provides a solid foundation in containerization and orchestration principles."

"If you're a beginner looking to understand the basics, this course is perfect."

"It helped me get comfortable with core concepts before diving deeper."

Concepts are explained clearly and understandably.

"The instructor explains difficult concepts like Pods, Deployments, and Services very clearly."

"Complex topics are broken down into digestible parts, making it easy to follow along."

"Found the explanations of Docker and Kubernetes fundamentals to be straightforward and easy to grasp."

Hands-on labs are highlighted as a strength.

"The hands-on labs and project are incredibly helpful and solidify the concepts well."

"I really enjoyed building the microservices application step-by-step; it made learning practical."

"The practical exercises using Docker and Kubernetes were the most valuable part for me."

"The labs are well-structured and guide you through the entire application build process."

Some users face challenges with the lab environment.

"Ran into some issues getting the Docker Desktop environment set up correctly."

"encountered difficulties specific to my operating system during lab execution."

"The setup process for the labs could be smoother; required some troubleshooting."

"Needed to research external resources to resolve environment configuration problems."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Build Scalable Applications using Docker and Kubernetes with these activities:

Review Docker Fundamentals

Show steps

Solidify your understanding of Docker fundamentals to better grasp the course's application of Docker in scalable applications.

Show steps

Review Docker documentation.
Practice basic Docker commands.
Build and run a simple Docker image.

Brush up on Kubernetes Concepts

Show steps

Strengthen your knowledge of Kubernetes concepts to prepare for the course's focus on Kubernetes for application scaling.

Browse courses on Kubernetes Concepts

Show steps

Study Kubernetes architecture.
Familiarize yourself with Kubernetes objects.
Explore Kubernetes networking concepts.

Read 'Docker in Action, Second Edition'

Show steps

Expand your Docker knowledge with 'Docker in Action, Second Edition', a comprehensive guide that complements the course's practical labs.

View Docker in Action, Second Edition on Amazon

Show steps

Obtain a copy of 'Docker in Action, Second Edition'.
Read the book cover to cover.
Experiment with the examples in the book.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Containerize a Simple Web Application

Show steps

Gain hands-on experience with Docker by containerizing a simple web application, reinforcing the course's practical approach.

Show steps

Choose a simple web application.
Create a Dockerfile for the application.
Build and run the Docker image.
Push the image to a container registry.

Follow Kubernetes Deployment Tutorials

Show steps

Deepen your understanding of Kubernetes deployments by following online tutorials, complementing the course's deployment-focused labs.

Show steps

Find tutorials on Kubernetes deployments.
Follow the tutorials to create deployments.
Experiment with different deployment strategies.

Document Your Docker and Kubernetes Journey

Show steps

Reinforce your learning by documenting your experiences with Docker and Kubernetes, solidifying your understanding of key concepts.

Show steps

Create a blog or online notebook.
Document your learning process.
Share your insights and challenges.

Contribute to a Kubernetes Project

Show steps

Enhance your Kubernetes skills by contributing to an open-source project, applying your knowledge in a real-world setting.

Show steps

Find a Kubernetes open-source project.
Identify an area to contribute to.
Submit a pull request with your changes.

Career center

Learners who complete Build Scalable Applications using Docker and Kubernetes will develop knowledge and skills that may be useful to these careers:

DevOps Engineer

A DevOps Engineer plays a crucial role in streamlining software development and deployment processes. They bridge the gap between development and operations teams, automating infrastructure and application deployment. This course directly helps aspiring DevOps Engineers by providing hands-on experience with Docker and Kubernetes, essential tools for containerization and orchestration. The course's focus on building a microservices application using these technologies mirrors real-world DevOps scenarios. Specifically, learning to manage application revisions and scalability using Kubernetes Deployment, as covered in the course, aligns with core DevOps responsibilities. One who wishes to break into DevOps should know how to build scalable applications.

See salaries and explore the career path for DevOps Engineer

Cloud Engineer

A Cloud Engineer is responsible for designing, building, and maintaining cloud infrastructure and applications. This course helps individuals become proficient in using containerization and orchestration technologies, which are fundamental to cloud deployments. The concepts of Docker and Kubernetes, which are covered extensively in the course, are essential tools for cloud engineers. Building a microservices application as part of the course provides practical experience in deploying and managing applications in a cloud-native environment. In particular, the course's coverage of Kubernetes Persistent Volumes for stateful applications can be valuable when working in the cloud. Aspiring cloud engineers should know how to build scalable applications.

See salaries and explore the career path for Cloud Engineer

Software Architect

A Software Architect designs the structure of software systems, ensuring they are scalable, maintainable, and efficient. This course helps develop skills in designing and implementing microservices architectures using Docker and Kubernetes. Understanding containerization and orchestration is crucial for modern software architecture, enabling the creation of resilient and scalable applications. The course's hands-on approach to building a two-tier microservices application provides practical experience in architectural design patterns. Gaining familiarity with managing configuration changes using ConfigMap and Portainer, as taught in the course, is beneficial for architects. Potential software architects would find this course helpful.

See salaries and explore the career path for Software Architect

Systems Engineer

A Systems Engineer focuses on the overall design, integration, and management of complex systems. This course helps build a Systems Engineer's understanding of containerization, orchestration, and microservices architecture. Learning to use Docker and Kubernetes to deploy and manage applications allows for efficient resource utilization and scalability. The course's hands-on labs, such as creating multi-container Docker applications and managing applications using Kubernetes, provide practical experience in system integration. Understanding how to persist application state using Kubernetes Persistent Volumes, as covered in the course, is particularly relevant to systems engineering. Those aspiring to systems engineering find this course helpful.

See salaries and explore the career path for Systems Engineer

Backend Developer

A Backend Developer is responsible for building and maintaining the server-side logic and databases of applications. This course helps backend developers gain practical experience with containerizing and deploying backend services using Docker and Kubernetes. The course's focus on building a REST API server with Flask and deploying it in a Kubernetes Pod provides direct experience in backend development workflows. Learning to manage application revisions and scalability using Kubernetes Deployment, as covered in the course, is highly relevant to backend development. One who wishes to work as a backend developer will find value in this course.

See salaries and explore the career path for Backend Developer

Solutions Architect

A Solutions Architect designs and implements technology solutions that meet specific business needs. This course may help aspiring Solutions Architects understand and leverage containerization and orchestration to build scalable and resilient solutions. The course's hands-on experience with Docker and Kubernetes provides a practical understanding of these technologies. The course teaches how to build a two-tier microservices application, which is relevant when designing modern, cloud-native applications. Learning about managing configuration changes using ConfigMap and Portainer, as covered in the course, can be useful for solutions architects when addressing the need for configurable, adaptable, and scalable systems. Aspiring Solutions Architects can benefit from this course.

See salaries and explore the career path for Solutions Architect

Platform Engineer

A Platform Engineer builds and maintains the underlying infrastructure and tools that enable software development teams to build, deploy, and run applications. This course provides platform engineers with practical skills in containerization, orchestration, and microservices. The course helps Platform Engineers learn to use Docker and Kubernetes to build and manage application platforms. Hands-on labs, such as creating multi-container Docker applications and managing applications using Kubernetes, provide practical experience in platform engineering. Moreover, the course's coverage of Kubernetes Persistent Volumes and ConfigMaps is highly relevant to building robust and configurable application platforms. A person looking for a job as a Platform Engineer would find this course useful in their search.

See salaries and explore the career path for Platform Engineer

Release Engineer

A Release Engineer manages the process of releasing software updates and new features to production environments. This course may help release engineers gain valuable skills in automating and streamlining the software release process using Docker and Kubernetes. The course's focus on containerization and orchestration provides a foundation for building automated release pipelines. Learning to manage application revisions and scalability using Kubernetes Deployment, as covered in the course, is directly relevant to release engineering. Someone who wants to break into the field as a release engineer might consider this course.

See salaries and explore the career path for Release Engineer

Site Reliability Engineer

A Site Reliability Engineer (SRE) ensures the reliability, scalability, and performance of software systems in production. This course may help SREs gain a deeper understanding of containerization and orchestration, which are crucial for managing complex systems. The course's hands-on experience with Docker and Kubernetes provides practical skills in deploying and managing applications in production environments. Learning to manage application revisions and scalability using Kubernetes Deployment, as covered in the course, is directly relevant to SRE responsibilities. People who want to work as SREs will find this course helpful.

See salaries and explore the career path for Site Reliability Engineer

Technical Lead

A Technical Lead guides and mentors a team of developers, setting technical direction and ensuring code quality. This course may help Technical Leads understand containerization technologies and microservices, which are increasingly important in modern software development. Exposure to Docker and Kubernetes provides a high-level overview of deployment strategies. The course's focus on building a microservices application could be relevant to leading teams working on similar architectures. Someone interested in technical leadership may find value in a course like this.

See salaries and explore the career path for Technical Lead

Software Consultant

A Software Consultant advises clients on technology solutions and helps them implement new systems. This course may help Software Consultants gain knowledge of containerization and orchestration technologies like Docker and Kubernetes. Understanding these technologies can be valuable when advising clients on modern application deployment strategies. The course's hands-on experience with building a microservices application provides a practical understanding of this architectural pattern. Software Consultants may find the course to be a good way to improve their skills.

See salaries and explore the career path for Software Consultant

Data Engineer

A Data Engineer builds and maintains the infrastructure for data storage, processing, and analysis. This course may help Data Engineers learn to use containerization and orchestration technologies to deploy and manage data pipelines. The course's coverage of Docker and Kubernetes provides a foundation for containerizing data processing applications. Learning to manage application state using Kubernetes Persistent Volumes, as covered in the course, is relevant when working with stateful data applications. Data Engineers might find this course useful.

See salaries and explore the career path for Data Engineer

Security Engineer

A Security Engineer is responsible for protecting computer systems and networks from security threats. This course may help Security Engineers gain a better understanding of containerization and orchestration, which can impact application security. Learning about Docker and Kubernetes provides insight into the security considerations of containerized environments. The course's focus on managing application configurations using ConfigMap can be relevant to securing application settings. Security Engineers can use this course to help secure their applications.

See salaries and explore the career path for Security Engineer

Database Administrator

A Database Administrator (DBA) manages and maintains database systems, ensuring data integrity and availability. This course may help DBAs learn how to deploy and manage databases in containerized environments using Docker and Kubernetes. The course's coverage of Kubernetes Persistent Volumes is particularly relevant to persisting database state. By taking this course, database administrators can learn about a different aspect of their field.

See salaries and explore the career path for Database Administrator

Network Engineer

A Network Engineer designs, implements, and manages computer networks. This course may help Network Engineers gain a better understanding of how containerized applications communicate within a network. The course's coverage of Kubernetes Services, which enable application exposure, provides insight into networking aspects of container orchestration. Network Engineers may find it useful to learn about how this course works.

See salaries and explore the career path for Network Engineer

Reading list

We've selected one books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Build Scalable Applications using Docker and Kubernetes.

Docker in Action, Second Edition

Save

Provides a comprehensive guide to Docker, covering everything from basic concepts to advanced techniques. It is particularly useful for understanding how to use Docker to containerize applications and manage them in production. This book adds more depth to the course by providing real-world examples and best practices.

Docker in Action, Second Edition

Paperback

Build Scalable Applications using Docker and Kubernetes

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

Build scalable apps with docker and kubernetes

Activities

Career center

Reading list

Share

Similar courses