The find command is a command that searches for files and folders, from the command line, in a directory tree. It is used by many users who work in the terminal and can help even the most veteran users of the system.

So, let’s show you some examples of how to use the command to find files in any Linux distribution.

How to find files in Linux

The find command is part of the GNU Utils so it is available in any Linux distribution you can think of. So like any command, it has a basic syntax which is as follows

find [path] [parameters] [values] [values]

From what we can see, it is simple to use and now we will show some examples

• Find a file of which we know the name and extension:

find / -name name.txt 

Replace name with the name of the file. In this case, a file named name.txt will be searched for in the whole system.

• Search for files in a particular location.

find /home/angelo/ -name name.txt

• Doing case-insensitive searches

When searching by filename it is common to not remember whether it is upper or lower case. To do this, you can follow the following structure

find /home/angelo -iname name name.txt

Remember that you can modify the names and parameters to fit your criteria.

• Search for directories or folders

To search for directories we must use the type d parameter, it is as simple as this.

find / -type d -name documents

This will search for all folders named documents in the whole system. Also, you can change the search directory.

• Search files by extension

In this case, it is also useful to know how to search for files by extension. In this case, the option that will help us is type f.

find / -type f -name *.sh

Thus, in the above example, all files with the extension .sh in the system will be searched.

Other examples of the find command

It is also useful to know how to search for files by permissions, to do this use the perm parameter and the permission you want to search for.

find / -type f -perm 0775

or even, permissions different from the specified one

find / -type f ! -perm 775

• Search for empty files or folders

In this case, we can easily do it with these two commands

find / -type f -empty
find / -type d -empty

The first one works for files and the second one for directories or folders.

• Find files according to their modification date

For many sysadmins this can be very useful because we can perform a search according to the time it was modified.

find / -type f -mtime +21

In this case, all files that are older than 21 days since their last modification will be searched.

• Search files according to their size

Also, with the size option we can further filter our search. For example, we can search for files that weigh more than 10Mb.

find / -type f -size +10M

That is to say, with this we can be more effective.

So, enjoy it.

The post How to Find files in Linux? appeared first on Linux Windows and android Tutorials.

Docker on the “new” world

Before Docker, the basic way to distribute applications on a server was through a virtual machine. I explain, if you developed an application that required a certain library in Debian 8 and you had to deploy it on a server, the most logical solution was to create a virtual machine with Debian 8. This was a small problem, having a virtual machine for one or two applications is not adequate. On the other hand, the server had to move several systems at once.

Now with Docker, you can “package” that application and its dependencies in the form of a container. These containers are distributed in the form of images that are interpreted by Docker on the server and can run independently of the system where it was built.

Likewise, Docker has port and volume isolation to increase security and integrity between the image and the host system.

Now, we are going to install Docker on Ubuntu 20.04 / Debian 10.

Install Docker on Ubuntu 20.04 / Debian 10

To perform this tutorial, it is necessary to have a user who has access to sudo or to have the password of the root user. Remember that we are going to do an installation.

On the other hand, the server or computer must have SSH enabled. Although if you have installed Debian 10 Buster with our tutorial, it should already be working.

1.- Add the Docker Repository

The easiest and safest way to install Docker on Ubuntu 20.04 / Debian 10 is to use the official Docker repository. This way, we will save time but we will also have Docker updated in an easy and secure way. So this is the officially recommended option.

Before adding the repository, first, you have to install some necessary packages. In a terminal session, run the following command:

:~$ sudo apt install apt-transport-https  ca-certificates curl gnupg2 software-properties-common

The next step is to add the official GPG key to the repository. This ensures that downloaded packages are not compromised.

For Debian 10:

:~$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
OK

For Ubuntu 20.04:

:~$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
Ok

Using this repository you can install the test and nightly versions. However, we will use the stable channel to perform the installation.

For Debian 10:

:~$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian/ $(lsb_release -cs) stable"

For Ubuntu 20.04:

:~$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu/ $(lsb_release -cs) stable"

2.- Install Docker CE on Ubuntu 20.04 / Debian 10

Now that the Docker repository is added correctly, we will be able to update the APT cache.

:~$ sudo apt update

Now, using the following command we can install Docker.

:~$ sudo apt install docker-ce docker-ce-cli containerd.io

Note: If you have several Docker repositories enabled APT will always choose the newest version and this is a stability problem because It would prefer a beta version to a stable one.

3.- Test the Docker installation

First, we verify that the Docker service is correctly started with this command:

:~$ sudo systemctl start docker

If you want Docker starts at the booting:

:~$ sudo systemctl enable docker

Next, check the service status:

:~$ sudo systemctl status docker

As you can see, the Docker service is working properly.

Finally, run the docker hello-world.

:~$ sudo docker run hello-world

So, Docker is ready for the action.

Conclusion

Docker’s technology is a wonder if you work with large-scale servers. Its practicality when depleting applications makes it an alternative to virtual machines. And now you have learned to install it on Ubuntu 20.04 / Debian 10.

So, please share this post with your friends and join our Telegram channel.

The post How to install Docker on Ubuntu 20.04 / Debian 10? 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.

What is the Docker situation on CentOS 8?

CentOS 8 just went on the air. In fact, that’s what we’re telling you in this post. However, the Docker repositories have not yet been prepared for the number change. However, the process is quite reliable although it is advisable to take some precautions.

The main advantage of this method is that it does not expire. That is to say, as soon as the packages are suitable, everything will flow without problems and with the certainty that nothing strange will happen.

Once we know this, we are going to install Docker on CentOS 8.

Install Docke on CentOS 8

Open a terminal session and add the Docker repository. As I said before we will use packages for CentOS 7 but it is functional. So let’s go for it:

:~$ su
:~# dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
Adding repo from: https://download.docker.com/linux/centos/docker-ce.repo

Then we’ll have to install Docker. The command in question is as follows:

:~# dnf install docker-ce

But if for some reason, the command fails. The safest thing is to use the following one:

:~# dnf install --nobest docker-ce 

That should work by now.

Now you only need to start the Docker service with this command:

:~# systemctl start docker

And see the status of the service:

:~# systemctl status docker

As you can see, everything is in order. That is to say, we will be able to use docker without problems.

And that is it.

Conclusion

Docker is a spectacular technology for the deployment of applications. However, due to the recent release of CentOS the repositories and packages have not yet been adequate. But today we have taught you an alternative method to achieve the installation.

You can learn how to install Docker on Debian 10 too.

Please share this post and join our Telegram channel.

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

0. What we need

First of all, we need two Debian 10 teams. Both must have a static IP address and a defined hostname. Also, they have a partition defined for replication of the same size. Then, be connected to the same network and that the Firewall allows connections through the DRBD network port. In short, this will be our environment.

Node 1:

• IP address: 192.168.250.100
• Hostname: osradar1
• OS: Debian 10
• Disk: /dev/sda
• Partition to replicate: /dev/sda2

Node 2:

• IP address: 192.168.250.110
• Hostname: osradar2
• OS: Debian 10
• Disk: /dev/sda
• Partition to replicate: /dev/sda2

Each node must have a /dev/sda2/ partition of at least several GB in size.

1) Install DRBD on Debian 10

DRBD is available in the official repositories of the distribution. So the installation is not complicated.

On both nodes, run the following command:

:~$ sudo apt install drbd-utils

Of course, DRBD incorporates a module that has to be loaded into the kernel. In both nodes, it has to be loaded. To do this, run the following command:

:~$ sudo modprobe drbd

Then, check the module was added.

:~$ lsmod | grep drbd

2) Configure DRBD

The package is already installed and the module loaded to the kernel. Now it remains to make the appropriate settings for the replication to be a success.

DRBD has the particularity of being flexible, that is, the configuration file has many options that we can manipulate and adapt to our needs.

However, it is recommended to make a backup of the configuration file before starting to work on it.

:~$ sudo cp /etc/drbd.conf /etc/drbd.conf.bak

Then, erase the entire file.

:~$ sudo cat /dev/null > /etc/drbd.conf

Now, you need to edit the configuration file:

:~$ sudo nano /etc/drbd.conf

And add the following:

global { usage-count no; }
common { syncer { rate 100M; } }
resource r0 {
        protocol C;
        startup {
                wfc-timeout  15;
                degr-wfc-timeout 60;
        }
        net {
                cram-hmac-alg sha1;
                shared-secret "secret";
        }
        on osradar1 {
                device /dev/drbd0;
                disk /dev/sda2;
                address 192.168.250.100:7788;
                meta-disk internal;
        }
        on osradar2 {
                device /dev/drbd0;
                disk /dev/sda2;
                address 192.168.0.110:7788;
                meta-disk internal;
        }
}

The truth is that I think that many of the options are very explicit but I will briefly explain the most important ones.

In global and common some global configurations are defined to both nodes and resources.

Then, in the resource section, we define the name. In this case r0, of course, you can modify it. Next, in protocol, startup, and net, specific configurations to the resource.

Then, there is the configuration in each node identified by the hostname. In each of them, we define the DRBD device and the partition we are going to replicate (disk). Also, the IP address of the node as well as the communication port.

As you can see it is not very complex or long to understand.

3) Start DRBD on Debian 10

Remember this same file must be on both nodes. Then, in both nodes run the following commands to start the DRBD service.

:~$ sudo systemctl stop drbd
:~$ sudo drbdadm create-md r0
:~$ sudo drbdadm attach r0

Remember that isr0 the name of the resource. You can change it in the configuration file.

After that, you can start the service.

:~$ sudo systemctl start drbd

And set which node will be the master. In this case, the node1 will be the master. So, in the node1 run this command:

:~$ sudo drbdadm -- --overwrite-data-of-peer primary all

With that, we should have an effective replication. It would be enough to create a new file system and mount it.

:~$ sudo mkfs.ext4 /dev/drbd0
:~$ sudo mkdir /testdata
:~$ sudo mount /dev/drbd0 /testdata

There, you can create new files. And that is it.

If you want more post about Debian 10, please click here.

Please share this post with your friends and join our Telegram Channel.

The post Install and configure DRBD on Debian 10 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.

Continuous integration and Jenkins

In a production environment, the software is developed and compiled frequently. In addition to this, it needs to be tested quite a few times. With each change in the source code, it is necessary to start the whole process over again.

Jenkins automates all these tasks quickly and easily. So, the process where all the changes and functions of the application in development are automatically verified is called continuous integration.

In this sense, using Jenkins the developer will know at all times the status of his application. Failures, new features, and processes will be automated and monitored with Jenkins.

Install Jenkins on Debian 10 Buster

One of the great advantages of Jenkins is that it is cross-platform. This is because it is built in Java. Therefore, it can be installed on almost all Linux distributions without any problems. Of course, also in Debian 10.

However, there are some small things to keep in mind. First of all, it is necessary to have a user with sudo or to be root users.

Read how to enable sudo on Debian 10?

On the other hand, you have to have Java installed and know how to use the terminal. So, let us start.

1) Install Java on Debian 10

First of all, you must have Java installed. This is vital because Jenkins is made in Java. So open a terminal and run the following command:

:~$ sudo apt install default-jre default-jdk

Then, check the Java version.

:~$ java --version
openjdk 11.0.3 2019-04-16
OpenJDK Runtime Environment (build 11.0.3+7-post-Debian-5)
OpenJDK 64-Bit Server VM (build 11.0.3+7-post-Debian-5, mixed mode, sharing)

Now, Java is correctly installed.

2) Add the Jenkins repository on Debian 10

Jenkins is a vital program in professionally deploying software. So, to install it, it requires a safe and reliable method from Jenkins developers. For this purpose and to facilitate the installation, they have made available a software repository.

So, add it to our Debian 10 Buster. First, install some necessary packages:

:~$ sudo apt install apt-transport-https wget gnupg

Then, add the GPG key for the repository.

:~$ wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -
OK

Now add edit the file /etc/apt/sources.list and add the following. To do this, I will use the nano text editor.

:~$ sudo nano /etc/apt/sources.list
deb https://pkg.jenkins.io/debian-stable binary/

Next, save the changes (CTRL + O) and close the file (CTRL +X).

3) Install Jenkins on Debian 10 (I)

Then, refresh APT and install Jenkins on Debian 10 using the following commands:

:~$ sudo apt update
:~$ sudo apt install jenkins

You can check the service status by running this command:

:~$ sudo systemctl status jenkins

As you can see, the service is running smoothly. Now, you need to get the default superuser key. To do this, run this command:

:~$ sudo cat /var/lib/jenkins/secrets/initialAdminPassword
6dcefe440e474daea0f4b85ace1ad954

Now, complete the installation using the web browser.

3) Install Jenkins on Debian 10 (II)

Now we have to go to the server and complete the installation. Open your web browser and go to http://server-ip:8080 Remember that Jenkins uses port 8080 by default. You will see this. Just, type the root password and continue.

Then, create the admin user.

After that, you can choose the plugins you want to activate. Whether they are suggested or others.

Then, after a couple of confirmation and information windows. You will be on the Jenkins dashboard.

Enjoy it. 😀

Conclusion

In this post, you have learned to install Jenkins on Debian 10, Buster. It is a pretty good application for continuous integration processes. So the processes inherent to the software development can be automated giving the developer truthful and accurate information about the process.

Please share this post and join our Telegram channel.

The post How to install Jenkins on Debian 10? 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.

We’ve already talked about ArangoDB on this site. ArangoDB is a NoSQL type database handler, that is, it does not use the traditional data storage system as in MySQL or PostgreSQL. ArangoDB stands out for being high performance, open source and easily scalable.

As you can see, we are in the presence of a database manager for a fairly defined segment of the market. On the other hand, ArangoDB has community and enterprise versions for business projects.

So, let us start to install ArangoDB on CentOS 7.

1. Upgrade the system

First, you need to update the system completely. With this, you will have a faster and more agile system to perform the tasks. In addition, you will have installed the latest security patches intended to solve problems in the packages.

:~$ su
:~# yum update

As I said before, updating the system is necessary to improve the stability and security of the system.

2. Install ArangoDB on CentOS 7

The most efficient way to install ArangoDB on a CentOS 7 system is to do it through YUM. For this, it is vital to add the official repository of ArangoDB. So, let us do it.

:~# cd /etc/yum.repos.d/
:~# curl -OL https://download.arangodb.com/arangodb34/RPM/arangodb.repo

Then, you can start with the installation of ArangoDB using YUM.

:~# yum install arangodb3

After that, you have to enable and start the ArangoDB service.

:~# systemctl enable arangodb3
:~# systemctl start arangodb3

It is a good idea to check the service status to find some issue.

:~# systemctl status arangodb3

So, ArangoDB is correctly installed and it is running properly too.

Finally, you can access to the ArangoDB console

:~# arangosh

Now, you can start to use it.

3. Using the web interface

ArangoDB has a quite friendly and useful web interface, with it you will be able to make multiple configurations and operations in a very friendly way. To enable it is necessary to edit some configuration files.

:~# nano /etc/arangodb3/arangod.conf

And add the following:

endpoint = tcp://SERVER_IP:8529

In my case, it would be something like this.

After that, do the same with the other configuration file.

:~# nano /etc/arangodb3/arangosh.conf

Then, restart the ArangoDB service.

:~# systemctl restart arangodb3

Next, set the firewall rules to allow the use of the port 8529 by ArangoDB.

:~# firewall-cmd --add-port=8529/tcp --permanent
:~# firewall-cmd --reload

After that, open the web browser and go to http://SERVER_IP:8529 and you will see this:

Now, we have to change the root password. Just type:

:~# systemctl stop arangodb3
:~# ARANGODB_DEFAULT_ROOT_PASSWORD=your_password arango-secure-installation

You can also run the command to change the root password:

:~# arangodb_secure_installation

Go back to the web browser and log in.

Next, select the database.

And you will see the main screen.

Conclusion

As you can notice, ArangoDB has a fairly simple installation process, taking into account its potential. For it, it has a repository for CentOS 7 that facilitates the process of installation and update.

Please share this post with your friends.

The post Install ArangoDB on CentOS 7 appeared first on Linux Windows and android Tutorials.

To do it I present you two very simple methods to do it, one consists of using an external program for it. The other method is with a command that normally comes installed on all Linux distributions.

So, let us start.

1. Protect your files using rm-protection

rm-protection is a small program similar to an rm extension that protects your files from accidental deletion. The program can be installed via PIP so there should be no problem with it.

First, you need to install PIP.

If you use Debian, Ubuntu, Linux Mint or derivate:

$ sudo apt install python-pip
$ sudo apt-get install python-setuptools

In case you are using Arch Linux or derivates, you can install it with this command:

:~$ sudo pacman -S pyhton-pip

On CentOS 7 and RHEL:

:~$ su
:~# yum install epel-release
:~# yum install python-pip

Next, install rm-protection.

:~$ sudo -H pip install rm-protection

Next, use the command to protect your file. For example, I have one file called examplerm.txt.

:~$ protect examplerm.txt

Then, the tool will ask your to set a question and answer. If you want to eliminate it, it will ask you a question and you must answer it correctly.

Now, try to remove it.

:~$ rm-p example.txt

You will see this:

As you can see, you have to answer the question. If you don not answer the question correctly, the program will not allow you to remove the file.

However, if you type the answer, then you will remove it.

The script is very good, but not infallible. The root user can delete without knowing the answer to the question, just as if the user knows the answer as well. Use it more than anything to avoid accidents, not to give security to the system.

If you want more security, I recommend to you create a Alias and change rm for rm-p.

2.- Protect your files using the chattr command

The second form is somewhat more drastic than the first and is using the chattr command. It is a command available on almost all Linux distributions.

Its usage is like this:

:~$ chattr [-pRVf] [-+=aAcCdDeijPsStTu] [-v version] files

Do not worry, it is too easy to use it.

For example, I will protect one file called examplechattr.txt.

:~$ sudo chattr +i examplechattr.txt

I’ll explain briefly. Chattr has an operator like + that adds a feature or – that removes it. Option i indicates that the file is immutable, i.e. it cannot be deleted.

Let us try to remove it.

As you can see, even the root user is not allowed to remove the file.

If you want to remove this attribute, you can do so with this command:

:~$ sudo chattr -i examplechattr.txt

Now, you can delete it.

The same way you can protect entire folders. For example:

:~$ sudo chattr -R +i Example/

To revoke it

:~$ sudo chattr -R -i Example/

So, that’s it.

Conclusion

The protection of data and files is an essential task of a sysadmin, for it there are two very simple ways to do it.

Please share this post with your friends.

The post Protect your files from accidental deletion appeared first on Linux Windows and android Tutorials.