Static Website with Docker

• Docker containers encapsulate web applications for easy distribution and management.
• The tutorial progresses from simple static websites to complex orchestrated applications.

Bullarium Bracarensis Static Website with Docker

• A static website using HTML and CSS was encapsulated in a Docker container to be served over HTTP.
• The Docker image for this setup includes the HTML pages, CSS stylesheets, and a web server.
• Any web server can be used, but their configurations may differ.
• Nginx was used for the first version.

Dockerfile for Static Website + Nginx

• FROM nginx: Specifies the base image as nginx.
• COPY . /usr/share/nginx/html: Copies the website files to the directory where nginx serves content.
• To run the container, the web server responds on internal port 80.
• Map the internal port to an external port, for example, 2804.

Running the Docker Container

• Command to run the Docker container: docker run -d -p 2804:80 --name bb engweb2024/bb

Static Website + Apache

• To create a container with Apache, only the base image and website directory need to be altered.

Dockerfile for Static Website + Apache

• FROM httpd:latest: Sets the base image to the latest httpd (Apache) image.
• COPY . /usr/local/apache2/htdocs/: Copies the website files to Apache's document root.
• Apache also responds on internal port 80.

Running the Apache Container

• Command is similar to the nginx version: docker run -d -p 2804:80 --name bb engweb2024/bb_apache

Examining Container Logs

• Logs can be examined after website interactions.
• Example log entries show HTTP requests and server responses.

Static Website + Python

• More configuration is required for a Python container.

Dockerfile for Static Website + Python

• FROM python: Specifies the base image as Python.
• WORKDIR /usr/src/app: Sets the working directory inside the container.
• COPY . .: Copies the website files to the working directory.
• CMD ["python", "-m", "http.server", "80"]: Starts a simple HTTP server using Python.
• WORKDIR specifies the default directory for subsequent commands.
• The Python web server is a module that needs execution with arguments.
• The CMD specifies a list of arguments as strings.
• The Python web server is configured to respond on internal port 80.

Running the Python Container

• Sample commands to build and run the image:
• docker build . -t engweb2024/bb_python
• docker run -d -p 2804:80 --name bb engweb2024/bb_python

Applications with Node.js

• Examples of web applications developed with Node.js are presented with increasing complexity.

Node.js: Hello World

• A simple web application that responds with a text message.

Web Service Code

• Includes code to set up a simple HTTP server using Node.js
• The server listens on port 7777.

Dockerfile for the Node.js Web Service

• FROM node: Uses the Node.js image as the base.
• WORKDIR /app: Sets the working directory.
• COPY server1.js .: Copies the application files.
• EXPOSE 7777: Exposes the port the server will run on.
• CMD ["node", "server1.js"]: Starts the Node.js application.

Node.js: json-server

• A utility for creating APIs, enabling quick demonstration and testing.
• It is developed in Node.js and expects a database in JSON format following a structure.

Example JSON Database

• Shows a JSON database structure for a music school, including students, courses, and instruments.

Dockerfile for json-server

• FROM node: Uses Node.js as the base image.
• WORKDIR /app: Sets the working directory.
• COPY db.json .: Copies the JSON database file.
• RUN npm install json-server -g: Installs json-server globally.
• EXPOSE 3000: Exposes port 3000.
• CMD ["json-server", "--watch", "db.json", "--port", "3000", "--host", "0.0.0.0"]: Starts the json-server with specified options.

Running json-server

• Commands to build, run and view the container logs are given

Orchestrating Multiple Services with Docker Compose

• Isolate an application into two services:
  • An API for student data
  • A service consuming the API and serving HTML pages
• The json-server is specified to feed the API.
• Orchestration combines this API with the application

Dockerfile for json-server

• FROM node
• WORKDIR /app
• COPY alunos.json .
• RUN npm install json-server -g
• EXPOSE 3000
• CMD ["json-server", "--watch", "alunos.json", "--port", "3000", "--host", "0.0.0.0"]

Dockerfile for the Application

• Uses the gAlunosExpress folder to build an image
• FROM node
• WORKDIR /usr/src/app
• COPY package*.json ./
• RUN npm install
• COPY . .
• EXPOSE 1103
• CMD [ "npm", "start" ]

Building Service Images

• Two Dockerfiles were used to construct two service images:
  • docker build . -t engweb2024/jserver_alunos
  • docker build . -t engweb2024/galunos --no-cache

Docker Compose

• Creates a dependence that the interface only starts when the data API is available

Docker Compose Configuration

• Specifies version 2 of the compose file format.
• Defines two services: web and jserver.
• web service configuration includes:
  • container_name: galunos-interface
  • image: engweb2024/galunos
  • ports: Maps host port 2804 to container port 1103
  • depends_on: Specifies dependency on the jserver service
  • links: Links to the jserver service
• jserver service configuration includes:
  • container_name: json-server
  • image: engweb2024/jserver_alunos

Running Services with Docker Compose

• Command to start the services: docker-compose up -d
• The application responds on port 2804.
• json-server is available internally as jserver instead of localhost.
• Service dependency ensures the interface starts after the data API is available.

Stopping Services

• Command to stop the services: docker-compose down

Node.js with MongoDB

Setting up the application

• Uses a Node.js application with data persistence in MongoDB.
• Requires a MongoDB server.
• A Dockerfile spec is not sufficient for this type of environment
• The approach requires a Docker Compose
• For Node:
  • Use the last image available on the Docker Hub

Dockerfile for the Node.js application

• FROM node
• WORKDIR /usr/src/app
• COPY package*.json ./
• RUN npm install
• COPY . .
• EXPOSE 2204
• CMD [ "npm", "start" ]

Docker Compose configuration for Node.js and MongoDB

• Uses version 2 of the compose file format.
• Defines two services: web and mongo.
• web service configuration includes:
  • container_name: gentregas-api
  • image: engweb2024/gentregas
  • ports: Maps host port 2804 to container port 2204
  • depends_on: Specifies dependency on the mongo service
  • links: Links to the mongo service
• mongo service configuration includes:
  • container_name: mongo-server
  • image: mongo

Decisions Made in the Specification

• Mapped application port 2204 to host port 2804.
• MongoDB is not exposed externally for security.
• Container dependency ensures the application starts after MongoDB is available, avoiding connection errors.
• Service orchestration requires an internal virtual network, created by default if not specified.