Changes between Version 2 and Version 3 of dockerdeployment2023

Timestamp:

Nov 14, 2023, 10:03:16 AM (12 months ago)

Author:

deepthi

Comment:

--

dockerdeployment2023

@@ -19 +19 @@
 
 4. Start and Enable Docker: Ensure Docker starts on boot.
+
 $ sudo systemctl enable docker
 $ sudo systemctl start docker
+
 5. Verify Docker Installation: Check the Docker version to ensure it's installed correctly.
+
 $ docker --version
 
 === 6. Deploying a Sample Web Application using Docker ===
+
 6.1 Pull a Sample Web Application Image: For this guide, we'll use a simple HTTP server image from Docker Hub.
+
 $ docker pull httpd
+
 6.2 Run the Web Application: Start a container using the httpd image. This will run the web server on port 8080.
+
 $ docker run -d -p 8080:80 --name sample-webapp httpd
+
 6.3 Access the Web Application: If you're accessing the server locally, open a web browser and navigate to: (Since you are connected via SSH lets install a text-based web browser lynx.)
+
 $ sudo apt-get install lynx
 $ lynx http://localhost:8080
+
 6.4 Stop and Remove the Web Application (Optional):
 When you're done testing the web application, you can stop and remove the container.
+
 $ docker stop sample-webapp
 $ docker rm sample-webapp
  
 Extra Ref:
+
 https://linuxhint.com/best_linux_text_based_browsers/
 https://romanzolotarev.com/ssh.html
  
 Basic Docker Commands and Their Usage
+
 •           docker --version
         Usage: Displays the Docker version installed.
         Example: docker --version
+
 •           docker info
         Usage: Provides detailed information about the Docker installation.
         Example: docker info
+
 •           docker pull <image_name>
         Usage: Downloads a Docker image from Docker Hub.
         Example: docker pull nginx
+
 •           docker build -t <image_name>:<tag> <path>
         Usage: Builds a Docker image from a Dockerfile located at <path>.
         Example: docker build -t myapp:latest .
+
 •           docker images
         Usage: Lists all available Docker images on the system.
         Example: docker images
+
 •           docker run <options> <image_name>
         Usage: Creates and starts a container from a Docker image.
         Example: docker run -d -p 80:80 nginx
+
 •           docker ps
         Usage: Lists running containers.
         Example: docker ps
+
 •           docker ps -a
         Usage: Lists all containers, including stopped ones.
         Example: docker ps -a
+
 •           docker stop <container_id/container_name>
         Usage: Stops a running container.
         Example: docker stop my_container
+
 •           docker rm <container_id/container_name>
         Usage: Removes a stopped container.
         Example: docker rm my_container
+
 •           docker rmi <image_name>
         Usage: Removes a Docker image.
         Example: docker rmi nginx
+
 •           docker logs <container_id/container_name>
         Usage: Displays logs from a running or stopped container.
@@ -80 +104 @@
  
 Troubleshooting Common Docker Container Issues
+
 •           Container Fails to Start
+
         Check Logs: Use docker logs <container_name> to check for any error messages.
         Inspect Configuration: Ensure that the Docker run command has the correct parameters, such as port mappings and volume mounts.
+
 •           Networking Issues
+
         Check IP Address: Use docker inspect <container_name> | grep IPAddress to find the container's IP address.
         Check Port Bindings: Ensure that the ports inside the container are correctly mapped to the host using the -p option.
         You may use docker port <container_name> to further check the port mapping.
+
 •           File or Directory Not Found in Container
+
         Check Volumes: Ensure that directories or files from the host are correctly mounted into the container using the -v option.
         You may use docker volume ls to list all volumes mapped and docker volume inspect  <volume_name> to inspect a selected volume.
         Inspect Image: Use docker image inspect <image_name> to see the image's layers and ensure the required files are present.
+
 •           Container Performance Issues
+
         Check Resources: Containers might face performance issues if they're not allocated enough resources. Use docker stats to check the resource usage of running containers.
         Limit Resources: When running a container, you can use flags like --cpus and --memory to limit its resources.
         You can use docker top <container_name> to see some stats.
+
 •           Image-Related Issues
+
         Pull Latest Image: Ensure you have the latest version of the image using docker pull <image_name>.
         Check Dockerfile: If you're building your own image, ensure that the Dockerfile has the correct instructions.
+
 •           Permission Issues
+
         User Mappings: If a containerized application can't access certain files, it might be a user permission issue. Ensure that the user inside the container has the necessary permissions.
         Use --user Flag: When running a container, you can specify which user the container should run as using the --user flag.
  
  
-Part 2:
+=== Part 2: ===
+
 What is a Dockerfile?
+
 A Dockerfile is a script containing a set of instructions used by Docker to automate the process of building a new container image. It defines the environment inside the container, installs necessary software, sets up commands, and more.
-Basic Structure of a Dockerfile
+
+==== Basic Structure of a Dockerfile ====
+
 A Dockerfile consists of a series of instructions and arguments. Each instruction is an operation used to build the image, like installing a software package or copying files. The instruction is written in uppercase, followed by its arguments.
+
 Key Dockerfile Instructions
+
     FROM: Specifies the base image to start from. It's usually an OS or another application.
         Example: FROM ubuntu:20.04
+
     LABEL: Adds metadata to the image, like maintainer information.
         Example: LABEL maintainer="name@example.com"
+
     RUN: Executes commands in a new layer on top of the current image and commits the result.
         Example: RUN apt-get update && apt-get install -y nginx
+
     CMD: Provides defaults for the executing container. There can only be one CMD instruction in a Dockerfile.
         Example: CMD ["nginx", "-g", "daemon off;"]
+
     ENTRYPOINT: Configures the container to run as an executable. It's often used in combination with CMD.
         Example: ENTRYPOINT ["nginx"]
+
     COPY: Copies files or directories from the host machine to the container.
         Example: COPY ./webapp /var/www/webapp
+
     ADD: Similar to COPY, but can also handle URLs and tarball extraction.
         Example: ADD https://example.com/app.tar.gz /app/
+
     WORKDIR: Sets the working directory for any subsequent RUN, CMD, ENTRYPOINT, COPY, and ADD instructions.
         Example: WORKDIR /app
+
     EXPOSE: Informs Docker that the container listens on the specified network port at runtime.
         Example: EXPOSE 80
+
     ENV: Sets environment variables.
         Example: ENV MY_VARIABLE=value
+
     VOLUME: Creates a mount point for external storage or other containers.
         Example: VOLUME /data
  
 Let's create a Dockerfile for a basic web server using Nginx:
+
 First, create a folder called my-webserver and go inside it cd my-webserver
 Then create another folder inside that called website and a file called index.html within the folder website with any content of your choice.
@@ -155 +208 @@
 
 Building an Image from a Dockerfile
+
 To build a Docker image from your Dockerfile, navigate to the directory containing the Dockerfile and run:
 docker build -t my-webserver:latest .
@@ -160 +214 @@
  
 Best Practices
+
 •       Minimize Layers: Try to reduce the number of layers in your image to make it lightweight. For instance, chain commands using && in a single RUN instruction.
 •       Use .dockerignore: Just like .gitignore, you can use .dockerignore to exclude files that aren't needed in the container.
@@ -165 +220 @@
 •       Clean Up: Remove temporary files and caches to reduce image size.
  
-Part 3:
+=== Part 3: ===
+
 What is Docker Compose?
+
 Docker Compose is a tool for defining and running multi-container Docker applications. With Compose, you can define a multi-container application in a single file, then spin up your application with a single command (docker-compose up).
+
 Key Concepts
+
     Services: Each container started by Docker Compose is a service. Services are defined in the docker-compose.yml file.
     Networks: By default, Docker Compose sets up a single network for your application. Each container for a service joins the default network and is discoverable via a hostname identical to the container name.
@@ -174 +233 @@
  
 Basic docker-compose Commands
+
 •           docker-compose up: Starts up the services defined in the docker-compose.yml file.
 •           docker-compose down: Stops and removes all the containers defined in the docker-compose.yml file.
@@ -180 +240 @@
  
 Deploying WordPress with Docker Compose
+
 Let's deploy a WordPress application using two containers: one for WordPress and another for the MySQL database.
 Create a docker-compose.yml file:
@@ -231 +292 @@
  
  
-Part 4:
+==== Part 4: ====
+
 Deploy any web app as per your wish and showcase its usage of it. You need to use more than one docker container eg: you can use three containers, one to run a web app and the others to run a database and other data storage respectively. You may use the docker hub to get any existing containers. What we evaluate is your ability to deploy the containers and bringing up a working web app.