Docker for Beginners: DevOps for Java & Spring Boot

Install Docker across macOS, Windows, and Linux, run basic Docker commands, and gain a 10,000 feet overview of how Docker differs from virtual machines and its internal architecture.

Deploy a Spring Boot application quickly by running a Docker image, eliminating local Java installation, and observe the image pull and launch in a QA environment.

Learn how hub.docker.com serves as a docker registry hosting repositories and tags, how an image becomes a container, and how port mapping like 5000:5000 lets you access the app.

Learn to run docker images in detached mode, view logs with docker logs -f, manage multiple containers, and inspect images with docker container ls -a on ports.

Discover Docker architecture by examining the Docker client and Docker daemon, and see how the daemon manages containers and local images, pulling and pushing images to the registry.

Discover why Docker is popular by comparing container-based architecture with virtual machines, and see how easily Docker runs on local machines and cloud services like Azure Container Service.

Learn to tag and manage images, understand latest tag caveats, and use docker pull and docker run. Discover official images and use history and inspect to understand image layers.

Explore essential docker container commands, including running in detached mode, pausing and unpausing, tailing logs, inspecting containers, pruning stopped ones, and understanding stop versus kill and the restart policy --restart=always.

Explore essential docker commands such as events, top, stats, and system df, and learn how to monitor containers, set memory and cpu limits, and view resources in real time.

Download or clone the repository, extract it, import six spring boot projects (rest api, todo apps, full-stack, currency exchange/conversion) in Eclipse to build and run docker images in containers.

Learn how to run and containerize a Spring Boot hello world REST API, exposing hello-world, hello-world-bean, and path-variable endpoints, and build a Docker image.

Learn to build a docker image manually for a hello world rest api by packaging a jar with Maven, copying the jar into an openjdk:8-jdk-alpine base, and running it.

Automate building a java rest-api image with a dockerfile, using a base openjdk:8-jdk-alpine, copying the jar, and setting startup with entrypoint, then build and run on port 8080.

Investigate how docker image layers and caching influence builds, using a jdk 8 alpine base, add instructions, and an entrypoint to run a container on port 8080.

Automate docker image creation by integrating the Spotify dockerfile-maven-plugin with Maven, so mvn package builds both the jar and the image in one command.

Create a generic, reusable dockerfile that can be used across Spring Boot projects by copying any jar to app.jar and adjusting the port.

Learn to improve docker image caching by splitting the fat jar into dependencies and classes, unpacking with maven dependency plugin, and copying boot-inf/libs, meta-inf, then classes to maximize cache hits.

Jib, a Maven plugin, builds Docker and OCI images for Java applications without a Dockerfile. It creates reproducible, layered images and auto-detects the entry point.

Explore the Fabric8 Docker Maven Plugin for creating Docker images, offering both Dockerfile-based and XML configuration options. Compare its approach with the Dockerfile Maven plugin and jib.

Deploy a Spring Boot todo web app as a WAR on Tomcat, using H2 in-memory database and Spring Security, and manage todos through the UI and H2 console.

Create a docker image for the todo web app using a Tomcat base, deploy the WAR as ROOT.war, and build with Spotify Dockerfile Maven plugin to run on port 8080.

Copy copies local files, add can fetch urls and unzip archives, and cmd is overridable while entrypoint keeps the executable, overridable only with --entrypoint.

Push your spring boot todo app image to Docker Hub by logging in, building with mvn clean package, tagging with your Docker id, and pushing the 0.0.1-SNAPSHOT tag to in28min/todo-web-application-h2.

Migrate a Spring Boot todo app from H2 to MySQL by updating pom.xml and configuring application.properties. Enable retention with ddl-auto=update and map the desc field to description using @column annotation.

Learn to run MySQL in a local docker container, configure with env vars like MYSQL_ROOT_PASSWORD and MYSQL_DATABASE, publish port 3306, and connect with a MySQL client.

Connect a Spring Boot web app to a MySQL database running in a Docker container, create and query the todos table, and verify data persists after restart.

Create a docker image for the todo web app, run app and mysql containers, and connect them using environment variables and the deprecated link.

Explore Docker networking options for Java and Spring Boot apps, including bridge, host, and none; learn port publishing and why a custom network is recommended.

Create a custom Docker bridge network and connect a MySQL container and a web application, enabling inter-container communication without links.

Explore how Docker volumes persist data across container restarts, enable data sharing between containers, and protect important information when containers are removed.

Deploy a full stack app with Spring Boot and React, secure its REST API with Spring Security and JWT, and run the backend on port 8080.

Connect the React frontend to the local backend by configuring Visual Studio Code, installing dependencies with npm, and running the app on port 4200 while pointing API calls to localhost:8080.

Containerize a full-stack java rest API and a node front end with docker, exposing port 8080. See how spring-boot-maven-plugin explodes the fat jar and dockerfile-maven-plugin builds the image.

Containerize a React frontend with a two-stage Docker build, using Node.js for npm install and npm run build, then copy the build into an nginx image for production.

Improve front-end docker builds by using a .dockerignore to shrink build context and npm install time, then deploy via multi-stage builds and run the container on port 4200.

Configure a two-stage docker build for a java rest api backend to produce a platform-independent, reproducible image with stage one building dependencies and stage two a minimal OpenJDK Alpine image.

Learn to build and run a Java REST API backend with Docker two-stage builds, optimize Maven dependency downloads, and run with port 8080 while integrating with a front end.

Docker Compose defines and runs multi-container applications using a YAML file, enabling isolated environments, data-preserving volumes, and selective recreation of changed containers with a single command.

Install Docker Compose, configure a docker-compose.yml with services and networks, and use docker-compose up and down to deploy and manage a full-stack todo app.

Use docker compose to run a Java Spring Boot todo web app with MySQL, persist data via a host volume, configure environment variables, and manage services with depends_on and networks.

Explore docker compose commands: down, up, ps, top, config, images, rm, pause, unpause, stop, kill, and build contexts to manage services and inspect containers.

Explore the microservice approach by defining microservices, their REST-based communication, and cloud-enabled, independently deployable units with well-defined boundaries. Compare monoliths and microservice architectures, highlight advantages, challenges, and deployment considerations.

Explore the advantages of microservice architectures, including adapting to new technologies, dynamic scaling, and faster release cycles for cloud-enabled applications.

Discover how Docker enables consistent environments and streamlined deployment across microservices built as containers. This approach eases adoption of new technologies and simplifies operations.

Explore two Spring Boot microservices, currency exchange and currency conversion, their H2 database, key endpoints, and how Feign enables inter-service calls.

Build docker images for the currency-exchange and currency-conversion microservices, create a currency-network, and run containers that communicate via the currency-exchange uri environment variable on ports 8000 and 8100.

Configure a Docker compose workflow to run currency-exchange-service and currency-conversion-service, create a dedicated currency-compose-network, add environment variables, and manage containers and startup order for microservices.

Discover how a Eureka Naming Server enables service registration and discovery across multiple microservice instances, and how Feign with Ribbon enables client-side load balancing and dynamic scaling.

Set up the Netflix Eureka naming server with Spring Cloud, enable discovery clients in two services, and configure Docker Compose to connect them to naming-server:8761/eureka.

Configure and run Java Spring Boot microservices with a Eureka naming server using Docker Compose. Register, discover, and load balance currency-exchange and currency-conversion services with Ribbon and Feign.

Explore using Zuul API gateway to centralize authentication, rate limiting, logging, and pre filters for service aggregation across microservices with Eureka discovery.

Deploy and orchestrate microservices with docker compose to run the Zuul API gateway and currency-exchange and currency-conversion services, coordinated by the naming server.