Briefly, I will tell you that Docker compose is more thought of production environments where compatibility should be as high as possible. This is precisely the great advantage of Docker images that we will be able to use in any supported system thanks to the technology of containers. Then, these steps can be done from any Linux distribution that has installed Docker and Docker Compose.

ArangoDB is a native multi-model, open-source database with flexible data models for documents, graphs, and key-values. Build high-performance applications using a convenient SQL-like query language or JavaScript extensions. Use ACID transactions if you require them. Scale horizontally and vertically with a few mouse clicks.

So, let us start.

Install Docker and Docker Compose on Linux

The first step is to have Docker installed in the system, obviously.

• If you are using Ubuntu: How to install Docker on Ubuntu 18.04?
• For CentOS 8: How to install Docker on CentOS 8?
• For CentOS 7: How to install Docker CE on CentOS 7?
• If you use Windows: How to install Docker in Windows 10?
• Or, if you are using Debian 10: How to install Docker on Debian 10?

And using your distribution’s package manager, you can install Docker Compose. For example:

:~$ sudo apt docker-compose

For Debian, Ubuntu, and derivatives.

:~$ sudo dnf install docker-compose

Or, for RHEL, CentOS and derivatives.

Deploy ArangoDB using Docker Compose

First, I will create a folder called arangodb and within it a file called docker-compose.yml which is where we will add the instructions.

:~$ mkdir arangodb
:~$ cd arangodb

Now we’ll create the docker-compose file and add the following:

:~$ nano docker-compose.yml

version: '3.1'
 services:
 arangodb:
     image: arangodb:latest
     restart: always
     ports:
       - 1234:8529
     environment:
       ARANGO_ROOT_PASSWORD: angelo123osradar
     volumes:
       - /home/angelo/arangodb_data:/var/lib/arangodb3

Now we proceed to explain. First, I’m using the latest version of ArangoDB. Then, I expose port 8529 which is the image port to 1234 of our host system. You can use another port if you want.

On the other hand, in the environment section, I define an initial password for the root user. And a volume to access the container data. I have chosen /home/angelo/arangodb_data but you choose the one you want. Remember that before you raise the image you must create it.

Then, create the data folder and start the deployment.

:~$ mkdir/home/angelo/arangodb_data

:~$ sudo docker-compose up -d

When you finish, you can access the ArangoDB web interface. Open your browser and go to http://your-server:1234. You will see the following:

Then, type your credentials. Keep in mind that the default user is root. After that, you will see this:

Finally, you will see the dashboard.

And that is it.

Conclusion

ArangoDB is a NoSQL database manager quite important in the current market. Deploying ArangoDB using Docker compose is simple but with many options available.

If you want more information, I recommend you to visit the official documentation of the image.

The post How to deploy ArangoDB using Docker Compose? appeared first on Linux Windows and android Tutorials.

Briefly, I will tell you that Docker compose is more thought of production environments where compatibility should be as high as possible. This is precisely the great advantage of Docker images that we will be able to use in any supported system thanks to the technology of containers. Then, these steps can be done from any Linux distribution that has installed Docker and Docker Compose.

Owncloud is one of the best-known solutions to create our own private cloud as if it were a professional service. Of course, by this I do not mean that Owncloud is not professional, I mean that its behavior is similar to that of proprietary solutions such as Google Drive or OneDrive.

So let’s get to work.

Install Docker and Docker Compose on Linux

The first step is to have Docker installed in the system, obviously.

• If you are using Ubuntu: How to install Docker on Ubuntu 18.04?
• For CentOS 8: How to install Docker on CentOS 8?
• For CentOS 7: How to install Docker CE on CentOS 7?
• If you use Windows: How to install Docker in Windows 10?
• Or, if you are using Debian 10: How to install Docker on Debian 10?

And using your distribution’s package manager, you can install Docker Compose. For example:

:~$ sudo apt docker-compose

For Debian, Ubuntu, and derivatives.

:~$ sudo dnf install docker-compose

Or, for RHEL, CentOS and derivatives.

Deploy Owncloud using Docker compose

Well, the first step is to create a new folder where we will do the process.

:~$ mkdir owncloud
:~$ cd owncloud

Then, in that folder create a new file called docker-compose.yml that contains all the instructions for deployment. When you create it, add the following:

:~$ sudo nano docker-compose.yml

version: '3.1'

services:

  owncloud:
    image: owncloud
    restart: always
    ports:
      - 1234:80
    volumes:
      - /home/angelo/owncloud_data:/var/www/html
      - /home/angelo/owncloud_data/apps:/var/www/html/apps
      - /home/angelo/owncloud_data/config:/var/www/html/config
      - /home/angelo/owncloud_data/data:/var/www/html/data

  db:
    image: mariadb
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: angelo123

I proceed to explain.

In this file, we will raise two services. The first is the Owncloud. The image is configured for Owncloud to run on port 80, but I exposed port 1234. You can set the number you want but don’t touch 80.

Then come the volumes. The first part is folders on our host system to make sure the data is persistent. These folders must be created before the services are deployed.

After this, comes the second service. By default, the Owncloud image is configured to use SQLite. But in this case, we have decided to use MariaDB. All simple just set up an initial key and you’re done.

Let us create the volume folders.

:~$ mkdir /home/angelo/owncloud_data
:~$ mkdir /home/angelo/owncloud_data/apps
:~$ mkdir /home/angelo/owncloud_data/config
:~$ mkdir /home/angelo/owncloud_data/data

Then, run Docker Compose.

:~$ sudo docker-compose up -d

That’s enough. Now open your web browser and go to http://your-server:1234 and you will see the following. Create an admin account.

Next, configure the Database.

Finally, you’ll see the login screen and you are done. You can now use Owncloud.

Conclusion

Owncloud is a really useful application. And to deploy it using Docker compose is something easy and within everyone’s reach.

For more information on this, see the official documentation of the Owncloud Docker image.

The post Deploy owncloud using Docker compose appeared first on Linux Windows and android Tutorials.

Briefly, I will tell you that Docker compose is more thought of production environments where compatibility should be as high as possible. This is precisely the great advantage of Docker images that we will be able to use in any supported system thanks to the technology of containers. Then, these steps can be done from any Linux distribution that has installed Docker and Docker Compose.

Remember that it is always possible to install MySQL on a server using your precompiled packages, we can easily have the latest version available.

For this tutorial, apart from MySQL, we will also deploy Adminer that we talked about earlier. Together you will be able to manage a MySQL server without problems.

So let’s get to work.

Install Docker and Docker Compose on Linux

The first step is to have Docker installed in the system, obviously.

• If you are using Ubuntu: How to install Docker on Ubuntu 18.04?
• For CentOS 8: How to install Docker on CentOS 8?
• For CentOS 7: How to install Docker CE on CentOS 7?
• If you use Windows: How to install Docker in Windows 10?
• Or, if you are using Debian 10: How to install Docker on Debian 10?

And using your distribution’s package manager, you can install Docker Compose. For example:

:~$ sudo apt docker-compose

For Debian, Ubuntu and derivatives.

:~$ sudo dnf install docker-compose

Or, for RHEL, CentOS and derivatives.

Deploy MySQL using Docker Compose

Well, it’s time to work. First create a folder called mysql and access it.

:~$ mkdir mysql
:~$ cd mkdir

Inside it, we will create the docker compose file called docker-compose.yml.

:~$ nano docker-compose.yml

Once you have created the file, you need to add the following content:

version: '3.1'

services:

  db:
    image: mysql:latest
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: angelo123
      MYSQL_DATABASE: example
      MYSQL_USER: angelo
      MYSQL_PASSWORD: angelo123
    volumes:
      /home/angelo/mysqldata:/var/lib/mysql

  adminer:
    image: adminer
    restart: always
    ports:
      - 8080:8080

I now proceed to explain briefly.

First, we deploy a service called db that contains the information to install MySQL. First, we use the image of the latest version of MySQL. Inside the environment section we define the necessary variables to start the service. In this section, you define things like the password of the root user, the regular user and the user name as well as the name of the initial database.

An important aspect is the volume that allows us to have access to the database in the host system. This folder must be created before the execution of the file.

In the end, we deploy Adminer using port 8080, obviously you can change this.

So, create the volume folder:

:~$ mkdir /home/angelo/mysqldata

Then, run Docker Compose.

:~$ sudo docker-compose up -d

So, now you can open your favorite web browser and go to http://your-server:8080 to access Adminer. Remember that port has to be open in the firewall.

Now, type in your MySQL credentials and log in. These are the ones we define in the Docker compose file.

And that is it.

Conclusion

Docker is a technology with enormous potential. It helps a lot in the deployment of applications without many dependency problems. Today in this tutorial we have deployed MySQL and Adminer without many problems.

For more information about the use of the MySQL image, please consult the official documentation.

The post Deploy MySQL using Docker Compose appeared first on Linux Windows and android Tutorials.

I have to admit that these last days I have liked much more the technology of Docker compose. It seems a very simple and fast way to install certain applications. However, from my point of view, a bit of flexibility is lost in the configurations since they are images already created from a base. Of course, we will be able to configure some things but not everything.

Well, PHPMyAdmin is an application that is quite easy to install in Linux because it is available in most of the official refuels of the distributions. However, installing the latest version available from its source code may frighten some users. So this is a good way to install it.

Briefly, I will tell you that Docker compose is more thought of production environments where compatibility should be as high as possible. This is precisely the great advantage of Docker images that we will be able to use in any supported system thanks to the technology of containers. Then, these steps can be done from any Linux distribution that has installed Docker and Docker Compose.

So, let us start.

Install Docker and Docker Compose on Linux

The first step is to have Docker installed in the system, obviously.

• If you are using Ubuntu: How to install Docker on Ubuntu 18.04?
• For CentOS 8: How to install Docker on CentOS 8?
• For CentOS 7: How to install Docker CE on CentOS 7?
• If you use Windows: How to install Docker in Windows 10?
• Or, if you are using Debian 10: How to install Docker on Debian 10?

And using your distribution’s package manager, you can install Docker Compose. For example:

:~$ sudo apt docker-compose

For Debian, Ubuntu and derivatives.

:~$ sudo yum install docker-compose

Or, for RHEL, CentOS and derivatives.

Install PHPMyAdmin using Docker Compose

The official PHPMyAdmin image requires the MySQL or MariaDB image to be installed. Anyway, in the docker-compose file, I will also add it in case you do not have it installed.

First, I will create a new folder and within it I will create the docker-compose.yml file.

:~$ mkdir phpmyadmin
:~$ cd phpmyadmin

Then, create the file and add the following:

:~$ nano docker-compose.yml

version: '2'

  volumes:
    db:

  services:
    db:
      image: mariadb
      command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW
      restart: always
      volumes:
        - db:/var/lib/mysql
      environment:
        - MYSQL_ROOT_PASSWORD=1234osradar
        - MYSQL_PASSWORD=1234osradar
        - MYSQL_DATABASE=example    
        - MYSQL_USER=osradar
  app:
     image: phpmyadmin/phpmyadmin
     container_name: phpmyadmin
     environment:
      - PMA_ARBITRARY=1
     restart: always
     links:
      - db
     ports:
      - 8080:80
     volumes:
      - /sessions

Save the changes and close the file.

The file itself is explicit but we are going to explain the most important parts. In the image we can see that we will try to raise two services: one is mariadb and the other PHPMyAdmin.

First we configure MariaDB that will work as the database manager. And we configured the environment variables that will allow us to define the password of the root user, the normal user and the user name.

In the case of PHPMyAdmin is even simpler because by default only requires that we specify within the environment if it is an arbitrary host. Then, we define the port where we will have access, in this case, I left the 8080. All better explained in the official documentation of the PHPMyAdmin image.

Finally, run docker compose to install PHPMyAdmin.

:~$ sudo docker-compose up -d

Then, we will be able to access from our browser using the IP address of the server or the domain name with port 8080 that we specify. Then, log in with your credentials:

Finally you will see the main screen.

So, that is it.

Conclusion

In a production server, we look very much for the productivity and compatibility of the applications. In this sense, using Docker images guarantees compatibility and ease of use. Today, you have learned how to install PHPMyAdmin using this technology and we will be able to realize how simple it is.

The post Deploy PHPMyAdmin using Docker Compose appeared first on Linux Windows and android Tutorials.

Install Docker and Docker Compose on Linux

The first step is to have Docker installed in the system, obviously.

• If you are using Ubuntu: How to install Docker on Ubuntu 18.04?
• For CentOS 8: How to install Docker on CentOS 8?
• For CentOS 7: How to install Docker CE on CentOS 7?
• If you use Windows: How to install Docker in Windows 10?
• Or, if you are using Debian 10: How to install Docker on Debian 10?

And using your distribution’s package manager, you can install Docker Compose. For example:

:~$ sudo apt docker-compose

For Debian, Ubuntu and derivatives.

:~$ sudo yum install docker-compose

Or, for RHEL, CentOS and derivatives.

Install Nextcloud using Docker compose

Now that we have our environment ready, let us create a folder called nextcloud and navigate there to then create the docker-compose.yml file.

:~$ mkdir nextcloud && cd nextcloud

Now we will create the file with the following content.

:~$ nano docker-compose.yml

version: '2'
 volumes:
   nextcloud:
   db:
   data:
 services:
   db:
     image: mariadb
     command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW
     restart: always
     volumes:
       - db:/var/lib/mysql
     environment:
       - MYSQL_ROOT_PASSWORD=1234osradar
       - MYSQL_PASSWORD=1234osradar
       - MYSQL_DATABASE=nextclouddb
       - MYSQL_USER=nextclouduser
 app:
     image: nextcloud
     ports:
       - 1234:80
     links:
       - db
     volumes:
       - nextcloud:/var/www/html
       - data:/var/www/html/data
     restart: always

Let us remember that this image of Nextcloud is the official one so many of these parameters are unalterable. Although we can always add new configurations.

The explanation can be quite brief because of the explicit variables. In the image of MariaDB, we take the volume db that will be in /var/lib/mysql to preserve the data that Nextcloud stores. On the other hand, in the environment section, there are the parameters of the database, user and password. You can modify this as I did.

In the nextcloud image, we simply redirect the application port through ours. I have chosen as an example the 1234 but you know that you can modify it. And I have added two volumes one for the application as such and another for the data. Remember to create these folders in case you don’t have them already created.

Not much more than explaining the truth.

Once everything is in place, we save the file and close them. Then we run it:

:~$ docker-compose up -d

At this point you can open the browser and go to http://your-server:1234 but we will make a virtual host in Apache to avoid having to use the port. In other words an inverse proxy with Apache.

To do this, enable the following Apache module:

:~$ sudo a2enmod proxy_http
:~$ sudo systemctl restart apache2

Then, create the new virtualhost for Nextcloud:

:~$ sudo nano /etc/apache2/sites-available/nextcloud.conf

And add the following:

<Virtualhost *:80>
     ServerName nextcloud.osradar.test
     <Directory /var/www/html/>
       Options FollowSymlinks
       AllowOverride All
       Require all granted
     </Directory>
     ErrorLog ${APACHE_LOG_DIR}/nextcloud.osradar.test_error.log
     CustomLog ${APACHE_LOG_DIR}/nextcloud.osradar.test_access.log combined
     <Location "/">
         ProxyPass "http://localhost:1234/"
         ProxyPassReverse "http://localhost:1234/" 
     </Location>
</Virtualhost>

Then, save the changes and close the file.

So, enable the new Virtual host.

:~$ sudo ln -s /etc/apache2/sites-available/nextcloud.conf /etc/apache2/sites-enabled/nextcloud.conf
:~$ sudo a2enmod rewrite
:~$ sudo systemctl restart apache2

Complete the installation

Now, open your web browser and you will see the main page. Just type your database credentials and complete the installation.

In this step, I want to stop for a while. On the host, we do not type localhost but we refer to db which is where MariaDB is “installed”. So, the port is 3306 because it is the default and in the docker-compose.yml file we do not specify another one.

Then the installation will begin and you will see the dashboard.

And that is it. You can read more about Docker on the project website. Or about docker compose.

Conclusion

Docker we already know how powerful he is and today we have seen a bit of what can be done. In a few minutes, we can have in our server a Nextcloud instance working without any problem. So let’s make the most of it.

The post Nextcloud using Docker compose appeared first on Linux Windows and android Tutorials.

Install Docker and Docker-compose

The first thing to do is to install Docker and Docker compose in our system. For centos7, use the following command.

For the rest of the releases, it’s best to read the official Docker documentation.

[root@localhost ~]# yum install docker python-pip docker-compose -y

Check that the installation is successful

 [root@localhost ~]# docker-compose -v && docker -v

Deploy zabbix using Docker-compose

• First, create a folder and then create docker-compose.yml files in it

[root@localhost ~]# mkdir zabbix
[root@localhost ~]# cd zabbix/
[root@localhost zabbix]# touch docker-compose.yml

• Edit docker-compose.yml file

[root@localhost zabbix]# vim docker-compose.yml 
 version: '3'
 services:
   zabbix-mysql:
     image: mysql:5.6
     container_name: zabbix-mysql
     ports:
       - '3306:3306'
     environment:
       MYSQL_ROOT_PASSWORD: zabbix
     volumes:
       - /root/zabbix/mysql-data:/var/lib/mysql
 zabbix-server:
     image: zabbix/zabbix-server-mysql:ubuntu-3.0.4
     container_name: zabbix-server
     environment:
       DB_SERVER_HOST: "zabbix-mysql"
       MYSQL_USER: root
       MYSQL_PASSWORD: zabbix
     ports:
       - '10051:10051'
     links:
       - zabbix-mysql
     depends_on:
       - zabbix-mysql
 zabbix-web:
     image: zabbix/zabbix-web-nginx-mysql:ubuntu-3.0.4
     container_name: zabbix-web
     environment:
       DB_SERVER_HOST: zabbix-mysql
       MYSQL_USER: root
       MYSQL_PASSWORD: zabbix
       ZBX_SERVER_HOST: "zabbix-server"
       PHP_TZ: Asia/Shanghai
     ports:
       - '80:80'
       - '443:443'
     links:
       - zabbix-mysql
       - zabbix-server
     depends_on:
       - zabbix-mysql
       - zabbix-server

Important environment variable Settings

• Zabbix-web-nginx-mysql and zabbix-web-nginx-mysql image versions remain consistent (ubuntu-3.0.4 or other)
• MYSQL_ROOT_PASSWORD: mysql root password
• MYSQL_USER: Connect the mysql user
• MYSQL_PASSWORD: Connect the mysql password

Running and testing zabbix

[root@localhost ~]# docker-compose up -d
[root@localhost ~]# docker-compose ps

Wait 2 minutes for the database initialization to complete

Next, open your web browser and go to your server using the port 80.

Log in using Zabbix’s default user and password
user: Admin password:zabbix
After that, you will see the dashboard

In a nutshell with Docker Compose, you no longer need to use shell scripts to start the container. In the configuration file, all containers are defined through the services, and then the application is started, stopped, and restarted using the docker-compose script, along with the services in the application and all containers that depend on the services. Docker Compose is a tool for defining and running multi-container Docker applications. it USES YAML files to configure the service of the application and a single command to perform the creation and startup of all containers. The docker-compose cli tool allows users to run commands for multiple containers simultaneously.

android (260) Apache (56) bionic (55) Buster (83) CentOS (145) Centos 8 (51) database (57) Databases (62) debian (171) desktop (34) fedora (50) focal (102) Focal Fossa (106) google (168) howto (346) How to (330) how to tutorials (39) java (50) Linux (864) linux mint (37) mariadb (48) monitoring (36) mysql (43) network (35) News (59) New version (64) opensuse (44) PHP (66) Programming (139) RHEL (47) Security (103) server (259) SQL (65) tools (52) Tutorial (485) ubuntu (282) unix (32) web (40) web server (33) Windows (315) Windows 10 (222) windows 11 (73) Windows server (46) Windows server 2019 (58) Xiaomi (36)

The post Centos7 and 8 uses docker-compose to install zabbix appeared first on Linux Windows and android Tutorials.

Install Docker and Docker-compose

The first thing to do is to install Docker and Docker compose in our system. In the case of Debian 10, there is a tutorial of ours that you can use as a guide.

For the rest of the distributions, it is a good idea to read Docker’s official documentation. Anyway, it is not hard to do.

Deploy Jenkins using Docker-compose

As we explained in the post to deploy LAMP using Docker-compose, the definitions of images and their options, we do them in a file with the extension YML. To do this, it is recommended to first make a folder and within it create the file.

So, open a terminal session and type the following:

:~$ mkdir jenkins && cd jenkins

Once we have entered the folder using your favorite text editor proceed to create the docker-compose.yml file.

:~$ nano docker-compose.yml

Once inside, we will begin to define the content.

version: '2'
services:
  jenkins:
  image: 'bitnami/jenkins:2'

First the basic file definitions. The version to use will be the 2. And we will deploy only a service that will be called jenkins. For it, we will use the image Jenkins of bitnami. It is very well documented and quite reliable.

Then, we continue with the definition of the options.

ports:
      - '80:8080'
      - '443:8443'
      - '50000:50000'
    volumes:
      - 'jenkins_data:/bitnami'
volumes:
  jenkins_data:
  driver: local

In this section, you define the ports that the image will use. Remember that Jenkins uses the 8080 but we will access the 8080 port of the image through the 80. So, the 443 is for secure connections with Jenkins.

Equally, with LAMP, it is advisable to mount a volume for the Jenkins data. And at the end of the file, we refer to the options of that volume.

So, the file will be completed as follows:

version: '2'
services:
  jenkins:
    image: 'bitnami/jenkins:2'
    ports:
      - '80:8080'
      - '443:8443'
      - '50000:50000'
    volumes:
      - 'jenkins_data:/bitnami'
volumes:
  jenkins_data:
  driver: local

We can now raise the image, but I want to show you a few more options.

Some useful options to deploy Jenkins

This Jenkins image is customizable thanks to environment variables that can be modified. Some of them are these:

• JENKINS_USERNAME: Jenkins admin username.
• JENKINS_PASSWORD: Jenkins admin password.
• JENKINS_HOME: Jenkins home directory.
• DISABLE_JENKINS_INITIALIZATION: Allows to disable the initial Bitnami configuration for Jenkins.
• JAVA_OPTS: Customize JVM parameters.

To use and modify them, just add them to the file in the environment section. For example:

jenkins:
  ...
  environment:
    - JENKINS_PASSWORD=your-password
  ...

Note: by default the user is user and the password is bitnami. Then, you can modify it from Jenkins once it has been deployed.

Running and testing Jenkins

Once you have finished defining the docker-compose file. Now we can execute it with the following command:

:~$ sudo docker-compose up -d

Next, open your web browser and go to your server using the port 80.

Then, login into the application using the default credentials or yours.

After that, you will see the dashboard.

And that is it.

Conclusion

Jenkins is a very popular application and it is possible to install it on our server using docker. This way we save a lot of time on some operating-system configurations. However, for total control of it, it is advisable to do it manually.

You can read How to install Jenkins on Debian 10?

Please share this post and join our Telegram channel.

The post How to deploy Jenkins using docker-compose? appeared first on Linux Windows and android Tutorials.

As I have already explained, Docker is highly popular. If you did not know, it is an open source technology project that allows the deployment of applications through containers. These containers are distributed in the form of images that are loads from Docker. So, the programmer or Sysadmin can make an image of an application and redistribute it in many systems. In addition, all this without dependencies or compatibility problems.

What is Docker Compose?

Docker Compose was born as a tool that extends the functionality of Docker. Docker is for deploying or installing applications that are in the form of images. However, many applications require other images to run. For example, if you want to install WordPress, you need the images of the web server, the database handler and finally the WordPress itself. This also happens with other services, which require to operate other services.

With Docker Compose it is possible to define the dependencies of an image and they will be automatically managed. Too useful and practice this utility.

So, let us install Docker Compose on CentOS 7.

Install Docker Compose on CentOS 7

To use Docker Compose, you need to install Docker first. Installing Docker is quite simple and in this post, we show you how to do it.

Read how to install Docker on CentOS 7?

Once Docker is installed and fully functional, we can start installing Docker Compose.

For this, we will use the official Docker Compose binary. Open a terminal and as root user run the following command:

:~# curl -L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

After that, set the execution permission to the binary.

:~# chmod +x /usr/local/bin/docker-compose

Next, create a sym link for Docker compose.

:~# ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

Finally, check the installed version.

:~# docker-compose --version

So, Docker compose is ready to use.

Using Docker Compose

Docker Compose automatically manages various images through a .yaml file. This file defines the parameters to be followed and the management of the images. Then, it is lifted with a command and ready.

In this example, I will make a file to install a LAMP server.

First, we need to create a file with a .yml extension called docker-compose. On it, we need to put all the image requisites. For example:

version: "3"
 
services:
  test_mysql:
    image: mysql:5.7
    environment:
      - MYSQL_DATABASE=testdatabase
      - MYSQL_ROOT_PASSWORD=rootpss
      - MYSQL_USER=user
      - MYSQL_PASSWORD=userpss
    volumes:
      - ./volume/mysql:/var/lib/mysql
    expose:
      - 3306
    ports:
      - 3306:3306
   
  php:
    image: php:7-apache
    volumes:
      - ./test_web/:/var/www/html
    expose:
      - 80
    ports:
      - 80:80
    links: 
      - test_mysql

The file is somewhat long but very understandable. I will try to explain it briefly to make it clearer.

Version refers to the version of the Docker Compose file. It is currently 3. As it evolves, it becomes incremental. Within Service, the services to be deployed are defined. In this case, there are two, MySQL and PHP with Apache already incorporated.

The first service is MySQL where test_mysql is the name of the service and the image that is going to load. Then, we define an environment with test credentials. We need to create a new volume so as not to lose the data and make it available through port 3306.

Similarly, in the PHP service, we first assign a name. Then, the image to load, the volume where we can place our page and then the ports to use. Finally, we must link the services and therefore the last line.

After that, use Docker Compose to make apply the file

:~# docker-compose up -d

As you can see, there is no error in the execution of the file and at the end, you will have the services running. Remember to open the ports in the firewall for everything to work.

On the contrary, if you want to stop the execution of the containers, run the following command:

:~# docker-compose down

So, that is it.

Conclusion

Using the best tools is vital for good server management results. Docker is an example of this. With this technology, it is possible to display images in a simple way and guaranteeing the compatibility of the programs.

Please share this post with your friends.

The post How to install Docker Compose on CentOS 7? appeared first on Linux Windows and android Tutorials.