{"id":11798,"date":"2019-03-17T11:02:23","date_gmt":"2019-03-17T11:02:23","guid":{"rendered":"http:\/\/www.appservgrid.com\/paw92\/?p=11798"},"modified":"2019-03-17T11:02:23","modified_gmt":"2019-03-17T11:02:23","slug":"install-docker-and-learn-basic-container-manipulation-in-centos-and-rhel-7-6","status":"publish","type":"post","link":"https:\/\/www.appservgrid.com\/paw92\/index.php\/2019\/03\/17\/install-docker-and-learn-basic-container-manipulation-in-centos-and-rhel-7-6\/","title":{"rendered":"Install Docker and Learn Basic Container Manipulation in CentOS and RHEL 7\/6"},"content":{"rendered":"

In this 3-article series, we will discuss about\u00a0Docker<\/strong>, is an open-source lightweight virtualization tool which runs at top of Operating System level, allowing users to create, run and deploy applications, encapsulated into small containers.<\/p>\n

\n

\"Install<\/a><\/p>\n

Install Docker and Learn Basic Container Manipulation \u2013 Part 1<\/p>\n<\/div>\n

This type of Linux containers are proven to be fast, portable and secure. The processes that run in a Docker container are always isolated from the main host, preventing outside tampering.<\/p>\n

Part 1<\/b>:\u00a0Install Docker and Learn Basic Container Manipulation in CentOS and RHEL 7\/6<\/b><\/div>\n
Part 2<\/b>:\u00a0How to Deploy and Run Applications into Docker Containers on CentOS\/RHEL 7\/6<\/a><\/div>\n
Part 3<\/b>:\u00a0Automatically Build and Configure Docker Images with Dockerfile on CentOS\/RHEL 7\/6<\/a><\/div>\n
Part 4<\/b>:\u00a0How to Monitor Docker Containers in Linux<\/a><\/div>\n

This tutorial provides a starting point on how to install Docker, create and run Docker containers on\u00a0CentOS\/RHEL 7\/6<\/strong>, but barley scratches the surface of Docker.<\/p>\n

Step 1: Install and Configure Docker<\/h3>\n

1.<\/strong>\u00a0Docker binaries are incorporated into\u00a0RHEL\/CentOS 7<\/strong>\u00a0extras repositories, the installation process being pretty simple. Install Docker package by issuing the following command with root privileges:<\/p>\n

Install Docker on RHEL and CentOS 7<\/h4>\n
# yum install docker\r\n<\/pre>\n
\n
\"Install<\/a><\/p>\n
Install Docker on CentOS and RHEL 7<\/p>\n<\/div>\n
Install Docker on RHEL and CentOS 6<\/h4>\n
To install Docker, the\u00a0Epel repositories<\/a>\u00a0must be enabled on your system by issuing the following command:<\/p>\n
# yum install epel-release\r\n# yum install docker-io\r\n<\/pre>\n
\n
\"Install<\/a><\/p>\n
Install Docker on RHEL and CentOS 6<\/p>\n<\/div>\n
2.<\/strong>\u00a0After, Docker package has been installed, start the daemon, check its status and enable it system wide using the below commands:<\/p>\n
On RHEL\/CentOS 7<\/h4>\n
# systemctl start docker \r\n# systemctl status docker\r\n# systemctl enable docker\r\n<\/pre>\n
\n
\"Enable<\/a><\/p>\n
Enable Docker on RHEL and CentOS 7<\/p>\n<\/div>\n
On RHEL\/CentOS 6<\/h4>\n
# service docker start\r\n# service docker status\r\n# chkconfig docker on\r\n<\/pre>\n
\n
\"Enable<\/a><\/p>\n
Enable Docker on RHEL and CentOS 6<\/p>\n<\/div>\n
3.<\/strong>\u00a0Finally, run a container test image to verify if Docker works properly, by issuing the following command:<\/p>\n
# docker run hello-world\r\n<\/pre>\n
If you can see the below message, then everything is in the right place.<\/p>\n
\"Hello from Docker. This message shows that your installation appears to be working correctly.\"<\/strong>\r\n<\/pre>\n
\n
\"Docker<\/a><\/p>\n
Docker Hello World<\/p>\n<\/div>\n
4.<\/strong>\u00a0Now, you can run a few basic Docker commands to get some info about Docker:<\/p>\n
For system-wide information on Docker<\/h6>\n
# docker info\r\n<\/pre>\n
\n
\"Check<\/a><\/p>\n
Check Docker Info<\/p>\n<\/div>\n
For Docker version<\/h6>\n
# docker version\r\n<\/pre>\n
\n
\"Check<\/a><\/p>\n
Check Docker Version<\/p>\n<\/div>\n
5.<\/strong>\u00a0To get a list of all available Docker commands type docker on your console.<\/p>\n
# docker\r\n<\/pre>\n
\n
\"List<\/a><\/p>\n
List Docker Commands<\/p>\n<\/div>\n
Step 2: Download a Docker Image<\/h3>\n
6.<\/strong>\u00a0In order to start and run a Docker container, first an image must be downloaded from\u00a0Docker Hub<\/a>\u00a0on your host. Docker Hub offers a great deal of free images from its repositories.<\/p>\n
To search for a Docker image, Ubuntu for instance, issue the following command:<\/p>\n
# docker search ubuntu\r\n<\/pre>\n
\n
\"Search<\/a><\/p>\n
Search Docker Images<\/p>\n<\/div>\n
7.<\/strong>\u00a0After you decided on what image you want to run based on your needs, download it locally by running the below command (in this case an\u00a0Ubuntu<\/strong>\u00a0image is downloaded and used):<\/p>\n
# docker pull ubuntu\r\n<\/pre>\n
\n
\"Download<\/a><\/p>\n
Download Docker Images<\/p>\n<\/div>\n
8.<\/strong>\u00a0To list all the available Docker images on your host issue the following command:<\/p>\n
# docker images\r\n<\/pre>\n
\n
\"List<\/a><\/p>\n
List Docker Images<\/p>\n<\/div>\n
9.<\/strong>\u00a0If you don\u2019t need a Docker image anymore and you want to remove it from the host issue the following command:<\/p>\n
# docker rmi ubuntu\r\n<\/pre>\n
\n
\"Remove<\/a><\/p>\n
Remove Docker Image<\/p>\n<\/div>\n
Step 3: Run a Docker Container<\/h3>\n
When you execute a command against an image you basically obtain a container. After the command that is executing into container ends, the container stops (you get a non-running or exited container). If you run another command into the same image again a new container is created and so on.<\/p>\n
All the containers created will remain on the host filesystem until you choose to delete them by using the\u00a0docker rm<\/code>\u00a0command.<\/p>\n
10.<\/strong>\u00a0In order to create and run a container, you need to run a command into a downloaded image, in this case\u00a0Ubuntu<\/strong>, so a basic command would be to display the distribution version file inside the container using\u00a0cat command<\/a>, as in the following example:<\/p>\n
# docker run ubuntu cat \/etc\/issue\r\n<\/pre>\n
\n
\"Run<\/a><\/p>\n
Run Docker Containers<\/p>\n<\/div>\n
The above command is divided as follows:<\/p>\n
# docker run [local image] [command to run into container]\r\n<\/pre>\n
11.<\/strong>\u00a0To run one of the containers again with the command that was executed to create it, first you must get the container\u00a0ID<\/strong>\u00a0(or the name automatically generated by Docker) by issuing the below command, which displays a list of the running and stopped (non-running) containers:<\/p>\n
# docker ps -l \r\n<\/pre>\n
\n
\"List<\/a><\/p>\n
List Running Docker Containers<\/p>\n<\/div>\n
12.<\/strong>\u00a0Once the container\u00a0ID<\/strong>\u00a0has been obtained, you can start the container again with the command that was used to create it, by issuing the following command:<\/p>\n
# docker start c629b7d70666\r\n<\/pre>\n
Here, the string\u00a0c629b7d70666<\/code>\u00a0represents the container\u00a0ID<\/strong>.<\/p>\n
\n
\"Start<\/a><\/p>\n
Start Docker Containers<\/p>\n<\/div>\n
13.<\/strong>\u00a0In case the container is running state, you can get it\u2019s\u00a0ID<\/strong>\u00a0by issuing\u00a0docker ps<\/code>\u00a0command. To stop the running container issue\u00a0docker stop<\/code>\u00a0command by specifying the container\u00a0ID<\/strong>\u00a0or auto-generated name.<\/p>\n
# docker stop dreamy_mccarthy\r\n# docker ps\r\n<\/pre>\n
\n
\"Start<\/a><\/p>\n
Start Stop Docker Containers<\/p>\n<\/div>\n
14.<\/strong>\u00a0A more elegant alternative so you don\u2019t have to remember the container\u00a0ID<\/strong>\u00a0would be to allocate a unique name for every container you create by using the\u00a0--name<\/code>\u00a0option on command line, as in the following example:<\/p>\n
# docker run --name myname  ubuntu cat \/etc\/debian_version\r\n<\/pre>\n
\n
\"Add<\/a><\/p>\n
Add Name to Docker Container<\/p>\n<\/div>\n
15.<\/strong>\u00a0Then, using the name that you allocated for the container, you can manipulate container (start<\/strong>,\u00a0stop<\/strong>,\u00a0remove<\/strong>,\u00a0top<\/strong>,\u00a0stats<\/strong>) further just by addressing its name, as in the below examples:<\/p>\n
# docker start myname\r\n# docker stats myname\r\n# docker top myname \r\n<\/pre>\n
Be aware that some of the above commands might display no output if the process of command that was used to create the container finishes. When the process that runs inside the container finishes, the container stops.<\/p>\n
Step 4: Run an Interactive Session into a Container<\/h3>\n
16.<\/strong>\u00a0In order to interactively connect into a container shell session, and run commands as you do on any other Linux session, issue the following command:<\/p>\n
# docker run -it ubuntu bash\r\n<\/pre>\n
\n
\"Start<\/a><\/p>\n
Start Docker Container Interactive Shell<\/p>\n<\/div>\n
The above command is divided as follows:<\/p>\n
    \n
  1. -i<\/code>\u00a0is used to start an interactive session.<\/li>\n
  2. -t<\/strong>\u00a0allocates a tty and attaches stdin and stdout.<\/li>\n
  3. ubuntu<\/code>\u00a0is the image that we used to create the container.<\/li>\n
  4. bash<\/code>\u00a0(or\u00a0\/bin\/bash<\/strong>) is the command that we are running inside the Ubuntu container.<\/li>\n<\/ol>\n
    17.<\/strong>\u00a0To quit and return to host from the running container session you must type\u00a0exit<\/code>\u00a0command. The\u00a0exit<\/strong>command terminates all the container processes and stops it.<\/p>\n
    # exit\r\n<\/pre>\n
    18.<\/strong>\u00a0If you\u2019re interactively logged on container terminal prompt and you need to keep the container in running state but\u00a0exit<\/strong>\u00a0from the interactive session, you can quit the console and return to host terminal by pressing\u00a0Ctrl+p<\/code>\u00a0and\u00a0Ctrl+q<\/code>\u00a0keys.<\/p>\n
    \n
    \"Keep<\/a><\/p>\n
    Keep Docker Shell Session Active<\/p>\n<\/div>\n
    19.<\/strong>\u00a0To reconnect to the running container you need the container\u00a0ID<\/strong>\u00a0or\u00a0name<\/strong>. Issue\u00a0docker ps<\/code>\u00a0command to get the\u00a0ID<\/strong>\u00a0or\u00a0name<\/strong>\u00a0and, then, run\u00a0docker attach<\/code>\u00a0command by specifying container\u00a0ID<\/strong>\u00a0or\u00a0name<\/strong>, as illustrated in the image above:<\/p>\n
    # docker attach <container id>\r\n<\/pre>\n
    20.<\/strong>\u00a0To stop a running container from the host session issue the following command:<\/p>\n
    # docker kill <container id>\r\n<\/pre>\n
    That\u2019s all for basic container manipulation. In the next tutorial we will discuss how to save, delete and run a web server into a Docker container.<\/p>\n
    Following the previous Docker article, this tutorial will discuss how to save a Docker container into a new image, remove a container and run a\u00a0Nginx<\/strong>\u00a0web server inside a container.<\/p>\n
    \n
    \"Install<\/a><\/p>\n
    Install and Run Applications in Docker Containers \u2013 Part 2<\/p>\n<\/div>\n
    Requirements<\/h4>\n
      \n
    1. Install Docker on CentOS and RHEL 7\/6<\/a><\/li>\n<\/ol>\n
      How To Run and Save a Docker Container<\/h3>\n
      1.<\/strong>\u00a0In this example we will run and save an\u00a0Ubuntu<\/strong>\u00a0based Docker container where\u00a0Nginx<\/strong>\u00a0server will be installed. But before committing any changes to container, first start the container with the below command which installs\u00a0Nginx<\/strong>\u00a0daemon into Ubuntu image:<\/p>\n
      # docker run ubuntu bash -c \"apt-get -y install nginx\" \r\n<\/pre>\n
      \n
      \"Install<\/a><\/p>\n
      Install Nginx on Ubuntu Docker Container<\/p>\n<\/div>\n
      2.<\/strong>\u00a0Next, after\u00a0Nginx<\/strong>\u00a0package is installed, issue the command\u00a0docker ps -l<\/code>\u00a0to get the\u00a0ID<\/strong>\u00a0or\u00a0name<\/strong>\u00a0of the running container.<\/p>\n
      # docker ps -l\r\n<\/pre>\n
      \n
      \"Find<\/a><\/p>\n
      Find Docker Container ID Name<\/p>\n<\/div>\n
      And apply changes by running the below command:<\/p>\n
      # docker commit 5976e4ae287c ubuntu-nginx<\/pre>\n
      Here,\u00a05976e4ae287c<\/code>\u00a0represents the container\u00a0ID<\/code>\u00a0and\u00a0ubuntu-nginx<\/code>\u00a0represents the name of the newly image that has been saved with committed changes.<\/p>\n
      In order to view if the new image has been successfully created just run\u00a0docker images<\/code>\u00a0command and a listing of all saved images will be shown.<\/p>\n
      # docker images\r\n<\/pre>\n
      \n
      \"Docker<\/a><\/p>\n
      Docker Container Changes<\/p>\n<\/div>\n
      Chances are that the installation process inside the container finishes fast which leads to a non-running container (container is stopped). In this case the\u00a0docker ps<\/code>\u00a0command won\u2019t show any output because no container is running.<\/p>\n
      In order to be able to still get the container\u2019s id run\u00a0docker ps -a | head -3<\/code>\u00a0to output the most recent containers and identify the container based on the command issued to create the container and the exited status.<\/p>\n
      \n
      3.<\/strong>\u00a0Alternatively, you can actively enter container session by running\u00a0docker run -it ubuntu bash<\/code>command and execute further\u00a0apt-get install nginx<\/code>\u00a0command. While the command is running, detach from the container using\u00a0Ctrl-p + Ctrl-q<\/code>\u00a0keys and the container will continue running even if the Nginx installation process finishes.<\/p>\n
      # docker run -it ubuntu bash\r\n# apt-get install nginx\r\n<\/pre>\n
      \n
      \"Install<\/a><\/p>\n
      Install Nginx on Docker Container<\/p>\n<\/div>\n
      Then, get the running container id with\u00a0docker ps<\/code>\u00a0and commit changes. When finished, re-enter to container console using\u00a0docker attach<\/code>\u00a0and type\u00a0exit<\/code>\u00a0to stop container.<\/p>\n
      # docker ps\r\n# docker attach 3378689f2069\r\n# exit\r\n<\/pre>\n
      \n
      \"Attach<\/a><\/p>\n
      Attach Docker Container<\/p>\n<\/div>\n
      4.<\/strong>\u00a0To further test if the recently image has been committed properly (in this case\u00a0Nginx<\/strong>\u00a0service has been installed), execute the below command in order to generate a new container which will output if Nginx binary was successfully installed:<\/p>\n
      # docker run ubuntu-nginx whereis nginx\r\n<\/pre>\n
      \n
      \"Generate<\/a><\/p>\n
      Generate New Docker Container<\/p>\n<\/div>\n
      5.<\/strong>\u00a0To remove a container use the\u00a0rm<\/code>\u00a0command against a container ID or name, which can be obtained using\u00a0docker ps -a<\/code>\u00a0command:<\/p>\n
      # docker ps -a\r\n# sudo docker rm 36488523933a\r\n<\/pre>\n
      \n
      \"Remove<\/a><\/p>\n
      Remove Docker Container<\/p>\n<\/div>\n
      How to Run Nginx inside Docker Container<\/h3>\n
      6.<\/strong>\u00a0In this part we will concentrate on how you can run and access a network service, such as a\u00a0Nginx<\/strong>\u00a0web server, inside Docker, using the\u00a0ubuntu-nginx<\/code>\u00a0image created earlier where Nginx daemon was installed.<\/p>\n
      The first thing that you need to do is to create a new container, map host-container ports and enter container shell by issuing the below command:<\/p>\n
      # docker run -it -p 81:80 ubuntu-nginx \/bin\/bash\r\n# nginx &\r\n<\/pre>\n
      Here, the\u00a0-p<\/code>\u00a0option exposes the host port to container port. While the host port can be arbitrary, with the condition that it should be available (no other host services should listen on it), the container port must be exactly the port that the inside daemon is listening to.<\/p>\n
      Once you\u2019re connected to container session, start\u00a0Nginx<\/strong>\u00a0daemon in background and detach from container console by pressing\u00a0Ctrl-p + Ctrl-q<\/code>\u00a0keys.<\/p>\n
      \n
      \"Run<\/a><\/p>\n
      Run Nginx Inside Docker Container<\/p>\n<\/div>\n
      7.<\/strong>\u00a0Now, run\u00a0docker ps<\/code>\u00a0to get the state of your running container. You can also view host network sockets by issuing the following command:<\/p>\n
      # docker ps\r\nOR\r\n# netstat -tlpn \r\n<\/pre>\n
      \n
      \"View<\/a><\/p>\n
      View Docker Container Running State<\/p>\n<\/div>\n
      8.<\/strong>\u00a0In order to visit the page served by the Nginx container, open a browser from a remote location in your LAN and type the IP address of your machine using the HTTP protocol.<\/p>\n
      \n
      \"Verify<\/a><\/p>\n
      Verify Nginx Running under Docker Container<\/p>\n<\/div>\n
      9.<\/strong>\u00a0To stop the container run the following command followed by container ID or name:<\/p>\n
      # docker ps\r\n# docker stop fervent_mccarthy\r\n# docker ps\r\n<\/pre>\n
      \n
      \"Stop<\/a><\/p>\n
      Stop Running Docker Container<\/p>\n<\/div>\n
      As alternative to stop the running container, enter container shell command prompt and type exit to finish process:<\/p>\n
      # docker attach fervent_mccarthy\r\n# exit\r\n<\/pre>\n
      Be aware that using this kind of containers to run web servers or other kind of services are best suited only for development purposes or tests due to the fact that the services are only active while the container is running. Exiting the container disrupts all running services or any changes made.<\/p>\n
      This tutorial will concentrate on how to build a custom Docker image based on\u00a0Ubuntu<\/strong>\u00a0with\u00a0Apache<\/strong>\u00a0service installed. The whole the process will be automated using a\u00a0Dockerfile<\/strong>.<\/p>\n
      \n
      \"Build<\/a><\/p>\n
      Build Configure Docker Images with Dockerfile \u2013 Part 3<\/p>\n<\/div>\n
      Docker images can be automatically build form text files, named\u00a0Dockerfiles<\/strong>. A Docker file contains step-by-step ordered instructions or commands used to create and configure a Docker image.<\/p>\n
      Requirements<\/h4>\n
        \n
      1. Install Docker and Learn Docker Container Manipulation \u2013 Part 1<\/a><\/li>\n
      2. Deploy and Run Applications under Docker Containers \u2013 Part 2<\/a><\/li>\n<\/ol>\n
        Basically, a Docker file contains various instructions in order to build and configure a specific container based on your requirements. The following instructions are the most used, some of them being mandatory:<\/p>\n
          \n
        1. FROM<\/code>\u00a0= Mandatory as first instruction in a Docker file. Instructs Docker to pull the base image from which you are building the new image. Use a tag to specify the exact image from which you are building:<\/li>\n<\/ol>\n
          Ex: FROM ubuntu:14.04\r\n<\/pre>\n
            \n
          1. MAINTAINER<\/code>\u00a0= Author of the build image<\/li>\n
          2. RUN<\/code>\u00a0= This instruction can be used on multiple lines and runs any commands after Docker image has been created.<\/li>\n
          3. CMD<\/code>\u00a0= Run any command when Docker image is started. Use only one CMD instruction in a Dockerfile.<\/li>\n
          4. ENTRYPOINT<\/code>\u00a0= Same as CMD but used as the main command for the image.<\/li>\n
          5. EXPOSE<\/code>\u00a0= Instructs the container to listen on network ports when running. The container ports are not reachable from the host by default.<\/li>\n
          6. ENV<\/code>\u00a0= Set container environment variables.<\/li>\n
          7. ADD<\/code>\u00a0= Copy resources (files, directories or files from URLs).<\/li>\n<\/ol>\n
            Step 1: Creating or Writing Dockerfile Repository<\/h3>\n
            1.<\/strong>\u00a0First, let\u2019s create some kind of\u00a0Dockerfile<\/strong>\u00a0repositories in order to reuse files in future to create other images. Make an empty directory somewhere in\u00a0\/var<\/code>\u00a0partition where we will create the file with the instructions that will be used to build the newly Docker image.<\/p>\n
            # mkdir -p \/var\/docker\/ubuntu\/apache\r\n# touch \/var\/docker\/ubuntu\/apache\/Dockerfile\r\n<\/pre>\n
            \n
            \"Create<\/a><\/p>\n
            Create Dockerfile Repository<\/p>\n
            2.<\/strong>\u00a0Next, start editing the file with the following instructions:<\/p>\n
            # vi \/var\/docker\/ubuntu\/apache\/Dockerfile\r\n<\/pre>\n
            Dokerfile excerpt:<\/p>\n
            FROM ubuntu\r\nMAINTAINER  your_name  <user@domain.tld>\r\nRUN apt-get -y install apache2\r\nRUN echo \u201cHello Apache server on Ubuntu Docker\u201d > \/var\/www\/html\/index.html\r\nEXPOSE 80\r\nCMD \/usr\/sbin\/apache2ctl -D FOREGROUND\r\n<\/pre>\n
            \n
            \"Dockerfile<\/a><\/p>\n
            Dockerfile Repository<\/p>\n<\/div>\n
            Now, let\u2019s go through the file instructions:<\/p>\n
            The first line tells us that we are building from an\u00a0Ubuntu<\/strong>\u00a0image. If no tag is submitted, say\u00a014:10<\/strong>\u00a0for example, the latest image from\u00a0Docker Hub<\/strong>\u00a0is used.<\/p>\n
            On the second line we\u2019ve added the\u00a0name<\/strong>\u00a0and\u00a0email<\/strong>\u00a0of the image creator. Next two\u00a0RUN<\/strong>\u00a0lines will be executed in the container when building the image and will install\u00a0Apache<\/strong>\u00a0daemon and\u00a0echo<\/strong>\u00a0some text into default apache web page.<\/p>\n
            The\u00a0EXPOSE<\/strong>\u00a0line will instruct\u00a0Docker<\/strong>\u00a0container to listen on port\u00a080<\/strong>, but the port will be not available to outside. The last line instructs the container to run Apache service in foreground after the container is started.<\/p>\n
            3.<\/strong>\u00a0The last thing we need to do is to start creating the image by issuing the below command, which will locally create a new Docker image named\u00a0ubuntu-apache<\/code>\u00a0based on the Dockerfile created earlier, as shown in this example:<\/p>\n
            # docker build -t ubuntu-apache \/var\/docker\/ubuntu\/apache\/\r\n<\/pre>\n
            \n
            \"Create<\/a><\/p>\n
            Create Docker Image<\/p>\n<\/div>\n
            4.<\/strong>\u00a0After the image has been created by\u00a0Docker<\/strong>, you can list all available images and identify your image by issuing the following command:<\/p>\n
            # docker images\r\n<\/pre>\n
            \n
            \"List<\/a><\/p>\n
            List All Docker Images<\/p>\n<\/div>\n
            Step 2: Run the Container and Access Apache from LAN<\/h3>\n
            5.<\/strong>\u00a0In order to run the container continuously (in background) and access the container exposed services (ports) from the host or other remote machine in your LAN, run the below command on your host terminal prompt:<\/p>\n
            # docker run -d -p 81:80 ubuntu-apache\r\n<\/pre>\n
            \n
            \"Run<\/a><\/p>\n
            Run Docker Container Image<\/p>\n<\/div>\n
            Here, the\u00a0-d<\/code>\u00a0option runs the\u00a0ubuntu-apache<\/code>\u00a0container in background (as a daemon) and the\u00a0-p<\/code>\u00a0option maps the container port\u00a080<\/strong>\u00a0to your localhost port\u00a081<\/strong>. Outside LAN access to Apache service can be reached through port\u00a081<\/strong>\u00a0only.<\/p>\n
            Netstat command<\/a>\u00a0will give you an idea about what ports the host is listening to.<\/p>\n
            After the container has been started, you can also run\u00a0docker ps<\/code>\u00a0command to view the status of the running container.<\/p>\n
            6.<\/strong>\u00a0The webpage can be displayed on your host from command line using\u00a0curl<\/strong>\u00a0utility against your machine IP Address, localhost or docker net interface on port 81. Use\u00a0ip command<\/a>\u00a0line to show network interface IP addresses.<\/p>\n
            # ip addr               [List nework interfaces]\r\n# curl ip-address:81    [System Docker IP Address]\r\n# curl localhost:81     [Localhost]\r\n<\/pre>\n
            \n
            \"Check<\/a><\/p>\n
            Check Docker Network Interface and IP Address<\/p>\n<\/div>\n
            \n
            \"Check<\/a><\/p>\n
            Check Docker Apache Webpage<\/p>\n<\/div>\n
            7.<\/strong>\u00a0To visit the container webpage from your network, open a browser at remote location and use HTTP protocol, the IP Address of the machine where the container is running, followed by port 81 as illustrated on below image.<\/p>\n
            http:\/\/ip-address:81\r\n<\/pre>\n
            \n
            \"Check<\/a><\/p>\n
            Check Docker Container Apache Page<\/p>\n<\/div>\n
            8.<\/strong>\u00a0To get an inside of what processes are running inside the container issue the following command:<\/p>\n
            # docker ps\r\n# docker top <name or ID of the container>\r\n<\/pre>\n
            \n
            \"Check<\/a><\/p>\n
            Check Running Docker Processes<\/p>\n<\/div>\n
            9.<\/strong>\u00a0To stop the container issue\u00a0docker stop<\/code>\u00a0command followed by the container ID or name.<\/p>\n
            # docker stop <name or ID of the container>\r\n# docker ps\r\n<\/pre>\n
            10.<\/strong>\u00a0In case you want to assign a descriptive name for the container use the\u00a0--name<\/code>\u00a0option as shown in the below example:<\/p>\n
            # docker run --name my-www -d -p 81:80 ubuntu-apache\r\n# docker ps\r\n<\/pre>\n
            \n
            \"Give<\/a><\/p>\n
            Give Docker Container Name<\/p>\n<\/div>\n
            Now you can reference the container for manipulation (start, stop, top, stats etc) only by using the assigned name.<\/p>\n
            # docker stats my-www\r\n<\/pre>\n
            \n
            \"Monitor<\/a><\/p>\n
            Monitor Docker Container Utilization<\/p>\n<\/div>\n
            Step 3: Create a System-wide Configuration File for Docker Container<\/h3>\n
            11.<\/strong>\u00a0On\u00a0CentOS\/RHEL 7<\/strong>\u00a0you can create a\u00a0systemd<\/strong>\u00a0configuration file and manage the container as you normally do for any other local service.<\/p>\n
            For instance, create a new systemd file named, let\u2019s say,\u00a0apache-docker.service<\/code>\u00a0using the following command:<\/p>\n
            # vi \/etc\/systemd\/system\/apache-docker.service\r\n<\/pre>\n
            apache-docker.service<\/strong>\u00a0file excerpt:<\/p>\n
            [Unit]\r\nDescription=apache container\r\nRequires=docker.service\r\nAfter=docker.service\r\n\r\n[Service]\r\nRestart=always\r\nExecStart=\/usr\/bin\/docker start -a my-www\r\nExecStop=\/usr\/bin\/docker stop -t 2 my-www\r\n\r\n[Install]\r\nWantedBy=local.target\r\n<\/pre>\n
            12.<\/strong>\u00a0After you finish editing the file, close it, reload the systemd daemon to reflect changes and start the container by issuing the following commands:<\/p>\n
            # systemctl daemon-reload\r\n# systemctl start apache-docker.service\r\n# systemctl status apache-docker.service\r\n<\/pre>\n
            This was just a simple example on what you can do with a simple\u00a0Dockerfile<\/strong>\u00a0but you can pre-build some pretty sophisticated applications that you can fire-up in just a matter of seconds with minimal resources and effort.<\/p>\n
            ctop \u2013 Top-like Interface for Monitoring Docker Containers<\/h1>\n
            ctop<\/strong>\u00a0is a free open source, simple and cross-platform\u00a0top-like command-line tool<\/a>\u00a0for monitoring container metrics in real-time. It allows you to get an overview of metrics concerning CPU, memory, network, I\/O for multiple containers and also supports inspection of a specific container.<\/p>\n
            \n
            \"Docker<\/a><\/p>\n
            Docker Container Monitoring<\/p>\n<\/div>\n
            At the time of writing this article, it ships with built-in support for\u00a0Docker<\/a>\u00a0(default container connector) and\u00a0runC<\/strong>; connectors for other container and cluster platforms will be added in future releases.<\/p>\n
            How to Install ctop in Linux Systems<\/h3>\n
            Installing the latest release of\u00a0ctop<\/strong>\u00a0is as easy as running the following commands to download the binary for your Linux distribution and install it under\u00a0\/usr\/local\/bin\/ctop<\/strong>\u00a0and make it executable to run it.<\/p>\n
            $ sudo wget https:\/\/github.com\/bcicen\/ctop\/releases\/download\/v0.7.1\/ctop-0.7.1-linux-amd64  -O \/usr\/local\/bin\/ctop\r\n$ sudo chmod +x \/usr\/local\/bin\/ctop\r\n<\/pre>\n
            Alternatively, install\u00a0ctop<\/strong>\u00a0via Docker using following command.<\/p>\n
            $ docker run --rm -ti --name=ctop -v \/var\/run\/docker.sock:\/var\/run\/docker.sock quay.io\/vektorlab\/ctop:latest\r\n<\/pre>\n
            Once you have installed\u00a0ctop<\/strong>, you can run it to list all your containers whether active or not.<\/center><\/p>\n
            $ ctop\r\n<\/pre>\n
            \n
            \"Monitor<\/a><\/p>\n
            Monitor Docker Containers<\/p>\n<\/div>\n
            You can use the\u00a0Up<\/strong>\u00a0and\u00a0Down<\/strong>\u00a0arrow keys to highlight a container and click\u00a0Enter<\/strong>\u00a0to select it. You will see a menu as shown in the following screenshot. Choose\u00a0\u201csingle view\u201d<\/strong>\u00a0and click on it to inspect the selected container.<\/p>\n
            \n
            \"Monitor<\/a><\/p>\n
            Monitor Single Docker Container<\/p>\n<\/div>\n
            The following screenshot shows the single view mode for a specific container.<\/p>\n
            \n
            \"Inspect<\/a><\/p>\n
            Inspect a Single Container<\/p>\n<\/div>\n
            To display active containers only, use the\u00a0-a<\/code>\u00a0flag.<\/p>\n
            $ ctop -a \r\n<\/pre>\n
            \n
            \"Check<\/a><\/p>\n
            Check Active Docker Container<\/p>\n<\/div>\n
            To display CPU as\u00a0%<\/code>\u00a0of system total, use the\u00a0-scale-cpu<\/code>\u00a0option.<\/p>\n
            $ ctop -scale-cpu\r\n<\/pre>\n
            You can also filter containers using the\u00a0-f<\/code>\u00a0flag, for example.<\/p>\n
            $ ctop -f app\r\n<\/pre>\n
            Additionally, you can select initial container sort field using the\u00a0-s<\/code>\u00a0flag, and see the\u00a0ctop<\/strong>\u00a0help message as shown.<\/p>\n
             \r\n$ ctop -h\r\n<\/pre>\n
            Note that connectors for other container and cluster systems are yet to be added to\u00a0ctop<\/strong>. You can find more information from the\u00a0Ctop Github repository<\/a>.<\/p>\n
            ctop<\/strong>\u00a0is a simple top-like tool for visualizing and monitoring container metrics in real-time. In this article, we\u2019ve expalined how to install and use ctop in Linux. You can share your thoughts or ask any questions via the comment form below.<\/p>\n
            Source<\/a><\/p>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
            In this 3-article series, we will discuss about\u00a0Docker, is an open-source lightweight virtualization tool which runs at top of Operating System level, allowing users to create, run and deploy applications, encapsulated into small containers. Install Docker and Learn Basic Container Manipulation \u2013 Part 1 This type of Linux containers are proven to be fast, portable … <\/p>\n
            Continue reading “Install Docker and Learn Basic Container Manipulation in CentOS and RHEL 7\/6”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-11798","post","type-post","status-publish","format-standard","hentry","category-linux"],"_links":{"self":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/11798","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/comments?post=11798"}],"version-history":[{"count":1,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/11798\/revisions"}],"predecessor-version":[{"id":11799,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/11798\/revisions\/11799"}],"wp:attachment":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/media?parent=11798"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/categories?post=11798"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/tags?post=11798"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}