}
-----------------------------------------------------------------
If you are behind a firewall, remember to allow input/output of these tcp ports:
-----------------------------------------------------------------
port of seafile fileserver: 8082
port of seahub: 8000
When problems occur, Refer to
https://github.com/haiwen/seafile/wiki
for information.
```
Next, give permissions to Seafile with the following command:
```
chown -R www-data:www-data /var/www/html/
```
Next, you will need to add a FILE_SERVER_ROOT setting in the file seahub_settings.py:
```
nano /var/www/html/conf/seahub_settings.py
```
Add the FILE_SERVER_ROOT settings as shown below:
```
SECRET_KEY = "x)0=j*l6b+4amq2n^&)c=q5p==exn13%s&6x!*48u4p0p97k)4"
FILE_SERVER_ROOT = 'http://seafile.example.com/seafhttp'
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
: 'NAME': 'seahubdb',
'USER': 'seafileuser',
'PASSWORD': 'password',
'HOST': '127.0.0.1',
'PORT': '3306'
}
}
```
Save and close the file when you are finished.
## Step 5 – Create Admin User for Seafile
Next, you will need to create an admin user and set a password for Seafile. To do so, change the directory to seafile and start the seafile service with the following command:
```
cd /var/www/html/seafile
su -p -l www-data -s /bin/bash -c "./seafile.sh start"
```
Next, start the seahub service and create an admin account with the following command:
```
su -p -l www-data -s /bin/bash -c "./seahub.sh start"
```
You will be asked to provide your email address and admin password as shown below:
```
LC_ALL is not set in ENV, set to en_US.UTF-8
Starting seahub at port 8000 ...
----------------------------------------
It's the first time you start the seafile server. Now let's create the admin account
----------------------------------------
What is the email for the admin account?
[ admin email ] admin@example.com
What is the password for the admin account?
[ admin password ]
Enter the password again:
[ admin password again ]
----------------------------------------
Successfully created seafile admin
----------------------------------------
Seahub is started
Done.
```
Once you are done, stop the seafile and seahub services:
```
su -p -l www-data -s /bin/bash -c "./seafile.sh stop"
su -p -l www-data -s /bin/bash -c "./seahub.sh stop"
```
## Step 6 – Create a Systemd File for Seafile and Seahub
Next, you will need to create a systemd unit file for Seafile and Seahub to manage the service.
First, create a seafile service file with the following command:
```
nano /etc/systemd/system/seafile.service
```
Add the following lines:
```
[Unit]
Description=Seafile
After= mysql.service
After=network.target
[Service]
User=www-data
Group=www-data
Type=forking
ExecStart=/var/www/html/seafile-server-latest/seafile.sh start
ExecStop=/var/www/html/seafile-server-latest/seafile.sh stop
[Install]
WantedBy=multi-user.target
```
Save and close the file. Then, create a systemd service file for Seahub with the following command:
```
nano /etc/systemd/system/seahub.service
```
Add the following lines:
```
[Unit]
Description=Seafile
After= mysql.service
After=network.target
[Service]
User=www-data
Group=www-data
Type=forking
ExecStart=/var/www/html/seafile-server-latest/seahub.sh start
ExecStop=/var/www/html/seafile-server-latest/seahub.sh stop
[Install]
WantedBy=multi-user.target
```
Save and close the file. Then, reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, restart Seafile and Seahub service and enable them to start after system reboot with the following command:
```
systemctl start seafile
systemctl enable seafile
systemctl start seahub
systemctl enable seahub
```
To verify the Seafile service, run the following command:
```
systemctl status seafile
```
Output:
```
● seafile.service - Seafile
Loaded: loaded (/etc/systemd/system/seafile.service; disabled; vendor preset: enabled)
Active: active (running) since Thu 2019-11-28 08:48:31 UTC; 8s ago
Process: 15487 ExecStart=/var/www/html/seafile-server-latest/seafile.sh start (code=exited, status=0/SUCCESS)
Tasks: 16 (limit: 1150)
CGroup: /system.slice/seafile.service
├─15522 /var/www/html/seafile/seafile/bin/seafile-controller -c /var/www/html/ccnet -d /var/www/html/seafile-data -F /var/www/html/c
├─15524 ccnet-server -F /var/www/html/conf -c /var/www/html/ccnet -f /var/www/html/logs/ccnet.log -d -P /var/www/html/pids/ccnet.pid
└─15527 seaf-server -F /var/www/html/conf -c /var/www/html/ccnet -d /var/www/html/seafile-data -l /var/www/html/logs/seafile.log -P
Nov 28 08:48:28 ubuntu1804 systemd[1]: Starting Seafile...
```
To verify the Seahub service run the following command:
systemctl status seahub
Output:
```
● seahub.service - Seafile
Loaded: loaded (/etc/systemd/system/seahub.service; disabled; vendor preset: enabled)
Active: active (running) since Thu 2019-11-28 08:50:49 UTC; 18s ago
Process: 15547 ExecStart=/var/www/html/seafile-server-latest/seahub.sh start (code=exited, status=0/SUCCESS)
Main PID: 15573 (python2.7)
Tasks: 6 (limit: 1150)
CGroup: /system.slice/seahub.service
├─15573 python2.7 /var/www/html/seafile/seahub/thirdpart/gunicorn seahub.wsgi:application -c /var/www/html/conf/gunicorn.conf --prel
├─15579 python2.7 /var/www/html/seafile/seahub/thirdpart/gunicorn seahub.wsgi:application -c /var/www/html/conf/gunicorn.conf --prel
├─15580 python2.7 /var/www/html/seafile/seahub/thirdpart/gunicorn seahub.wsgi:application -c /var/www/html/conf/gunicorn.conf --prel
├─15581 python2.7 /var/www/html/seafile/seahub/thirdpart/gunicorn seahub.wsgi:application -c /var/www/html/conf/gunicorn.conf --prel
├─15582 python2.7 /var/www/html/seafile/seahub/thirdpart/gunicorn seahub.wsgi:application -c /var/www/html/conf/gunicorn.conf --prel
└─15583 python2.7 /var/www/html/seafile/seahub/thirdpart/gunicorn seahub.wsgi:application -c /var/www/html/conf/gunicorn.conf --prel
Nov 28 08:50:43 ubuntu1804 systemd[1]: Starting Seafile...
```
## Step 7 – Configure Reverse Proxy with Nginx
Next, you will need to install and configure Nginx as a reverse proxy for Seafile to forward the client requests from ports 8000 and 8082 to the Nginx port 80.
To do so, create an Nginx virtual host configuration file with the following command:
```
nano /etc/nginx/sites-available/seafile
```
Add the following lines:
```
server {
listen 80;
listen [::]:80;
root /var/www/html/seafile;
server_name seafile.example.com;
client_max_body_size 100M;
autoindex off;
access_log /var/log/nginx/example.com.access.log;
error_log /var/log/nginx/example.com.error.log;
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Host $server_name;
proxy_read_timeout 1200s;
}
location /seafhttp {
rewrite ^/seafhttp(.*)$ $1 break;
proxy_pass http://127.0.0.1:8082;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_connect_timeout 36000s;
proxy_read_timeout 36000s;
proxy_send_timeout 36000s;
send_timeout 36000s;
}
location /media {
root /var/www/html/seafile-server-latest/seahub;
}
}
```
Save and close the file when you are finished. Then, enable the Nginx virtual host with the following command:
```
ln -s /etc/nginx/sites-available/seafile /etc/nginx/sites-enabled/
```
Finally, restart the Nginx service with the following command:
```
systemctl restart nginx
```
## Step 9 – Access Seafile Web Interface
Now, open your web browser and navigate the URL http://seafile.example.com. You should see the Seafile login page:
Provide your admin username, password and click on the **Log in** button. You should see the Seafile default dashboard:
## Conclusion
In the above tutorial, we learned how to install the Seafile server with Nginx as a reverse proxy on Ubuntu 18.04 VPS. I hope you have now enough knowledge to host your own file sharing server using Seafile. Get started with Seafile today on a [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install Symfony Framework on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-symfony-framework-on-centos-8/ | Published: 2020-03-15 | Updated: 2026-03-03 | Author: Hitesh Jethva
Symfony is a free, open-source, popular PHP framework with MVC architecture used to build web services, APIs, microservices, and high-performance, complex web applications. Symfony is compatible with other database systems and gives you full control over configuration. It comes with a set of reusable components and a user-friendly web interface, and its flexibility and high performance make it a top choice for developing an enterprise application.
In this tutorial, we will learn how to install the Symfony framework on CentOS 8 server.
## Step 1 – Install LAMP Server
First, you will need to install the Apache, MariaDB, PHP and other required PHP extensions in your server. You can install all of them with the following command:
```
dnf install httpd mariadb-server php php-cli php-common php-spl php-hash php-ctype php-json php-mbstring php-zip php-gd php-curl php-mysqli php-xml php-gmp php-intl php-xmlrpc php-bcmath php-soap php-ldap unzip -y
```
Once all the packages are installed, start the Apache and MariaDB service and enable them to start after system reboot with the following command:
```
systemctl start httpd
systemctl enable httpd
systemctl start mariadb
systemctl enable mariadb
```
Once you are done, you can proceed to the next step.
## Step 2 – Secure MariaDB Database
By default, MariaDB is not secured, but you can secure the MariaDB and set a MariaDB root password using the following command:
```
mysql_secure_installation
```
Answer all the questions as shown below:
```
Enter current password for root (enter for none): Just Press Enter
Set root password? [Y/n] Y
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
```
Once you are finished, you can proceed to the next step.
## Step 3 – Install Symfony
Before installing Symfony, you will need to install Composer in your system. Composer is a dependency manager for PHP that can be used to install PHP dependencies while building the project.
You can install Composer with the following command:
```
wget https://getcomposer.org/installer -O composer-installer.php
php composer-installer.php --filename=composer --install-dir=/usr/local/bin
```
Once installed, you should get the following output:
All settings correct for using Composer
```
Downloading...
Composer (version 1.9.3) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer
```
Next, change the directory to the /var/www/html and create a new Symfony project with the following command:
```
cd /var/www/html
composer create-project symfony/website-skeleton symfony5
```
Next, give proper permissions to the symfony5 directory using the following command:
```
chown -R apache:apache /var/www/html/symfony5
chmod -R 755 /var/www/html/symfony5
```
## Step 4 – Start Symfony in Development Mode
You can now start Symfony in development mode using the following command:
```
cd /var/www/html/symfony5
php -S 0.0.0.0:8000 -t public
```
You should see the following output:
```
PHP 7.2.11 Development Server started at Thu Feb 6 08:56:29 2020
Listening on http://0.0.0.0:8000
Document root is /var/www/html/symfony5/public
Press Ctrl-C to quit.
```
Symfony web server is now started and listening on port 8000. You can access it using the URL http://your-server-ip:8000. You should see the following screen:
You can stop the Symfony web server by pressing **CTRL+C** on your terminal interface.
## Step 5 – Configure Apache for Symfony
Next, you will need to create a new Apache virtual host configuration file for Symfony. You can create it with the following command:
```
nano /etc/httpd/conf.d/symfony.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
DocumentRoot "/var/www/html/symfony5/public"
ServerName symfony.example.com
AllowOverride All
Order Allow,Deny
Allow from All
ErrorLog "/var/log/httpd/example.com-error_log"
CustomLog "/var/log/httpd/example.com-access_log" combined
```
Save and close the file when you are finished. Then, restart the Apache service to apply the changes:
```
systemctl restart httpd
```
## Step 6 – Configure Firewall
If the firewalld service is enabled in your system, you will need to allow HTTP/HTTPS port through firewalld.
First, check the firewalld service using the following command:
```
systemctl status firewalld
```
You should see that firewalld service is not running:
```
● firewalld.service - firewalld - dynamic firewall daemon
Loaded: loaded (/usr/lib/systemd/system/firewalld.service; disabled; vendor preset: enabled)
Active: inactive (dead)
Docs: man:firewalld(1)
```
You can start the firewalld service and enable it to start after system reboot with the following command:
```
systemctl start firewalld
systemctl enable firewalld
```
Next, allow HTTP and HTTPS port through firewalld with the following command:
```
firewall-cmd --permanent --add-service=http
firewall-cmd --permanent --add-service=https
```
Next, reload the firewalld to apply the changes:
```
firewall-cmd --reload
```
## Step 7 – Access Symfony
Now, open your web browser and type the URL http://symfony.example.com. You will be redirected to the Symfony default dashboard as shown in the following screen:
## Conclusion
Congratulations! you have successfully installed Symfony 5 on CentOS 8 server. You can now start building brilliant applications with Symfony. Get started on Symfony today on a [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# How to Set Up a Fully Featured Mail Server with Postfix, Dovecot and Roundcube on Ubuntu 24.04
> URL: https://www.atlantic.net/vps-hosting/how-to-set-up-fully-featured-mail-server-with-postfix-dovecot-and-roundcube-on-ubuntu/ | Published: 2020-03-16 | Updated: 2025-05-30 | Author: Hitesh Jethva
Setting up your own mail server on Linux VPS is an important task for any Linux system administrator. Postfix is one of the most widely used and easiest mail server solutions available. It is a free, open-source, and powerful Mail Transfer Agent (MTA) that can be used to send and receive email. By default, Postfix is the default MTA software on all Linux distributions.
Dovecot is an open-source IMAP and POP3 email server that can act as a mail storage server. It is used to deliver and retrieve emails to and from local mailboxes.
Roundcube is a web-based IMAP email client that can read emails stored by Dovecot on virtual mailboxes. It provides all features you expect from an email client including MIME support, multiple sender identities, spell checking, folder manipulation, and many more.
In this tutorial, we will show you how to set up a full-featured Mail server with Postfix, Dovecot and Roundcube on Ubuntu 20.04 VPS.
## Prerequisites
- A fresh Ubuntu 24.04 VPS.
- A valid domain name pointed to your VPS IP address. In this tutorial, we will use email.example.com.
- A & MX records for your server.
**Note**: You can refer to the Atlantic DNS Guide to manage the [DNS records](https://www.atlantic.net/dedicated-server-hosting/cloud-hosting-getting-started-with-dns-records/).
## Step 1 – Set Up the Hostname
Next, you will need to set the hostname of your server. In this case, we will set the hostname to mail.example.com, as shown below:
```
hostnamectl set-hostname email.example.com
```
Next, open /etc/hosts file and bind your server IP address with the hostname:
```
nano /etc/hosts
```
Add the following line:
```
your-server-ip email.example.com email
```
Save and close the file. Then, run the following command to apply the configuration changes:
```
hostname -f
```
## Step 2 – Install Apache, MariaDB and PHP
Roundcube requires Apache, MariaDB and PHP to be installed on your server. You can install them with the following command:
```
apt-get install apache2 mariadb-server php libapache2-mod-php php-mysql -y
```
After installing all the required packages, you will need to enable the Apache rewrite module for Roundcube to work. You can enable it with the following command:
```
a2enmod rewrite
```
Next, reload the Apache service to apply the changes:
```
systemctl restart apache2
```
## Step 3 – Install Let’s Encrypt SSL Certificate
Next, you will need to install the Let’s Encrypt Free SSL certificate on your server to configure your mail server with TLS.
First, install the Certbot client in your server with the following command:
```
add-apt-repository ppa:certbot/certbot
apt-get update -y
apt-get install python-certbot-apache -y
```
Next, download the Let’s Encrypt Free SSL certificate for your domain email.example.com with the following command:
```
certbot certonly --apache -d email.example.com
```
This command will download the certificate in the /etc/letsencrypt/live/email.example.com/ directory.
## Step 4 – Install and Configure Postfix
Next, let’s start to install a Postfix mail server with the following command:
```
apt-get install postfix
```
You will be redirected to the following screen:
Select **Internet Site** and press **TAB** and **Enter** to continue. You should see the following screen:
Provide your domain name and hit **Tab** and **Enter** to finish the installation.
The default Postfix configuration file is located at /etc/postfix/main.cf. Before configuring Postfix, it is recommended to back up this file:
```
mv /etc/postfix/main.cf /etc/postfix/main.cf.bak
```
Next, create a new Postfix configuration file as shown below:
```
nano /etc/postfix/main.cf
```
Add the following lines:
```
# GENERAL SETTINGS
smtpd_banner = $myhostname ESMTP $mail_name
biff = no
append_dot_mydomain = no
readme_directory = no
# SMTP SETTINGS
smtp_use_tls=yes
smtp_tls_security_level = may
smtp_tls_session_cache_database = btree:${data_directory}/smtp_scache
# SMTPD SETTINGS
smtpd_use_tls=yes
smtpd_tls_security_level = may
smtpd_tls_session_cache_database = btree:${data_directory}/smtpd_scache
smtpd_tls_cert_file=/etc/letsencrypt/live/email.example.com/fullchain.pem
smtpd_tls_key_file=/etc/letsencrypt/live/email.example.com/privkey.pem
smtpd_relay_restrictions = permit_mynetworks, permit_sasl_authenticated, reject_unauth_destination
# SASL SETTINGS
smtpd_sasl_auth_enable = yes
smtpd_sasl_type = dovecot
smtpd_sasl_path = private/auth
# VIRTUAL MAIL BOX AND LMTP SETTINGS
virtual_transport = lmtp:unix:private/dovecot-lmtp
virtual_mailbox_domains = /etc/postfix/virtual_mailbox_domains
# OTHER SETTINGS
myhostname = email.example.com
myorigin = /etc/mailname
mydestination = localhost.$mydomain, localhost
relayhost =
mynetworks = 127.0.0.0/8 [::ffff:127.0.0.0]/104 [::1]/128
mailbox_size_limit = 0
recipient_delimiter = +
inet_interfaces = all
inet_protocols = all
alias_maps = hash:/etc/aliases
alias_database = hash:/etc/aliases
```
Save and close the file.
Next, you will need to define your domain in the /etc/postfix/virtual_mailbox_domains file:
```
nano /etc/postfix/virtual_mailbox_domains
```
Add the following line:
```
example.com #domain
```
Save and close the file then create another file:
```
nano /etc/mailname
```
Add your FQDN.
```
email.example.com
```
Next, convert the file to a format that Postfix can understand with the following command:
```
postmap /etc/postfix/virtual_mailbox_domains
```
Next, edit the Postfix master configuration file:
```
nano /etc/postfix/master.cf
```
Uncomment the following line:
```
submission inet n - y - - smtpd
```
Save and close the file when you are finished.
## Step 5 – Install and Configure Dovecot
Next, you will need to install Dovecot with other required packages. You can install them using the following command:
```
apt-get install dovecot-core dovecot-imapd dovecot-pop3d dovecot-lmtpd -y
```
Next, you will need to define the Dovecot mail location to communicate with Postfix and virtual mailbox domains. You can define it by editing /etc/dovecot/conf.d/10-mail.conf file:
```
nano /etc/dovecot/conf.d/10-mail.conf
```
Find the following line:
```
mail_location = mbox:~/mail:INBOX=/var/mail/%u
```
And replace it with the following:
```
mail_location = maildir:/var/mail/vhosts/%d/%n
```
Save and close the file.
Next, create the Dovecot vhosts directory and the sub-directory for your domain name.
```
mkdir /var/mail/vhosts
mkdir /var/mail/vhosts/example.com
```
Next, create a vmail user and a group, and assign the ownership of the directories to the vmail user.
```
groupadd -g 5000 vmail
useradd -r -g vmail -u 5000 vmail -d /var/mail/vhosts -c "virtual mail user"
chown -R vmail:vmail /var/mail/vhosts/
```
Next, edit the Dovecot master configuration file and enable IMAP and POP3 secure services:
```
nano /etc/dovecot/conf.d/10-master.conf
```
Find the following lines:
```
inet_listener imaps {
#port = 993
#ssl = yes
}
```
And replace them with the following:
```
inet_listener imaps {
port = 993
ssl = yes
}
```
On the same file, find the following lines:
```
inet_listener pop3s {
#port = 995
#ssl = yes
}
```
And replace them with the following:
```
inet_listener pop3s {
port = 995
ssl = yes
}
```
Next, find the following lines:
```
service lmtp {
unix_listener lmtp {
#mode = 0666
}
```
And replace them with the following:
```
service lmtp {
unix_listener /var/spool/postfix/private/dovecot-lmtp {
mode = 0600
user = postfix
group = postfix
}
```
Next, find the following lines:
```
service auth {
# Postfix smtp-auth
#unix_listener /var/spool/postfix/private/auth {
# mode = 0666
#}
}
```
And replace them with the following:
```
service auth {
...
#Postfix smtp-auth
unix_listener /var/spool/postfix/private/auth {
mode = 0666
user=postfix
group=postfix
}
```
Save and close the file when you are finished.
Next, set up the Dovecot authentication process by editing the file /etc/dovecot/conf.d/10-auth.conf:
```
nano /etc/dovecot/conf.d/10-auth.conf
```
Uncomment the following line:
```
disable_plaintext_auth = yes
```
On the same file, find the following line:
```
auth_mechanisms = plain
```
And replace it with the following:
```
auth_mechanisms = plain login
```
Next, comment out the following line to disable the default Dovecot behaviour for authenticating users.
```
#!include auth-system.conf.ext
```
Next, uncomment the following line to enable password file configuration.
```
!include auth-passwdfile.conf.ext
```
Save and close the file when you are finished.
Next, edit the /etc/dovecot/conf.d/auth-passwdfile.conf.ext file:
```
nano /etc/dovecot/conf.d/auth-passwdfile.conf.ext
```
Change the file as shown below:
```
passdb {
driver = passwd-file
args = scheme=PLAIN username_format=%u /etc/dovecot/dovecot-users
}
userdb {
driver = static
args = uid=vmail gid=vmail home=/var/mail/vhosts/%d/%n
}
```
Save and close the file.
Next, create a password file for the user you want to assign an email account:
```
nano /etc/dovecot/dovecot-users
```
Add the following lines:
```
admin@example.com:admin@123
```
Save and close the file.
## Step 6 – Configure Dovecot to Use Let’s Encrypt SSL
Next, you will need to configure Dovecot to work with SSL. You can do it by editing the file /etc/dovecot/conf.d/10-ssl.conf:
```
nano /etc/dovecot/conf.d/10-ssl.conf
```
Find the following line:
```
ssl = yes
```
Replace it with the following:
```
ssl = required
```
Next, find the following lines:
```
#ssl_cert =
Alias /mail /usr/share/roundcube
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
```
Save and close the file, then restart the Apache web service to apply the changes:
```
systemctl restart apache2
```
## Step 8 – Access Roundcube Webmail
Now, open your web browser and type the URL h**http://email.example.com/mail.**You will be redirected to the Roundcube login page:
Provide your username and password which you have defined in the Dovecot password file and click on the **Login** button. You should see the Roundcube default dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed and configured a mail server with Postfix, Dovecot and Roundcube. You can now send and receive email from the Roundcube webmail dashboard. Ready to get started with Postfix, Dovecot and Roundcube? Try it out on a [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net today!
Learn more about our [VPS hosting](https://www.atlantic.net/vps-hosting/) services and [Virtual private servers.](https://www.atlantic.net/vps-hosting/)
---
# How to Choose the Right VPS Plan for Your Business
> URL: https://www.atlantic.net/vps-hosting/how-to-choose-the-right-vps-plan-for-your-business/ | Published: 2020-03-27 | Updated: 2025-09-19 | Author: Richard Bailey
Cloud Virtual Private Servers (VPS) are available in many different flavors, and the service providers offer an abundance of plans for customers to choose from when deploying a server.
When requisitioning a VPS, you are in control of choosing the operating system, usually Windows or a Linux distribution, and you can also opt for a pre-imaged auto-deployed application server, such as WordPress, cPanel, Docker or NodeJS.
Importantly, you also get to choose the performance of the Cloud VPS you are creating; this is done by selecting a VPS Plan that suits your needs.
## VPS Hosting Models & Plans
A Cloud VPS offers the perfect blend between a traditional VPS and dedicated hosting, which has made it an extremely popular service offering for the service providers and hosting companies. With a Cloud VPS, not only do you benefit greatly from the cost savings associated with the legacy hosting platforms, but you also get the guaranteed CPU, disk, and memory resources from a dedicated cloud platform.
This is why a growing number of organizations are migrating private, personal, and business workloads to Cloud VPS. Atlantic.Net’s sales and support teams are often asked, “What plan should I choose? Do I need all this CPU power? Do I need extra memory (RAM)?” IT Professionals and System administrators will be able to answer these questions, but not everyone is a computer expert. For this reason, we have put together this guide to offer you the background knowledge you need to make an informed decision on what plan best suits your requirements.
## What Is a Cloud VPS Plan?
Most service providers offer Cloud VPS under a variety of available plans. These plans typically include a **General Purpose** collection of standardized servers which are designed and suitable for multiple roles. Plans are also available for I/O intensive applications; these are **Storage Optimized** servers whose main benefit is disk performance. Providers also offer plans for **Memory-Optimized** or **Compute-Optimized** workloads.
Cloud VPS plans allow you to choose a server that will provide the specified resources detailed above, guaranteed. A VPS is a virtual machine that is hosted on a virtual hypervisor. Virtual hypervisor technology allows the VPS to be deployed automatically, using pre-defined build scripts. The VPS is then built and allocated to a physical host that has the resources specified in the plan.
The selected plan will include the preferred number of vCPUs available on the VPS. One vCPU is a single-core, while 8 vCPUs are 8 cores. The host will allocate CPU reservations against the physical hosts CPU [sockets, cores and threads](https://stackoverflow.com/questions/40163095/what-is-socket-core-threads-cpu).
The physical hosts will have huge allocations of superfast memory (RAM), and this physical memory is logically divided up between the VPS guests. If you select a plan with 4GB RAM, your VPS is reserved 4GB of physical RAM from the stack. Your VPS will have exclusive access to that 4GB of allocated memory.
VPS plans also include a multitude of disk storage options. Not only do these options include the size of storage allocated to the VPS, but also the type and speed. Storage allocations can be super fast Solid State Disk (SSD) storage, advanced premium (High I/O) dedicated local SSD storage, or extensive, flexible, and robust Secure Block Storage (SBS).
The VPS network bandwidth allocated by the cloud provider must be taken into consideration when setting up a VPS. All inbound (ingress) network traffic to a VPS is usually free, but outbound (egress) network traffic is chargeable. Your customers will use egress network allocations to access data on your server, for example, when accessing your website. Most VPS plans will include a set amount of “free” network bandwidth. This might be a small amount or a substantial allocation; the best option for you depends purely on your usage expectations.
## Plan Flexibility
You can always upgrade your Cloud VPS plan at any time. This adds a lot of flexibility; as your business grows organically, so can your VPS. Essentially, you can re-provision the server with more CPU, disk, memory and network bandwidth. There are a few “gotchas” with this technology; commonly, the operating system will need to be re-imaged when upgrading your VPS. But if you have planned your VPS design, you can save your data on an SBS volume, or if you have a backup or snapshot, you can simply move the data volume onto the new server.
Backup restoration is a much simpler way of restoring data to a newly reprovisioned server. Simply restore your system over the top of your new server from backup. This approach gets you back up and running in next to no time. A VPS can scale up by reprovisioning to a new plan with better performance, but the VPS can also scale out meaning that you can implement a cluster of virtual private servers to work together to provide additional compute resources.
## General Purpose VPS
General-purpose VPS plans are the most commonly used and deployed. These types of VPS are for general, everyday workloads. The use case scenario for a general-purpose VPS varies massively; for example, you might provision this type of plan to host a website or a workstation.
Just because these servers are labeled general purpose does not mean that they are slow or underperforming. Our SSD-backed servers are ultra-fast, no matter what resources you allocate. You can purchase a VPS for as little as $10 per month, and you might be surprised how powerful the smallest plan works out. If using Linux, the servers are more than powerful enough to run WordPress, cPanel, and basic MySQL applications.
The general purpose plan goes up to 64GB RAM, 20vCPU and 650GB SSD. These kinds of resources are powerful enough for enterprise-grade Docker installations, backup servers, or even powerful SQL database servers.
## Storage Optimized VPS
A VPS optimized for storage does exactly as the name suggests; you not only have access to dedicated, high-performance professional SSD hardware, but also can allocate up to 4TB of SSD storage to your VPS.
For obvious reasons, we do not recommend running just Windows Server on a 4TB SSD; these storage optimized servers are recommended for I/O intensive applications such as Microsoft SQL Server and, in particular, SQL ETL data transformation jobs. The super-fast I/O gives the VPS the capability to crunch huge amounts of data in no time at all.
Storage Optimized VPS use local SSD drives and are great for ultra-low latency, mission-critical tasks. Most commonly, our customers use these servers for distributed databases and data analytics.
## Memory-Optimized VPS
Customers that need servers with a large amount of volatile memory (RAM) can opt for the Memory Optimized VPS, which offers not only the best prices for higher RAM amounts, but also large amounts of uninterrupted memory sizes ranging from 16GB to 128GB.
These are designed for applications that require extremely high memory I/O or use applications that reside in memory for better performance. This type of VPS suits database applications and programs like Apache Spark.
Each server uses SSDs which enhance the performance of memory-optimized servers, and the SSDs can be used to dump data in the event of an error.
## Compute-Optimized VPS
An Optimized CPU VPS will provide your applications with a huge amount of compute power. With this type of VPS, you have access to the optimized Intel CPU hosting platform, allowing users to process vast amounts of information instantaneously.
CPU optimized VPSes are perfect for data analytics, video processing, gaming servers, and Docker worker nodes. SSD storage and ultra-fast memory create a server package that can keep up with the biggest of workloads.
## What Next?
Clearly the array of choices for a VPS is vast, and there are many use cases for each type of VPS. Usually, customers opt for plans with lower specifications, knowing that they can upgrade the plan if and when an upgrade is needed.
Cloud VPS offers greater levels of control over your server. Our hosting environment is simple to use, but powerful and flexible. Most importantly, your resources are guaranteed without disruption.
Share your vision with us and we will develop a hosting environment tailored to your needs!
Contact an advisor at 866-618-DATA (3282) or get started on our [VPS Hosting](https://www.atlantic.net/vps-hosting/) page.
---
# Overview of CCPA and GDPR
> URL: https://www.atlantic.net/vps-hosting/overview-of-ccpa-and-gdpr/ | Published: 2020-03-30 | Updated: 2025-09-19 | Author: Richard Bailey
The California Consumer Privacy Act (CCPA), and the General Data Protection Regulations (GDPR) are both privacy acts recently passed to update outdated laws regarding how personal information is handled, stored and processed in the digital age. Since the proliferation of internet services, mobile telecommunications, and social media, campaigners have been demanding changes to how businesses handle personal information.
CCPA was passed in 2018 and came into force on January 1st, 2020. GDPR was passed into law in May 2018. Both legislations have similar recommendations and requirements. GDPR is focused on the personal information of European citizens, and CCPA relates to the personal information of California residents.
Importantly, both legislations have a shared synergy that impacts businesses on both sides of the Atlantic. Any business in the United States that processes European personal information and any business in Europe that processes US personal information must adhere to each legislation’s guidelines to be compliant with the privacy rules.
## What is CCPA?
CCPA protects the private information of California residents in the United States. This includes data about the person’s identity, any sensitive health information, biometric data, mobile geolocation data, and any financial or asset information. The aim of the privacy act is to limit sensitive information disclosures or unexpected leaks caused by data breaches.
CCPA has been designed to give consumers control of their personal information and reinforce the penalties for any breaches of information, be this by negligence or as a result of a data hack.
The legislation’s purpose is to enforce consumer rights and give the consumer new rights about their data. This includes the right to know exactly what information is held on a person by a business. This is why you can now go to sites like Google and Facebook and download detailed archives of what information they hold on you.
California residents also have the right to access and view the data held on them, and importantly, the right to have the data deleted. Rights to opt-in or opt-out of data collection have been created. Other key elements include the right to equal service and price, and the right to seek damages if personal information is breached.
The new rules put a number of new requirements upon businesses that process personal data. They must be able to provide access to personal information, delete personal information on request, and evidence its destruction. They must also introduce consent management practices. This is commonly seen on websites where companies share information with third parties. The organization has a duty to disclose what data is shared.
CCPA gives the individual control over what information can or cannot be sold about them. Businesses are required to conduct data inventory exercises to learn in-scope personal data and instances of “selling” data. As a result, updating service-level agreements with third-party data processors is needed to be compliant.
Remediation of information security gaps and system vulnerabilities must be resolved promptly by implementing data governance reinforcement and data identification programs. If there is data held that is out of scope, it must be deleted.
## What is GDPR?
GDPR was designed for European citizens but affects every entity processing EU data. Its main purpose was to standardize data protection laws of all EU member states.
There are seven key principles of GDPR legislation. These focus on the lawfulness of retaining personal information and ensuring it is stored in a fair and transparent manner. The data must be retained for a specific reason and serve a specific purpose. Personal data cannot be retained indefinitely and must be destroyed once it has served its purpose.
Organizations must also commit to data minimization, retaining only recent and relevant information that is accurate. They must retain data integrity and ensure the confidentiality of private information is upheld.
EU citizens have many new rights since the introduction of GDPR. These rights lay the foundation of what third parties can and cannot do with personal information. People have the right to be informed of what personal data is being held by the business, and the individual has the right to view and access this information. If necessary, they have the right to correct the data.
EU citizens can request personal information is deleted and restrict how personal information is processed. They have the right to object as well as rights in relation to automated decision making and profiling, such as credit card acceptability criteria.
## CCPA vs GDPR
It is obvious to see the striking similarities between CCPA and GDPR. CCPA could be considered the US counterpart of GDPR. There are however some significant differences. [GDPR affects data controllers and data processors](https://www.atlantic.net/vps-hosting/gdpr-compliance-for-global-managed-service-providers/) inside and outside of the European Union, however, CCPA only regulates companies “[doing business](https://www.financierworldwide.com/the-california-consumer-privacy-act-and-the-gdpr-two-of-a-kind#.XkxF9-j7SUk)” in California.
Other rules exist such as CCPA only being applicable to companies with gross revenue above $25 million USD, and those that process the personal information of more than 50,000 California residents. The penalties given for breaching either legislation are also quite different. GDPR is up to 4% of turnover, or 20 million Euro (whichever is greater). CCPA is specifically $2500 per record for unintentional violations and $7500 for intentional violations.
There are other subtle differences, but importantly both legislation set out with the same objective, which is to enhance and protect personal and private information. Both laws enforce the notion that businesses cannot harvest whatever data they choose. Data has significant value and many tech giants in Silicon Valley have made huge profits selling personal information. CCPA and GDPR have identified this and have acted to protect each of us.
---
# How to Protect Apache and SSH With Fail2Ban on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-protect-apache-and-ssh-with-fail2ban-on-centos-8/ | Published: 2020-03-31 | Updated: 2023-11-27 | Author: Hitesh Jethva
If you’re a system administrator, then protecting your server from different kinds of attacks is an essential part of your job; Fail2Ban firewall can help you achieve this. Fail2Ban is an intrusion prevention system written in the Python language used to block malicious IPs that are trying to breach your system security. It works by scanning various log files and blocking the IPs that are trying to make frequent login attempts for a specified bantime. It also allows you to monitor the strength and frequency of attacks. Due to its simplicity, it is considered the preferred software to secure your server from DOS, DDOS, and brute-force attacks.
In this tutorial, we will show you how to secure an SSH and Apache server with Fail2Ban on CentOS 8.
## Step 1 – Install Fail2Ban
By default, Fail2Ban is not available in the CentOS 8 default repository, so you will need to install the EPEL repository in your system.
You can install it with the following command:
```
dnf install epel-release -y
```
After installing the EPEL repository, you can install Fail2Ban with the following command:
```
dnf install fail2ban -y
```
Once installed, start the Fail2Ban service and enable it to start after system reboot:
```
systemctl start fail2ban
systemctl enable fail2ban
```
## Step 2 – Secure SSH with Fail2Ban
In this section, we will learn how to secure the SSH server with Fail2Ban.
**Configure Fail2Ban for SSH**
By default, all pre-set jails are located inside /etc/fail2ban/jail.conf file. This is not an appropriate way to edit the default jail.conf file. You should create a separate jail.local file for each service that you want to configure.
You can create a jail.local file for SSH with the following command:
```
nano /etc/fail2ban/jail.local
```
Add the following lines:
```
[DEFAULT]
ignoreip = your-server-ip
bantime = 300
findtime = 300
maxretry = 3
banaction = iptables-multiport
backend = systemd
[sshd]
enabled = true
```
Save and close the file when you are finished. Then, restart the Fail2Ban service to apply the changes:
```
systemctl restart fail2ban
```
You can now check the status of SSH jail with the following command:
```
fail2ban-client status
```
You should see that an SSH jail is enabled:
```
Status
|- Number of jail: 1
`- Jail list: sshd
```
**A brief explanation of each parameter is shown below:**
- **ignoreip**: Used to define the IP addresses that you want to be ignored.
- **bantime**: Used to define a number of seconds the IP address will be banned for.
- **findtime**: Used to define the amount of time between login attempts before the IP is banned.
- **maxretry**: Used to define the number of attempts to be made before the IP address is banned.
- **banaction**: Banning action.
- **enabled**: This option enables the protection for SSH service.
**Test SSH Against Password Attacks**
At this point, Fail2Ban is installed and configured. It’s time to test whether it is working or not.
To do so, go to the remote machine and try to SSH to the server IP address:
```
ssh root@server-ip
```
You will be asked to provide the root password. Type the wrong password again and again. Once you reach the login attempt limit, your IP address will be blocked.
You can verify your blocked IP address with the following command:
```
fail2ban-client status sshd
```
You should see your blocked IP in the following output:
```
Status for the jail: sshd
|- Filter
| |- Currently failed: 7
| |- Total failed: 39
| `- Journal matches: _SYSTEMD_UNIT=sshd.service + _COMM=sshd
`- Actions
|- Currently banned: 1
|- Total banned: 2
`- Banned IP list: 190.8.80.42
```
You can also check the SSH log for failed logins:
```
tail -5 /var/log/secure | grep 'Failed password'
```
You should see the following output:
```
Mar 1 03:55:03 centos8 sshd[11196]: Failed password for invalid user bpadmin from 190.8.80.42 port 55738 ssh2
```
You can also block and unblock a specific IP address manually.
For example, to unblock the IP 190.8.80.42, run the following command:
```
fail2ban-client set sshd unbanip 190.8.80.42
```
To block the IP 190.8.80.42, run the following command:
```
fail2ban-client set sshd banip 190.8.80.42
```
## Step 3 – Secure Apache with Fail2Ban
You can also secure the Apache webserver from different kinds of attacks. You will need to configure jail.local file for Apache as shown below:
```
nano /etc/fail2ban/jail.local
```
Add the following lines at the end of the file:
```
[apache-auth]
enabled = true
port = http,https
logpath = %(apache_error_log)s
[apache-badbots]
enabled = true
port = http,https
logpath = %(apache_access_log)s
bantime = 48h
maxretry = 1
[apache-noscript]
enabled = true
port = http,https
logpath = %(apache_error_log)s
```
Save and close the file when you are finished. Then, restart the Fail2Ban service to implement the changes:
```
systemctl restart fail2ban
```
You can now verify the status of all jails with the following command:
```
fail2ban-client status
```
You should see the following output:
```
Status
|- Number of jail: 5
`- Jail list: apache-auth, apache-badbots, apache-noscript, sshd
```
**A brief explanation of each jail is shown below:**
- **apache-auth**: This jail is used to protect Apache from failed login attempts.
- **apache-badbots**: This jail is used to ban hosts which agent identifies spammer robots crawling the web for email addresses.
- **apache-noscript**: Used to block the IP which is trying to search for scripts on the website to execute.
## Conclusion
In the above tutorial, we learned how to protect SSH and Apache server with Fail2Ban. It is a very useful intrusion prevention system that adds extra security to your Linux system. You are now able to configure Fail2Ban that will suit your specific security needs. Get started with Fail2Ban today with [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install Ansible Server on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-ansible-server-on-ubuntu-18-04/ | Published: 2020-04-01 | Updated: 2023-11-22 | Author: Hitesh Jethva
Ansible is an automation tool set that works extremely well with Linux-based servers, but is also compatible with other cloud servers, such as Windows and VMware (to name a few). Ansible is an agentless application that only requires Python to function, which is a default application in nearly all Linux distributions.
Ansible its great at automating administrative tasks and creating a desired state infrastructure (ensuring all servers are the same).
Ansible works using the SSH protocol, so you don’t need any software or agent on remote servers. It is a great alternative to other automation tools, including Chef and Puppet.
In this article, we will show you how to install and configure Ansible on Ubuntu 18.04 server.
## Prerequisites
- A fresh Ubuntu 18.04 [VPS](https://www.atlantic.net/vps-hosting/)
- Preferably, you will have a few Linux test servers (Ubuntu or Debian)
- A root password configured on your server
## Step 1 – Configure SSH Key-based Authentication
Ansible uses SSH to retrieve information from the remote hosts. You will need to set up key-based authentication for the remote hosts so the Ansible server can communicate with remote hosts without entering SSH password.
First, generate an SSH key on Ansible server with the following command:
```
ssh-keygen -t rsa
```
You should get the following output:
```
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Created directory '/root/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:HzUXrR+ltn9w0mwz5+hKeFzEOPcJrLTKi9C72Y7elAE root@ubuntu1804
The key's randomart image is:
+---[RSA 2048]----+
| .. |
| .o .o|
| E .=o=o.|
| . ..o*=o.|
| S..o ..*o|
| . ..++ .+oB|
| . . =o + O+|
| . O .o . +|
| .Bo= .o. .|
+----[SHA256]-----+
```
Next, copy the generated key to the remote hosts with the following command:
```
ssh-copy-id -i ~/.ssh/id_rsa.pub root@your-remote-host-ip
```
Next, check the SSH password-less login with the following command:
```
ssh root@your-remote-host-ip
```
## Step 2 – Install Ansible
By default, Ansible is not available in the Ubuntu 18.04 default repository, so you will need to add Ansible PPA to your system.
You can add Ansible PPA with the following command:
```
apt-add-repository ppa:ansible/ansible
```
After adding Ansible PPA, update the repository and install Ansible with the following command:
```
apt-get update -y
apt-get install ansible -y
```
Once the installation has been completed, you can proceed to the next step.
## Step 3 – Configure Ansible Hosts
Next, you will need to configure your Ansible hosts file to define the remote servers. You can edit the /etc/ansible/hosts with the following command:
```
nano /etc/ansible/hosts
```
You can add single hosts or group of hosts, as shown below:
```
[webservers]
webserver1 ansible_ssh_host=192.168.1.2 ansible_ssh_port=22 ansible_ssh_user=root
webserver2 ansible_ssh_host=192.168.1.3 ansible_ssh_port=22 ansible_ssh_user=root
[databaseservers]
dbserver1 ansible_ssh_host=192.168.1.4 ansible_ssh_port=22 ansible_ssh_user=root
```
Save and close the file when you are finished.
In the above file, webserver1 and webserver2 are used to define a webserver IP address, SSH port and username, while dbserver1 is used to define a database server IP Address, SSH port and username.
Next, disable the Python warning by editing the file /etc/ansible/ansible.cfg:
```
nano /etc/ansible/ansible.cfg
```
Add the following line below [defaults]:
```
deprecation_warnings=False
```
Save and close the file when you are finished.
At this point, your Ansible server is ready to manage your web server and database server.
## Step 4 – Test Ansible
After setting up the Ansible server, it’s time to test the connectivity of all Ansible hosts.
On the Ansible server, run the following command to test the connectivity of all hosts:
```
ansible -m ping all
```
If everything is fine, you should get the following output:
To test the connectivity of specific hosts like dbserver1, run the following command:
```
ansible -m ping dbserver1
```
You should see the following output:
To test the connectivity of a group of hosts like [webservers], run the following command:
```
ansible -m ping webservers
```
You should see the following output:
## Step 5 – Ansible Advanced Commands
You can execute any command on a remote server over SSH from the Ansible server.
For example, to check disk usage of all Ansible hosts, run the following command:
```
ansible -m shell -a "df -h" all
```
This command will execute “df -h” command on all remote hosts and give the following output:
You can list all databases on dbserver1 hosts with the following command:
```
ansible -m shell -a "mysql -u root -padmin@123 -e 'show databases;'" dbserver1
```
You should see the following output:
## Conclusion
In the above tutorial, we learned how to install Ansible on Ubuntu 18.04 server. We also learned how to manage multiple servers with Ansible. You can now easily manage your entire infrastructure with Ansible – try it out with [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install and Use Docker on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-use-docker-on-centos-8/ | Published: 2020-04-02 | Updated: 2023-11-17 | Author: Hitesh Jethva
Sometimes when designing an application, it will work perfectly on your machine, but upon moving it into production, the application fails to work with the same performance or same optimization. This frustrating experience can be mitigated by using Docker.
Docker is an open-source container management service that allows you to build, ship and run applications on a server, cloud, or laptop, or even ship it into a container that can be deployed anywhere.
To summarize, Docker simplifies the process of managing application processes in containers. Docker has recently become very popular in recent times due to its ability to run applications anywhere, irrespective of the host operating system.
In this tutorial, we will show you how to install and use Docker on CentOS 8.
## Install Docker
By default, the latest version of Docker is not available in the CentOS 8 default repository. You can add and enable the official Docker CE repository with the following command:
```
dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
```
After adding the repository, you can verify the repository with the following command:
```
dnf repolist -v | grep docker
```
You should get the following output:
Now, install the appropriate version of Docker using the –nobest option as shown below:
```
dnf install docker-ce --nobest -y
```
After installing Docker, start the Docker service and enable it to start after system reboot:
```
systemctl start docker
systemctl enable docker
```
Next, verify the status of the Docker service using the following command:
```
systemctl status docker
```
You should get the following output:
## Docker Basic Commands
You can check the installed version of Docker using the following command:
```
docker --version
```
You should get the following output:
```
Docker version 19.03.6, build 369ce74a3c
```
To check the system-wide information on Docker, run the following command:
```
docker info
```
You should see the following screen:
You can check all information about the container with the following command:
```
docker inspect "Container-ID"
```
You can display all options available with docker command using the following command:
```
docker --help
```
You should see the following screen:
## Start the Docker Container in Interactive Mode
First, pull the Ubuntu image from the Docker hub repository with the following command:
```
docker pull ubuntu
```
You should see the following output:
```
Using default tag: latest
latest: Pulling from library/ubuntu
423ae2b273f4: Pull complete
de83a2304fa1: Pull complete
f9a83bce3af0: Pull complete
b6b53be908de: Pull complete
Digest: sha256:04d48df82c938587820d7b6006f5071dbbffceb7ca01d2814f81857c631d44df
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest
```
You can now verify the image with the following command:
```
docker images
```
You should see the following output:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu latest 72300a873c2c 8 days ago 64.2MB
```
Now, start the Ubuntu container using the downloaded image in interactive mode with the following command:
```
docker run -it ubuntu
```
Once the container started, you should get the Ubuntu container shell. You can now run the update command inside the shell to update the system.
You can exit from the container with the following command:
```
exit
```
You can list the active container by running the following command:
```
docker ps
```
Output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
```
You can list both active and inactive containers by running the following command:
```
docker ps -a
```
Output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
96fdc35ac495 ubuntu "/bin/bash" About a minute ago Exited (0) 24 seconds ago stupefied_keller
```
## Start the Docker Container in Detached Mode
Docker allows you to search for images available in the Docker Hub.
For example, you can search for Nginx images using the following command:
```
docker search nginx
```
You should see the following screen:
Now, download and start Nginx container in detached mode with the following command:
```
docker run -itd nginx
```
This command will download the Nginx image from the Docker Hub repository and start the container in detached mode as shown below:
```
Unable to find image 'nginx:latest' locally
latest: Pulling from library/nginx
68ced04f60ab: Pull complete
c4039fd85dcc: Pull complete
c16ce02d3d61: Pull complete
Digest: sha256:380eb808e2a3b0dd954f92c1cae2f845e6558a15037efefcabc5b4e03d666d03
Status: Downloaded newer image for nginx:latest
4eeabeb599d079795c1acd4822420c8513f12d6264176ea0685f9028f8bfd014
```
You can now verify the running container using the following command:
```
docker ps
```
You should see your Nginx container in the following output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4eeabeb599d0 nginx "nginx -g 'daemon of…" 30 seconds ago Up 28 seconds 80/tcp pensive_ptolemy
```
## Manage the Docker Container
In this section, we will show you some useful Docker commands that will help you to manage a Docker container easily.
To start the Docker container, use the following syntax:
```
docker start "Container-ID"
```
First, find the container id with the following command:
```
docker ps -a
```
Output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4eeabeb599d0 nginx "nginx -g 'daemon of…" 19 minutes ago Exited (0) About a minute ago pensive_ptolemy
96fdc35ac495 ubuntu "/bin/bash" 22 minutes ago Exited (0) About a minute ago stupefied_keller
```
Next, start the container with id **4eeabeb599d0** as shown below:
```
docker start 4eeabeb599d0
```
Now, check the running container with the following command:
```
docker ps
```
You should see the following output:
```
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4eeabeb599d0 nginx "nginx -g 'daemon of…" 20 minutes ago Up 36 seconds 80/tcp pensive_ptolemy
```
To pause the running container, run the following command:
```
docker pause "Container-ID"
```
To stop the running container, run the following command:
```
docker stop "Container-ID"
```
To stop all running containers, run the following command:
```
docker stop $(docker ps -a -q)
```
To delete the container, you will need to stop it first. Then, run the following command to delete it:
```
docker rm "Container-ID"
```
To remove all stopped containers, run the following command:
```
docker rm $(docker ps -a -q)
```
To remove the Docker image, run the following command:
```
docker rmi "Image-ID"
```
To remove all unused Docker images, run the following command:
```
docker rmi $(docker images -q -a)
```
To remove any stopped container and all unused images, run the following command:
```
docker system prune -a
```
You should see the following output:
```
WARNING! This will remove:
- all stopped containers
- all networks not used by at least one container
- all images without at least one container associated to them
- all build cache
Are you sure you want to continue? [y/N] y
Deleted Containers:
4eeabeb599d079795c1acd4822420c8513f12d6264176ea0685f9028f8bfd014
96fdc35ac49588aea490833a1ca66387ee9617217ee29715043291db1942b219
Deleted Images:
untagged: ubuntu:latest
untagged: ubuntu@sha256:04d48df82c938587820d7b6006f5071dbbffceb7ca01d2814f81857c631d44df
deleted: sha256:72300a873c2ca11c70d0c8642177ce76ff69ae04d61a5813ef58d40ff66e3e7c
deleted: sha256:d3991ad41f89923dac46b632e2b9869067e94fcdffa3ef56cd2d35b26dd9bce7
deleted: sha256:2e533c5c9cc8936671e2012d79fc6ec6a3c8ed432aa81164289056c71ed5f539
deleted: sha256:282c79e973cf51d330b99d2a90e6d25863388f66b1433ae5163ded929ea7e64b
deleted: sha256:cc4590d6a7187ce8879dd8ea931ffaa18bc52a1c1df702c9d538b2f0c927709d
untagged: nginx:latest
untagged: nginx@sha256:380eb808e2a3b0dd954f92c1cae2f845e6558a15037efefcabc5b4e03d666d03
deleted: sha256:a1523e859360df9ffe2b31a8270f5e16422609fe138c1636383efdc34b9ea2d6
deleted: sha256:4d5d91d27654e1c0284efbe6617ab628d30f2be44301460f94ca811d0ea14f44
deleted: sha256:4245b7ef9b70e3b2975ed908c7d68ce5f03972d8be702b0ed491e32445b42b8f
deleted: sha256:f2cb0ecef392f2a630fa1205b874ab2e2aedf96de04d0b8838e4e728e28142da
Total reclaimed space: 218.9MB
```
## Conclusion
Congratulations! You have successfully installed Docker on CentOS 8 and you have enough knowledge to install and manage the Docker containers. You can now explore Docker and start developing your first project inside the Docker container on a [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Install and Use Git on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-use-git-on-ubuntu-18-04/ | Published: 2020-04-03 | Updated: 2024-06-11 | Author: Hitesh Jethva
Git is the most popular version control system. Now used by developers around the world, it was originally developed by Linus Torvalds for Linux kernel development. A version control system is used to store and manage every revision of your code and files. Git is used by many companies to collaborate on source code, manage releases, and roll back to previous versions when bugs are discovered.
Git keeps track of each change that you have made to a file or code and allows you to roll back those changes. For example, if you are editing code on your system and want to delete a section of code, you can use a version control system to restore that deleted code in the future. Git also allows multiple users to work on the same files at the same time.
In this tutorial, we will show you how to install and use the Git version control system on Ubuntu 18.04.
## Install Git
By default, Git is available in the Ubuntu 18.04 default repository. You can install it by just running the following command:
```
apt-get install git -y
```
Once the installation has been completed, you can check the version of the Git using the following command:
```
git --version
```
You should see the following output:
```
git version 2.23.0
```
## Configure Git
Before configuring Git, you will need to create an account on GitHub. You can create a new account using the URL [github.com](https://github.com/) as shown below:
After creating an account on GitHub, open your terminal and run the following command that matches your GitHub username and email:
```
git config --global user.name "YOUR_USERNAME"
git config --global user.email "YOUR@EMAIL”
```
Next, verify the configuration changes with the following command:
```
git config --list
```
You should see the following output:
```
user.name=YOUR_USERNAME
user.email=YOUR@EMAIL
```
## Create a New Repository on GitHub
Next, log in to your GitHub account as shown below:
Click on the **New** button to create a repository. You should see the following page:
Provide a *repository name*, description and click on the **Create** **repository** button. Once the repository is created, make a note of your **Git Repo Address** at the Quick Setup page.
## Use Git with Local and Remote Repositories
Next, open your terminal and create a new directory that matches your project, as shown below:
```
mkdir atlanticapp
```
Next, change the directory to atlanticapp and initiate Git for this directory with the following command:
```
cd atlanticapp
git init
```
You should see the following output:
```
Initialized empty Git repository in /home/vyom/atlanticapp/.git/
```
Next, connect the remote GitHub repository to the local system with the following command:
```
git remote add origin https://github.com/YOUR_GIT_REPO.git
```
Next, create a new file named test.html as shown below:
```
nano test.html
```
Add the following contents:
```
My Atlantic App
This is my first atlantic App.
```
Save and close the file, then run the following command to adds changes in the working directory to the staging area:
```
git add test.html
```
Next, run the following command to save your changes to the local repository:
```
git commit -m "This my first version of test.html file"
```
You should see the following output:
```
[master (root-commit) 4d7a3de] This my first version of test.html file
1 file changed, 4 insertions(+)
create mode 100644 test.html
```
Next, run the following command to upload local repository content to a remote repository.
```
git push origin master
```
You will be asked to provide your GitHub username and password, as shown below:
```
Username for 'https://github.com': YOUR_USERNAME
Password for 'https://github.com’: YOUR_PASSWORD
```
After providing the correct details, your local repository content has been added to the remote repository:
```
Counting objects: 3, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 292 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/hitjethva/exampleapp.git
* [new branch] master -> master
```
To verify it, go to the GitHub account page and refresh it. You should see the added file in the following screen:
You can also view which remote servers are configured using the following command:
```
git remote -v
```
You should see the names of your remote repositories in the following output:
```
origin https://github.com/hitjethva/exampleapp.git (fetch)
origin https://github.com/hitjethva/exampleapp.git (push)
```
## Working with Git Revisions
Next, edit the test.html file and add some more contents:
```
nano test.html
```
Make the following changes:
```
My Atlantic App
This is my first atlantic App.
I am adding some content to this file.
```
Save and close the file when you are finished. Then, add the updated file to the remote repository with the following commands:
```
git add test.html
git commit -m "This my second version of test.html file"
git push origin master
```
Now, go to the GitHub page and refresh it. You should see the updated file with different revision number in the following screen:
Next, open your terminal and clone your repository to the local system with the following command:
```
git clone https://github.com/hitjethva/exampleapp.git
```
You should see the following output:
```
Cloning into 'exampleapp'...
remote: Enumerating objects: 6, done.
remote: Counting objects: 100% (6/6), done.
remote: Compressing objects: 100% (4/4), done.
remote: Total 6 (delta 1), reused 5 (delta 0), pack-reused 0
Unpacking objects: 100% (6/6), done.
Checking connectivity... done.
```
Next, change the directory to the cloned directory.
```
cd exampleapp/
```
Now, you can use the git checkout command to download the files in the working directory to match with your desired version stored in that branch.
For example, to download the previous version file, go to the GitHub page and copy the previous version file’s revision number as shown below:
Next, run the git checkout command with revision number as shown below:
```
git checkout 4d7a3de02b19e6aaea3b7f2bd6a4c0a5c85ddbe6
```
You should see the following output:
```
Note: checking out '4d7a3de02b19e6aaea3b7f2bd6a4c0a5c85ddbe6'.
You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.
If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:
git checkout -b new_branch_name
HEAD is now at 4d7a3de... This my first version of test.html file
```
Now, check the content of test.html file:
```
cat test.html
```
You should see the content of your previous version file:
```
My Atlantic App
This is my first atlantic App.
```
## Conclusion
In the above tutorial, we learned how to install Git on Ubuntu 18.04. We also learned how to add files and commit changes to the remote repository. You can now manage and track your project from a central location – start using Git today with a [VPS from Atlantic.Net](https://www.atlantic.net/vps-hosting/).
---
# How to Install and Secure Redis on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-secure-redis-on-ubuntu-18-04/ | Published: 2020-04-04 | Updated: 2023-11-17 | Author: Hitesh Jethva
Redis, which stands for “remote dictionary server,” is a key-value store that stores data as key-value pairs. Redis is a NoSQL database, meaning it does not have tables, rows and columns like in MySQL and Oracle databases. It does not use INSERT, SELECT, UPDATE and DELETE. Instead of this, Redis uses data structures to store data. It uses five primary data structures including Strings, Lists, Sets, Sorted Sets, and Hashes, as well as three extra data structures including bitmaps, hyperloglogs and geospatial indexes. One of the most important features of Redis is that it is an in-memory database, meaning it keeps the data in memory, making it super-fast. However, Redis also has options to write the data to the disk.
In this tutorial, we will show you how to install and secure Redis on Ubuntu 18.04.
## Install Redis Server
By default, the Redis package is available in the Ubuntu 18.04 server. You can install it with the following command:
```
apt-get install redis-server php-redis -y
```
After installing the Redis server, you will need to configure the Redis server to use the init system for managing Redis as a service. You can configure it by editing redis.conf file:
```
nano /etc/redis/redis.conf
```
Find the following line:
```
supervised no
```
Replace it with the following line:
```
supervised systemd
```
Save and close the file. Then, restart the Redis service to apply the changes:
```
systemctl restart redis
```
You can also check the status of the Redis service with the following command:
```
systemctl status redis
```
You should get the following output:
## Verify Redis Server
It is recommended to test whether the Redis server is functioning as expected or not.
You can test it using the redis-cli command-line utility:
```
redis-cli
127.0.0.1:6379> ping
```
If everything is fine, you should get the following output:
```
PONG
```
You can now exit from the Redis shell with the following command:
```
exit
```
You can also check the version of the Redis with the following command:
```
redis-cli -v
```
Output:
```
redis-cli 4.0.9
```
For more information about Redis, run the following command:
```
redis-cli info
```
You should see the following screen:
You can also verify the Redis listening port with the following command:
```
netstat -lnp | grep redis
```
You should see that Redis server is listening on localhost on port 6379:
## Secure Redis with Password
By default, Redis can be accessed without any password. It is recommended to secure Redis with a password for security reasons.
First, generate a strong password with OpenSSL command as shown below:
```
openssl rand 60 | openssl base64 -A
```
You should see the following output (a password like this):
```
MGDCmmWh2Ot+aZDv7TBr54SY5PueoSAVhX41sApcOLWYBTlPrfe01OT/nqO0YWK/y0ROozsDi9Dw61jR
```
Now, paste your password in the Redis configuration file /etc/redis/redis.conf:
```
nano /etc/redis/redis.conf
```
Find the following line:
```
# requirepass foobared
```
Replace it with the following line:
```
requirepass MGDCmmWh2Ot+aZDv7TBr54SY5PueoSAVhX41sApcOLWYBTlPrfe01OT/nqO0YWK/y0ROozsDi9Dw61jR
```
Save and close the file. Then, restart the Redis service to apply the changes:
```
systemctl restart redis
```
Now, connect to the Redis command-line with the following command:
```
redis-cli
127.0.0.1:6379>
```
Now, run the following command to test whether the Redis password works:
```
127.0.0.1:6379> set test "How Are You"
```
You will get the following error because didn’t authenticate:
```
(error) NOAUTH Authentication required.
```
Now, authenticate Redis with the password as shown below:
```
127.0.0.1:6379> auth MGDCmmWh2Ot+aZDv7TBr54SY5PueoSAVhX41sApcOLWYBTlPrfe01OT/nqO0YWK/y0ROozsDi9Dw61jR
```
You should get the following output:
```
OK
```
Now, run the previous command again:
```
127.0.0.1:6379> set test "How Are You"
```
Output:
```
OK
```
Now, get the value of the test:
```
127.0.0.1:6379> get test
```
You should see the following output:
```
"How Are You"
```
After testing successfully, exit from the Redis command-line with the following command:
```
127.0.0.1:6379> exit
```
## Rename Dangerous Commands
It is always a good idea to rename some dangerous commands including config, shutdown, flushdb, flushall and rename. These commands can destroy or wipe your data if run by mistake.
You can rename these commands by editing /etc/redis/redis.conf file:
```
nano /etc/redis/redis.conf
```
Add the following lines at the end of the file:
```
rename-command CONFIG ATLANTICCONFIG
rename-command FLUSHDB ATLANTICFLUSHDB
rename-command SHUTDOWN ATLANTICSHUTDOWN
rename-command FLUSHALL ATLANTICFLUSHALL
```
Save and close the file, then restart Redis service to implement the changes:
```
systemctl restart redis
```
To test the above commands, enter the Redis command line:
```
redis-cli
```
Now, authenticate Redis with the password as shown below:
```
127.0.0.1:6379> auth MGDCmmWh2Ot+aZDv7TBr54SY5PueoSAVhX41sApcOLWYBTlPrfe01OT/nqO0YWK/y0ROozsDi9Dw61jR
```
You should get the following output:
```
OK
```
Now, try to run the original CONFIG command as shown below:
```
127.0.0.1:6379> config get requirepass
```
You should get the following error:
```
(error) ERR unknown command 'config'
```
Now, try again with the renamed command:
```
127.0.0.1:6379> atlanticconfig get requirepass
```
You should see the following output:
```
1) "requirepass"
2) "MGDCmmWh2Ot+aZDv7TBr54SY5PueoSAVhX41sApcOLWYBTlPrfe01OT/nqO0YWK/y0ROozsDi9Dw61jR"
```
## Conclusion
Congratulations! Your Redis server is now installed and secured. This method is compatible with Atlantic.Net [VPS Hosting](https://www.atlantic.net/vps-hosting/). For more information, you can visit the Redis [documentation](https://redis.io/documentation) page.
---
# How to Install and Secure phpMyAdmin on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-secure-phpmyadmin-on-centos-8/ | Published: 2020-04-05 | Updated: 2024-07-02 | Author: Hitesh Jethva
phpMyAdmin is an open-source software tool used for managing MySQL/MariaDB databases. It provides an easy way to interact with MySQL through a web browser. phpMyAdmin is very useful for users who are not comfortable administering their data from the command line, so it is essential for any system administrator to secure phpMyAdmin from different kinds of attacks.
In this tutorial, we will show you how to install and secure phpMyAdmin on CentOS 8.
## Step 1 – Install Apache, MariaDB and PHP
Before starting, install Apache, MariaDB, PHP and other required PHP extensions with the following command:
```
dnf update -y
dnf install httpd mariadb-server php php-cli php-json php-mbstring php-pdo php-pecl-zip php-mysqlnd -y
```
After installing all the packages, you can proceed to the next step.
## Step 2 – Set MariaDB Root Password
First, start the MariaDB service and enable it to start on boot time with the following command:
```
systemctl start mariadb
systemctl enable mariadb
```
Next, set the MySQL root password using the following script:
```
mysql_secure_installation
```
This script will set the MySQL root password, remove anonymous users, disallow root login remotely and remove the test database and access to it, as shown below:
Enter current password for root (enter for none):
```
Set root password? [Y/n] Y
New password:
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
```
## Step 3 – Install phpMyAdmin
First, download the latest version of phpMyAdmin to the Apache web root directory using the following command:
```
cd /var/www/html
wget https://files.phpmyadmin.net/phpMyAdmin/4.9.4/phpMyAdmin-4.9.4-all-languages.zip
```
Once downloaded, unzip the downloaded file with the following command:
```
unzip phpMyAdmin-4.9.4-all-languages.zip
```
Next, rename the extracted directory to phpmyadmin as shown below:
```
mv phpMyAdmin-4.9.4-all-languages phpmyadmin
```
Next, change the ownership of the phpmyadmin directory to the apache user:
```
chown -R apache:apache /var/www/html/phpmyadmin
```
Next, rename the config.sample.inc.php file:
```
cd /var/www/html/phpmyadmin
mv config.sample.inc.php config.inc.php
```
Next, edit the file and define your secure password:
```
nano config.inc.php
```
Find the line below and update with your secure password, as shown below:
```
$cfg['blowfish_secret'] = 'your-secure-password';
```
Save and close the file. Then, import the tables for phpMyAdmin with the following command:
```
mysql < sql/create_tables.sql -u root -p
```
Once you are done, you can proceed to the next step.
## Step 4 – Configure Apache for phpMyAdmin
Next, create an Apache virtual host configuration file for phpMyAdmin:
```
nano /etc/httpd/conf.d/phpmyadmin.conf
```
Add the following lines:
```
Alias /phpmyadmin /var/www/html/phpmyadmin
AddDefaultCharset UTF-8
# Apache 2.4
Require all granted
# Apache 2.2
Order Deny,Allow
Deny from All
Allow from 127.0.0.1
Allow from ::1
# Apache 2.4
Require all granted
# Apache 2.2
Order Deny,Allow
Deny from All
Allow from 127.0.0.1
Allow from ::1
```
Save and close the file. Then, start the Apache service and enable it to start after system reboot with the following command:
```
systemctl start httpd
systemctl enable httpd
```
Now, open your web browser and visit the URL your-server-ip/phpmyadmin. You should see the phpMyAdmin web interface in the following screen:
Log in with your MySQL credentials created earlier.
## Step 5 – Secure phpMyAdmin
In this section, we will show different ways to secure your phpMyAdmin web interface.
### Change phpMyAdmin Access Location
It is a good idea to change the access URL of your phpMyAdmin interface. You can change it by editing the phpmyadmin.conf file:
```
nano /etc/httpd/conf.d/phpmyadmin.conf
```
Find the following line:
```
Alias /phpmyadmin /var/www/html/phpmyadmin
```
Replace it with the following line:
```
Alias /securelocation /var/www/html/phpmyadmin
```
Save and close the file, then restart the Apache service to implement the changes:
```
systemctl restart httpd
```
You can now access the phpMyAdmin interface using the URL: your-server-ip/securelocation.
### Allow phpMyAdmin from Specific IP
It is always a good idea to allow phpMyAdmin only to be accessible from a specific IP address.
To do so, open the phpmyadmin.conf file:
```
nano /etc/httpd/conf.d/phpmyadmin.conf
```
Find the following lines:
```
Require all granted
```
Replace it with the following:
```
Require ip your-client-ip-address
Require ip ::1
```
Save and close the file, then restart the Apache service to implement the changes:
```
systemctl restart httpd
```
Your phpMyAdmin interface is now only accessible from a specified IP address.
### Password Protect phpMyAdmin Interface
You can also add an extra layer of password protection on phpMyAdmin by setting up basic authentication.
First, create an authentication file using the following command:
```
htpasswd -c /etc/httpd/.htpasswd phpadmin
```
Provide a secure password as shown below:
```
New password:
Re-type new password:
Adding password for user phpadmin
```
Next, create the .htaccess file within the phpmyadmin directory:
```
nano /var/www/html/phpmyadmin/.htaccess
```
Add the following lines:
```
AuthType basic
AuthName "Authentication Required"
AuthUserFile /etc/httpd/.htpasswd
Require valid-user
```
Save and close the file when you are finished.
Next, edit the phpmyadmin.conf file and configure Apache to use the .htpasswd file.
```
nano /etc/httpd/conf.d/phpmyadmin.conf
```
Add the following lines below the line “AddDefaultCharset UTF-8”:
```
AllowOverride All
```
Save the file, then restart the Apache service to implement the changes:
```
systemctl restart httpd
```
## Step 6 – Test phpMyAdmin
At this point, the phpMyAdmin interface is secured with an extra layer of password protection. To test it, open your web browser and type the URL http://your-server-ip/securelocation. You will be asked to provide the login credentials that we created earlier:
Type your username and password and click on the **OK** button. You will be redirected to the phpMyAdmin login page:
Provide your MySQL username and password, then click on the **Go** button. You should see your phpMyAdmin web interface in the following screen:
## Conclusion
In the above guide, we learned how to install and secure phpMyAdmin on CentOS 8. Your phpMyAdmin interface is now secured with additional password protection. You can use this method to secure a server under an Atlantic.Net VPS Hosting Plan.
Learn more about our [VPS hosting](https://www.atlantic.net/vps-hosting/) services and [Virtual private servers.](https://www.atlantic.net/vps-hosting/)
---
# How to Setup Password Authentication with Apache on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-setup-password-authentication-with-apache-on-ubuntu-18-04/ | Published: 2020-04-06 | Updated: 2024-07-02 | Author: Hitesh Jethva
Apache webserver is free, open-source, and one of the most widely used web servers in the world. It allows you to serve the content on the web.
Any user can access your application over the Internet when it is hosted on an Apache web server. In some cases, you may need to secure your application so that only authenticated users can access the application. You can protect your application at the server level using Apache htpasswd. This utility allows you to limit access to a specific website to the limited person who has the login details only.
In this tutorial, we will show you how to setup password authentication with Apache on Ubuntu 18.04.
## Step 1 – Install Apache Webserver
By default, the Apache webserver package is available in the Ubuntu 18.04 default repository. You can install it with the following command:
```
apt-get install apache2 apache2-utils -y
```
Once installed, start the Apache service and enable it to start after system reboot with the following command:
```
systemctl start apache2
systemctl enable apache2
```
Now, open your web browser and navigate to the URL http://your-server-ip. You should see your default Apache web page in the following screen:
## Step 2 – Create Apache Password File
First, you will need to create a password file that Apache can use to authenticate users. You can create a hidden .htpasswd file withing /etc/apache2 directory for a user named user1 using the htpasswd utility:
```
htpasswd -c /etc/apache2/.htpasswd user1
```
Provide your desired password, as shown below:
```
New password:
Re-type new password:
Adding password for user user1
```
The above command will create a .htpasswd file with user credentials. You will need to use these credentials to access your website.
## Step 3 – Create a Sample Website
In this section, we will create a sample directory structure and index.html file for testing purposes.
First, create a directory for your website with the following command:
```
mkdir /var/www/html/example.com
```
Next, create an index.html file inside your web directory with the following command:
```
nano /var/www/html/example.com/index.html
```
Add the following contents:
```
Password Protected Apache Website.
This website is password protected.
```
Save and close the file when you are finished. Then, change the ownership of your web directory to www-data:
```
chown -R www-data:www-data /var/www/html/example.com
```
## Step 4 – Configure Apache Basic Authentication
Next, you will need to create an Apache virtual host configuration file for your website and define basic authentication.
```
nano /etc/apache2/sites-available/example.conf
```
Add the following lines:
```
ServerAdmin webmaster@example.com
ServerName example.com
DocumentRoot /var/www/html/example.com
DirectoryIndex index.html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
AuthType Basic
AuthName "Restricted Content"
AuthUserFile /etc/apache2/.htpasswd
Require valid-user
```
Save and close the file when you are finished.
A brief explanation of each directive is specified below:
- **ServerAdmin**: Email address of the server admin.
- **ServerName**: Domain name that the server uses to identify itself.
- **DocumentRoot**: Specify the path of your application.
- **DirectoryIndex**: Specify a default page to display when a directory is accessed.
- **AuthType**: Type of authentication.
- **AuthName**: Specify the message to appear on the password page.
- **AuthUserFile**: Specify the location of the user credential file.
- **Require**: Specify the users that can access this region of the server.
Next, check the Apache for any syntax errors with the following command:
```
apachectl -t
```
You should get the following output:
```
Syntax OK
```
Next, enable the Apache virtual host file for your website with the following command:
```
a2ensite example.conf
```
Next, restart the Apache service to implement the changes:
```
systemctl restart apache2
```
## Step 5 – Verify Apache Password Authentication
At this point, your website is secured with Apache basic authentication.
To check it, open your web browser and type the URL http://example.com. You will be asked to provide a username and password to access your website, as shown below:
Provide your username and password and click on the **Sign in** button. You should see your website default page in the following screen:
## Conclusion
In the above guide, we learned how to create a password protected website with Apache on Ubuntu 18.04. You can now easily password protect your website with Apache – test it out today with a [VPS Hosting Plan](https://www.atlantic.net/vps-hosting/) from Atlantic.Net! For more information, you can visit the Apache official documentation at [Apache Auth](https://httpd.apache.org/docs/2.4/howto/auth.html).
---
# Install and Configure Varnish Cache with Nginx Web Server on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/install-and-configure-varnish-cache-with-nginx-web-server-on-ubuntu-18-04/ | Published: 2020-04-07 | Updated: 2023-11-27 | Author: Hitesh Jethva
Varnish Cache is a free, open-source, and powerful web application accelerator designed for high-load dynamic websites. The Varnish Cache sits behind the web server and can speed up your website by a factor between about 300 and 1000 times. It can also be used as a load balancer if you are running multiple servers. Varnish Cache works by caching requested web pages in memory and serving a requested page without the delay of building content from scratch when the same information is asked for several times.
In this tutorial, we will show you how to set up Varnish Cache as a proxy server for Nginx on Ubuntu 18.04 VPS.
## Step 1 – Install Varnish Cache
By default, the Varnish package is available in the Ubuntu 18.04 default repository. You can install it by running the following command:
```
apt-get update -y
apt-get install varnish -y
```
After successful installation, the Varnish cache service has been started automatically. You can check the status of Varnish service with the following command:
```
systemctl status varnish
```
You should get the following output:
You can also verify the installed version of Varnish with the following command:
```
varnishd -V
```
You should see the following output:
By default, Varnish cache is listening on port 6081 and 6082. You can verify it with the following command:
```
netstat -ant
```
You should see the following output:
## Step 2 – Install and Configure Nginx
In this section, we will install and configure Nginx to sit behind the Varnish cache server. By default, Nginx runs on port 80, so you will need to configure the Nginx to listen on port 8088.
First, install the Nginx web server with the following command:
```
apt-get install nginx -y
```
After installing the Nginx web server, edit the Nginx default virtual host configuration file:
```
nano /etc/nginx/sites-available/default
```
Change the default port from 80 to 8088, as shown below:
```
server {
listen 8088 default_server;
listen [::]:8088 default_server;
root /var/www/html;
index index.html index.htm index.nginx-debian.html;
server_name _;
location / {
try_files $uri $uri/ =404;
}
}
```
Note : Ensure you have deleted or commented out all of the default entries in the files, make sure only the above content is saved. Failure to do this will result in the nginx service refusing to start
Save and close the file when you are finished. Then, restart the Nginx service to apply the configuration:
```
systemctl restart nginx
```
## Step 3 – Configure Varnish Cache
Next, you will need to configure Varnish to use port 80 so it can route traffic to the Nginx web server via the Varnish cache server.
You can do it by editing the file /lib/systemd/system/varnish.service:
```
nano /lib/systemd/system/varnish.service
```
Change the Varnish default port from 6081 to 80 as shown below:
```
[Unit]
Description=Varnish HTTP accelerator
Documentation=https://www.varnish-cache.org/docs/4.1/ man:varnishd
[Service]
Type=simple
LimitNOFILE=131072
LimitMEMLOCK=82000
ExecStart=/usr/sbin/varnishd -j unix,user=vcache -F -a :80 -T localhost:6082 -f /etc/varnish/default.vcl -S /etc/varnish/secret -s malloc,256m
ExecReload=/usr/share/varnish/varnishreload
ProtectSystem=full
ProtectHome=true
PrivateTmp=true
PrivateDevices=true
[Install]
WantedBy=multi-user.target
```
Save and close the file when you are finished. Then, reload systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, you will need to configure Nginx as a backend server for Varnish. You can do it by editing the file /etc/varnish/default.vcl:
```
nano /etc/varnish/default.vcl
```
Change the port from 8080 to 8088, as shown below:
```
backend default {
.host = "127.0.0.1";
.port = "8088";
}
```
Save and close the file when you are finished.
**Note**: Replace 127.0.0.1 with your Nginx server IP address if your Nginx web server is installed on the other host.
Finally, restart the Varnish cache server with the following command:
```
systemctl restart varnish
```
## Step 4 – Verify Varnish Cache Server
At this point, the Varnish cache is configured to work with the Nginx web server. It’s time to test it.
You can check the Varnish cache with the curl command as shown below:
```
curl -I your-server-ip
```
You should get the following output:
```
HTTP/1.1 200 OK
Server: nginx/1.14.0 (Ubuntu)
Date: Sun, 01 Dec 2019 06:46:18 GMT
Content-Type: text/html
Last-Modified: Sun, 01 Dec 2019 06:41:28 GMT
ETag: W/"5de36098-264"
Vary: Accept-Encoding
X-Varnish: 32770 3
Age: 17
Via: 1.1 varnish (Varnish/5.2)
Accept-Ranges: bytes
Connection: keep-alive
```
The above output clearly indicates that you are using Nginx server with Varnish Cache.
You can also verify Varnish caching statistics with the following command:
```
varnishstat
```
You should see the following screen:
You can also see Varnish log entry ranking with the following command:
```
varnishtop
```
Output:
If you have any issues with the Varnish cache, you can check the Varnish log with the following commands:
```
tail -f varnishncsa.log
```
## Conclusion
Congratulations! You have successfully installed and configured the Varnish Cache server with Nginx on Ubuntu 18.04 [VPS](https://www.atlantic.net/vps-hosting/). You can refer to the [Varnish documentation](https://varnish-cache.org/docs/) to optimize your configuration per your needs.
---
# How to Install Webmin on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-webmin-on-ubuntu-18-04/ | Published: 2020-04-08 | Updated: 2023-11-18 | Author: Hitesh Jethva
Webmin is a free and open-source web-based control panel for the Linux operating system. It is specifically designed for those who are unable to manage Linux servers from the command-line interface. Webmin allows you to manage users and groups, share files and folders, configure a web server, DNS, SSH, and FTP, install and update packages, create and manage databases, and start and stop services, all using a web-based interface.
Webmin is written in Perl language and runs as its own process and web server. It also allows you to control many Linux machines through a single interface.
In this tutorial, we will describe how to install Webmin on Ubuntu 18.04 server. We will also configure Apache as a reverse proxy for Webmin.
## Step 1 – Install Webmin
By default, Webmin is not available in the Ubuntu 18.04 default repository. You can install it by adding the Webmin repository in your system.
First, install the required packages with the following command:
```
apt-get install software-properties-common apt-transport-https wget -y
```
Next, download and add the Webmin GPG key with the following command:
```
wget -q http://www.webmin.com/jcameron-key.asc -O- | apt-key add -
```
Next, add the Webmin repository with the following command:
```
add-apt-repository "deb [arch=amd64] http://download.webmin.com/download/repository sarge contrib"
```
Once the repository is added, run the following command to install Webmin in your system:
```
apt-get install webmin -y
```
Once Webmin has been installed successfully, you should get the following output:
You cal also verify the status of the Webmin service with the following command:
```
systemctl status webmin
```
You should get the following output:
At this point, Webmin is installed and listening on port 10000.
## Step 2 – Configure Apache as a Reverse Proxy For Webmin
In this section, we will configure the Apache as a reverse proxy for Webmin so you can access Webmin without specifying the port (10000).
To do so, first install the Apache webserver with the following command:
```
apt-get install apache2 apache2-utils -y
```
After installing the Apache server, you will need to configure Webmin to disable SSL. You can disable SSL by editing the file /etc/webmin/miniserv.conf:
```
nano /etc/webmin/miniserv.conf
```
Change the SSH value from 1 to 0, as shown below:
```
ssl=0
```
Save and close the file. Next, you will need to add your domain name to the list of allowed domains. You can add your domain by editing the file /etc/webmin/config:
```
nano /etc/webmin/config
```
Add the following line at the end of the file:
```
referers=webmin.example.com
```
Save and close the file when you are finished. Then, restart the Webmin service to implement the changes:
```
systemctl restart webmin
```
Next, you will need to create an Apache virtual host configuration file to serve Webmin.
You can create it using the following command:
```
nano /etc/apache2/sites-available/webmin.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
ServerName webmin.example.com
ProxyPass / http://localhost:10000/
ProxyPassReverse / http://localhost:10000/
```
Save and close the file, then enable the virtual host and proxy module with the following command:
```
a2ensite webmin
a2enmod proxy_http
```
Finally, restart the Apache service to implement the changes:
```
systemctl restart apache2
```
## Step 3 – Access Webmin Interface
Now, open your web browser and type the URL **http://webmin.example.com**. You will be redirected to the Webmin login page:
Provide your system root username and password and click on the **Sign** **in** button. You should see the Webmin dashboard in the following screen:
To access the file manager, click on the **Others => File Manager**. You should see the following screen:
From here, you can manage files and directory through a web-based interface.
To access the password manager page, click on the **System => Change Passwords**. You should see the following screen:
From here, you can change any user’s password easily.
## Conclusion
Congratulations! You have successfully installed and configured Webmin on Ubuntu 18.04 server. You can now manage your Linux system easily through a web-based interface from the remote location. Test it today with a [VPS Hosting](https://www.atlantic.net/vps-hosting/) package from Atlantic.Net!
---
# How to Install PostgreSQL Server on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-postgresql-server-on-centos-8/ | Published: 2020-04-14 | Updated: 2023-11-26 | Author: Hitesh Jethva
PostgreSQL is a free and open-source object-relational database management system. PostgreSQL was developed by the PostgreSQL Global Development Group and is available for various platforms, including Linux, Microsoft Windows, and Mac OS X. PostgreSQL is known for its robustness, high availability, data integrity, reliability and ease of installation. PostgreSQL comes with many advanced features that allow you to build complex applications.
PostgreSQL supports many programming languages including Java, Python, Ruby, Perl, PHP and pgSQL. It also offers several library interfaces including JDBC, ODBC, OCI, libpq, C/C+, PHP, .NET, Perl, Qt and many more. If you are looking for enterprise-class database solutions, then PostgreSQL is the best choice for you.
In this tutorial, we will explain how to install the PostgreSQL server on CentOS 8.
## Step 1 – Install PostgreSQL 12
By default, the latest version of PostgreSQL is not available in CentOS 8 default repository, so you will need to add the PostgreSQL repository to your system.
You can add it with the following command:
```
dnf update -y
dnf install https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64/pgdg-redhat-repo-latest.noarch.rpm -y
```
Next, disable the built-in PostgreSQL module by running the following command:
```
dnf -qy module disable postgresql
```
Next, install PostgreSQL 12 with the following command:
```
dnf install postgresql12 postgresql12-server -y
```
Once the PostgreSQL server has been installed, you can proceed to the next step.
## Step 2 – Manage PostgreSQL Service
First, initialize the PostgreSQL database with the following command:
```
/usr/pgsql-12/bin/postgresql-12-setup initdb
```
You should get the following output:
```
Initializing database ... OK
```
Next, start the PostgreSQL service and enable it to start after system reboot with the following command:
```
systemctl start postgresql-12
systemctl enable postgresql-12
```
You can check the status of the PostgreSQL service with the following command:
```
systemctl status postgresql-12
```
You should see the following output:
```
● postgresql-12.service - PostgreSQL 12 database server
Loaded: loaded (/usr/lib/systemd/system/postgresql-12.service; enabled; vendor preset: disabled)
Active: active (running) since Sun 2020-03-22 11:33:01 EDT; 26s ago
Docs: https://www.postgresql.org/docs/12/static/
Main PID: 27099 (postmaster)
Tasks: 8 (limit: 12537)
Memory: 17.4M
CGroup: /system.slice/postgresql-12.service
├─27099 /usr/pgsql-12/bin/postmaster -D /var/lib/pgsql/12/data/
├─27102 postgres: logger
├─27104 postgres: checkpointer
├─27105 postgres: background writer
├─27106 postgres: walwriter
├─27107 postgres: autovacuum launcher
├─27108 postgres: stats collector
└─27109 postgres: logical replication launcher
Mar 22 11:33:01 centos8 systemd[1]: Starting PostgreSQL 12 database server...
```
You can also check the PostgreSQL service with the following command:
```
netstat -antup | grep 5432
```
You should see the following output:
```
tcp 0 0 127.0.0.1:5432 0.0.0.0:* LISTEN 30317/postmaster
```
## Step 3 – Set PostgreSQL Admin Password
During the PostgreSQL installation, a new user called postgres is created without a password. It is recommended to set a PostgreSQL password for security reasons.
To set a password, log in to the postgres user with the following command:
```
su - postgres
```
Next, set a new password with the following command:
```
psql -c "alter user postgres with password 'password'"
```
Next, exit from the PostgreSQL shell with the following command:
```
exit
```
## Step 4 – Configure PostgreSQL Server for Remote Access
By default, PostgreSQL is configured to listen on the localhost so that only local applications can connect to the database server, restricting external applications from connecting to the database.
You can configure PostgreSQL server for remote connection by editing postgresql.conf file:
```
nano /var/lib/pgsql/12/data/postgresql.conf
```
Find and change the listen_addresses value to * as shown below:
```
listen_addresses = '*'
```
Save and close the file. Then, you will also need to configure PostgreSQL to accept remote connections. You can do it by editing pg_hba.conf file:
```
nano /var/lib/pgsql/12/data/pg_hba.conf
```
Find the following line:
```
host all all 127.0.0.1/32 ident
```
Replace it with the following line:
```
host all all 0.0.0.0/0 md5
```
Save and close the file when you are finished. Then, restart the PostgreSQL service to apply the changes:
```
systemctl restart postgresql-12
```
Next, you can verify the PostgreSQL listening connection with the following command:
```
netstat -antup | grep 5432
```
You should see the following output:
```
tcp 0 0 0.0.0.0:5432 0.0.0.0:* LISTEN 21603/postmaster
tcp6 0 0 :::5432 :::* LISTEN 21603/postmaster
```
Next, go to the remote machine and run the following command to verify the PostgreSQL connection:
```
psql -h your-server-ip -p 5432 -U postgres -W
```
You will be asked to provide your Postgres password:
```
Password for user postgres:
```
Provide your password and hit Enter. Once the connection has been established, you should see the following output:
```
psql (9.3.24, server 12.2)
WARNING: psql major version 9.3, server major version 12.
Some psql features might not work.
Type "help" for help.
postgres=#
```
## Conclusion
Congratulations! You have successfully installed PostgreSQL 12 on CentOS 8. You can now host any application and use PostgreSQL as a database backend – try it out today on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net! For more information, visit the PostgreSQL official documentation at [Postgres Doc](https://www.postgresql.org/docs/).
---
# How to Install R on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-r-on-ubuntu-18-04/ | Published: 2020-04-15 | Updated: 2023-11-26 | Author: Hitesh Jethva
R is an open-source programming language that can be used to develop statistical software and perform data analysis. R is a GNU project and very similar to the S language. It is mainly used by data analysts, researchers, statisticians and marketers to retrieve, analyze, visualize and present the data. R also offers many packages for specific areas of study, making it easy to find applications in different fields. R can be run on various operating systems including Linux, Windows and MacOS.
In this tutorial, we will show you how to install and use R programming language on Ubuntu 18.04.
## Step 1 – Install R Programming Language
By default, R is not available in the Ubuntu 18.04 default repository, so you will need to add CRAN repositories in order to install the latest version of R on your system.
First, install the required packages by running the following command:
```
apt-get update -y
apt-get install apt-transport-https software-properties-common -y
```
Next, download and add the GPG key with the following command:
```
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9
```
You should get the following output:
```
Executing: /tmp/apt-key-gpghome.mOaFpZLCLj/gpg.1.sh --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9
gpg: key 51716619E084DAB9: public key "Michael Rutter " imported
gpg: Total number processed: 1
gpg: imported: 1
```
Next, add the CRAN repository with the following command:
```
add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu bionic-cran35/'
```
Once the repository has been added, update the repository and install R with the following command:
```
apt-get update -y
apt-get install r-base -y
```
After installing R, you can verify the R version with the following command:
```
R --version
```
You should see the following output:
```
R version 3.6.3 (2020-02-29) -- "Holding the Windsock"
Copyright (C) 2020 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)
R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under the terms of the
GNU General Public License versions 2 or 3.
For more information about these matters see
https://www.gnu.org/licenses/.
```
## Step 2 – Use R Programming Language
You can open the R console as root with the following command:
```
sudo -i R
```
You should get the following output:
```
R version 3.6.3 (2020-02-29) -- "Holding the Windsock"
Copyright (C) 2020 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)
R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.
Natural language support but running in an English locale
R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.
Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
>
```
Next, check the default packages installed with R using the following command:
```
> getOption("defaultPackages")
```
You should see the following output:
```
[1] "datasets" "utils" "grDevices" "graphics" "stats" "methods"
```
You can also list all available packages with the following command:
```
> (.packages(all.available=TRUE))
```
You should get the following output:
```
[1] "backports" "base64url" "filelock" "R6" "txtq"
[6] "base" "boot" "class" "cluster" "codetools"
[11] "compiler" "datasets" "foreign" "graphics" "grDevices"
[16] "grid" "KernSmooth" "lattice" "MASS" "Matrix"
[21] "methods" "mgcv" "nlme" "nnet" "parallel"
[26] "rpart" "spatial" "splines" "stats" "stats4"
[31] "survival" "tcltk" "tools" "utils"
>
```
You can also use the library() command to list all available packages with a short description:
```
> library()
```
Output:
```
Packages in library ‘/usr/lib/R/library’:
base The R Base Package
boot Bootstrap Functions (Originally by Angelo Canty
for S)
class Functions for Classification
cluster "Finding Groups in Data": Cluster Analysis
Extended Rousseeuw et al.
codetools Code Analysis Tools for R
compiler The R Compiler Package
datasets The R Datasets Package
foreign Read Data Stored by 'Minitab', 'S', 'SAS',
'SPSS', 'Stata', 'Systat', 'Weka', 'dBase', ...
graphics The R Graphics Package
grDevices The R Graphics Devices and Support for Colours
and Fonts
grid The Grid Graphics Package
KernSmooth Functions for Kernel Smoothing Supporting Wand
& Jones (1995)
lattice Trellis Graphics for R
MASS Support Functions and Datasets for Venables and
Ripley's MASS
Matrix Sparse and Dense Matrix Classes and Methods
methods Formal Methods and Classes
mgcv Mixed GAM Computation Vehicle with Automatic
Smoothness Estimation
nlme Linear and Nonlinear Mixed Effects Models
nnet Feed-Forward Neural Networks and Multinomial
```
You can exit from the R console with the following command:
```
> quit()
```
## Step 3 – Install R Packages from the Console
You can also install R packages within the R console. First, log in to the R console as a root with the following command:
```
sudo -i R
```
Next, install the txtq package using the following command:
```
> install.packages("txtq")
```
You should get the following output:
```
Installing package into ‘/usr/local/lib/R/site-library’
(as ‘lib’ is unspecified)
trying URL 'https://cloud.r-project.org/src/contrib/txtq_0.2.0.tar.gz'
Content type 'application/x-gzip' length 10536 bytes (10 KB)
==================================================
downloaded 10 KB
* installing *source* package ‘txtq’ ...
** package ‘txtq’ successfully unpacked and MD5 sums checked
** using staged installation
** R
** inst
** byte-compile and prepare package for lazy loading
** help
*** installing help indices
** building package indices
** testing if installed package can be loaded from temporary location
** testing if installed package can be loaded from final location
** testing if installed package keeps a record of temporary installation path
* DONE (txtq)
The downloaded source packages are in
‘/tmp/RtmpHfzZs1/downloaded_packages’
>
```
You can also remove the installed package with the following command:
```
> remove.packages("txtq")
```
## Step 4 – Install R Packages from Linux CLI
You can also install the R packages using the command-line interface.
**NOTE**: If you are still on the R CLI, press **CTRL D**and select **no**when prompted to save the workspace.
First, download the txtq package from the CRAN website with the following command:
```
wget -q https://cran.r-project.org/src/contrib/txtq_0.2.0.tar.gz
```
Once downloaded, you can install it with the following command:
```
sudo R CMD INSTALL txtq_0.2.0.tar.gz
```
Once installed, you should see the following output:
```
* installing to library ‘/usr/local/lib/R/site-library’
* installing *source* package ‘txtq’ ...
** package ‘txtq’ successfully unpacked and MD5 sums checked
** using staged installation
** R
** inst
** byte-compile and prepare package for lazy loading
** help
*** installing help indices
** building package indices
** testing if installed package can be loaded from temporary location
** testing if installed package can be loaded from final location
** testing if installed package keeps a record of temporary installation path
* DONE (txtq)
```
## Conclusion
That’s it for now. I hope you now have enough understanding of how to install and use R on the Ubuntu 18.04 server. You can now use it to build a statistical software using R programming language on your [VPS from Atlantic.Net](https://www.atlantic.net/vps-hosting/).
---
# Managing Dedicated Hosts
> URL: https://www.atlantic.net/vps-hosting/managing-dedicated-hosts/ | Published: 2020-04-17 | Updated: 2026-03-04 | Author: Josh Simon
## Introduction
[Dedicated Hosts](https://www.atlantic.net/dedicated-server-hosting/dedicated-hosts/) are private computing nodes that are fully dedicated to a single customer’s use with no shared resources or noisy neighbors. This service is ideal for any customer that has a growing need for powerful infrastructure, security, compliance, or is looking for the flexibility and cost-effectiveness that comes with having their own computing infrastructure.
**Dedicated Host highlights**
Fully dedicated and private environment for your use with no shared resources and no noisy neighbors.
Self-service ability to add and remove Dedicated Hosts on-demand or opt for a discount with the selection of a 1 or 3-year term.
View and manage RAM, CPU, and Disk space in use.
Freedom and flexibility to provision any Cloud Server plan type.
Complete control to create, manage and remove Cloud Server on your [Dedicated Host](https://www.atlantic.net/dedicated-server-hosting/dedicated-hosts/).
The environment is ready to help you meet your compliance and regulatory requirements.
## **What you will learn in this guide**
Adding a Dedicated Host
Viewing an Overview of your Dedicated Hosts
Viewing the Details of a Dedicated Host
Enable or Disable the ability to host Windows Cloud Servers on your Dedicated Host
Delete a Dedicated Host
Creating a Cloud Server on a Dedicated Host
Determining if a Cloud Server is on a Dedicated Host or the Public Cloud
## Adding a Dedicated Host
In the Atlantic.Net Control Panel, click on “Dedi Hosts” in the navigation menu on the left side of the page.
From the Dedicated Host page click the “Add Dedicated Hosts” button to go to the Add Dedicated Host page.
On the Add Dedicated Host page, a customer will choose a display name for the Dedicated Host, location, term, plan, and whether they want the Dedicated Host to be able to host Windows Servers.
## Viewing an Overview of your Dedicated Hosts
In the Atlantic.Net Control Panel, click on “Dedi Hosts” in the navigation menu on the left side of the page.
You will now be presented with a list of your Dedicated Hosts and an overview of the host resources and server count on that host.
## Viewing the Details of a Dedicated Host
On the Dedicated Hosts page, click on the “Description” field in the list of your Dedicated Hosts and you will be presented with an overview of the host resources, server count, and list of Cloud Servers that reside on the host.
## Enable or Disable the ability to host Windows Cloud Servers on your Dedicated Host
#### **Add Support for Windows Servers**
Click the Manage button and then click “Add Windows Licensing”
#### Remove Support for Windows Servers
Click the Manage button and then click “Remove Windows Licensing”
Note: You must remove any Windows Servers deployed on your Dedicated Host before you can remove Windows Licensing from your Dedicated Host.
## Delete a Dedicated Host
Click the Manage button and then click Delete Host
Note: If a user attempts to delete a Dedicated Host that still has an active non-expired term commitment, they will receive an error message stating they can not remove the Dedicated Host until the term commitment ends.
Note: If a user attempts to delete a Dedicated Host that still has Cloud Servers deployed they will receive an error message stating they can not remove the Dedicated Host until all Cloud Servers are removed from the Host.
## Creating a Cloud Server on a Dedicated Host
You can create a new Cloud Server on a Dedicated Host from the Dedicated Host Details page or from the Add Server page.
#### From the Add Server Page
In the Atlantic.Net Control Panel, click on “Servers”, then click the “Add Server” button. Next, select your desired [Dedicated Host](https://www.atlantic.net/dedicated-server-hosting/dedicated-hosts/) in the “Public or Dedicated Host” section of the page. You will then proceed to select the same remaining options as you normally would when building a Cloud Server.
**From the Dedicated Host Details Page**
In the Atlantic.Net Control Panel, click on “Dedi Hosts”, then click on the “Description” of the Dedicated Host you want to create the Cloud Server on, and then click on the “Add Server” button. Next, select your desired Dedicated Host in the “Public or Dedicated Host” section of the page. You will then proceed to select the same remaining options as you normally would when building a Cloud Server.
## Determining if a Cloud Server is on a Dedicated Host or the Public Cloud
From your list of Cloud Servers, click on the name of the desired Cloud Server. You will then view the value of the “Host Type” field. This field will either display the Dedicated Host where the Cloud Server resides or state it resides on the Public Cloud
## Want to learn more about Dedicated Hosts?
Learn more about our [Dedicated Hosting](https://www.atlantic.net/dedicated-server-hosting/dedicated-hosts/) by visiting our [Dedicated Server Hosting](https://www.atlantic.net/dedicated-server-hosting/) page or email us at sales@atlantic.net.
---
# How to Install Yarn on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-yarn-on-centos-8/ | Published: 2020-04-20 | Updated: 2023-11-26 | Author: Hitesh Jethva
Yarn is an advanced package management tool released by Facebook for JavaScript applications. Yarn is mostly used for Node.js applications and is compatible with npm, meaning it can install, remove, configure and update npm packages. It was specially designed to speed up package installation process.
In this guide, we will explain different ways to install Yarn on CentOS 8.
## Step 1 – Install Yarn
### Install Yarn with NPM
You can install Yarn with NPM “Node Package Manager.” First, install Node.js with the following command:
```
dnf update -y
dnf install @nodejs -y
```
Once installed, you can install the Yarn package globally using the following command:
```
npm install yarn -g
```
Once installed, you should see the following output:
You can now verify the version of Yarn with the following command:
```
yarn -v
```
You should see the following output:
```
1.22.4
```
### Install Yarn with Script
The simplest and easiest way to install Yarn is to install it from the script available at the Yarn official website.
You can install download and run the Yarn installation script with the following command:
```
curl -o- -L https://yarnpkg.com/install.sh | bash
```
Once the installation has been finished, you should see the following output:
**Note**: This script will install Yarn only for the current user.
Next, activate the PATH environment variable for Yarn with the following command:
```
source ~/.bashrc
```
Next, verify the Yarn version with the following command:
```
yarn -v
```
You should see the following output:
```
1.22.4
```
### Install Yarn from Repository
You can also install Yarn from the official repository.
First, add the Yarn repository with the following command:
```
curl --silent --location https://dl.yarnpkg.com/rpm/yarn.repo | tee /etc/yum.repos.d/yarn.repo
```
You should see the following output:
Next, import the Yarn GPG key with the following command:
```
rpm --import https://dl.yarnpkg.com/rpm/pubkey.gpg
```
Finally, install Yarn by running the following command:
```
dnf install yarn -y
```
Next, verify the Yarn version with the following command:
```
yarn -v
```
You should see the following output:
```
1.22.4
```
## Step 2 – Yarn Basic Command-line Usage
In this section, we will show some basic commands to create and manage the Yarn project.
To create a new Yarn project, run the following command:
```
yarn init projectname
```
This will create a package.json for your project.
You can now initiate a Yarn project in your current working directory with the following command:
```
yarn init
```
To install all the dependencies for your project specified in the package.json, run the following command:
```
yarn install
```
To add any package as a dependency in your project, run the following command:
```
yarn add packagename
```
To update any package dependencies, run the following command:
```
yarn upgrade packagename
```
To remove any package from the dependencies, run the following command:
```
yarn remove packagename
```
## Conclusion
Congratulations! You have successfully installed Yarn on CentOS 8. You can now use your desired method to install Yarn in your system – try it today using your Atlantic.Net [VPS Hosting](https://www.atlantic.net/vps-hosting/). For more information, visit the Yarn official [documentation page](https://yarnpkg.com/lang/en/docs/).
---
# How to Set Up GitLab on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-set-up-gitlab-on-centos-8/ | Published: 2020-04-30 | Updated: 2024-06-30 | Author: Hitesh Jethva
GitLab is a free, open-source, web-based version control platform that allows you to manage all your Git repositories from the centralized server. GitLab is a great alternative to Github, offering very useful features including code review, issue management, repository branching, merging, time tracking, and continuous integration and deployment. GitLab is specially designed for developers to create, review, and deploy their projects.
GitLab is available in three different editions: Community Edition (CE), Enterprise Edition (EE), and a GitLab-hosted version. You can install any of them depending on the requirements of your use case.
In this tutorial, we will show you how to install GitLab CE on CentOS 8.
Next, you will need to install some required dependencies on your system. You can install all of them with the following command:
```
dnf install curl policycoreutils python3-policycoreutils -y
```
## Step 1 – Install GitLab CE
By default, GitLab is not available in the CentOS 8 default repository, so you will need to add the GitLab repository in your system.
You can install it with the following command:
```
curl -s https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.rpm.sh | bash
```
Once the repository is added, you should get the following output:
Next, install GitLab CE by running the following command:
```
dnf install gitlab-ce -y
```
Once the installation has been completed successfully, you can proceed to the next step.
## Step 2 – Secure GitLab with Let’s Encrypt
Next, you will need to set the GitLab URL and enable Let’s Encrypt integration. You can do it by editing the file /etc/gitlab/gitlab.rb:
```
nano /etc/gitlab/gitlab.rb
```
Change the following lines that match your domain name and enable Let’s Encrypt integration with your desired value:
```
external_url 'https://gitlab.example.com'
letsencrypt['enable'] = true
letsencrypt['contact_emails'] = ['admin@example.com']
letsencrypt['auto_renew'] = true
letsencrypt['auto_renew_hour'] = 12
letsencrypt['auto_renew_minute'] = 15
letsencrypt['auto_renew_day_of_month'] = "*/4"
```
Save and close the file when you are finished. Then, reconfigure GitLab CE with the following command:
```
gitlab-ctl reconfigure
```
This command will reconfigure GitLab and secure it with Let’s Encrypt SSL. Once the GitLab setup has been completed successfully, you should get the following output:
```
* execute[reload prometheus] action run
- execute /opt/gitlab/bin/gitlab-ctl hup prometheus
Recipe: monitoring::alertmanager
* runit_service[alertmanager] action restart (up to date)
Recipe: monitoring::postgres-exporter
* runit_service[postgres-exporter] action restart (up to date)
Recipe: monitoring::grafana
* runit_service[grafana] action restart (up to date)
Recipe: nginx::enable
* execute[reload nginx] action run
- execute gitlab-ctl hup nginx
Recipe: letsencrypt::enable
* ruby_block[display_le_message] action run
- execute the ruby block display_le_message
Recipe: crond::enable
* runit_service[crond] action restart (up to date)
Running handlers:
Running handlers complete
Chef Client finished, 609/1641 resources updated in 10 minutes 43 seconds
Warnings:
Environment variable LANG specifies a non-UTF-8 locale. GitLab requires UTF-8 encoding to function properly. Please check your locale settings.
gitlab Reconfigured!
```
## Step 3 – Access GitLab Web UI
At this point, GitLab is installed and configured, and you can now access the GitLab UI by visiting the URL https://gitlab.example.com. You will be redirected to the password change screen as shown below:
Set the new password for the root user and click on the **Change** **your** **password** button. Once the password is changed successfully, you should see the GitLab login screen:
Enter root as your username, your specified password, and click on the **Sign** **in** button. You should see the GitLab dashboard in the following screen:
## Step 4 – Disable User Sign Up
By default, GitLab allows new users to sign up, which is very dangerous for security reasons. It is recommended to disable user registration on the GitLab welcome page.
To disable User Sign Up, click on the **Admin** area as shown below:
Now, click on **Settings** in the left pane. You should see the following page:
Next, **Expand** the Sign-up restrictions. You should see the following page:
Next, uncheck Sign-up enabled button to disable User registration on the GitLab welcome page and click on the **Save** **Changes** button.
Next, log out of your GitLab dashboard. You should see the following screen:
As you can see, the tab for user registration is missing.
## Step 5 – Automate GitLab Backup
You can take a complete backup of GitLab data with the following command:
```
gitlab-rake gitlab:backup:create
```
This command will take a complete backup of GitLab data and save it in the /var/opt/gitlab/backups directory. Once the backup has been completed successfully, you should get the following output:
```
2020-03-22 10:59:34 -0400 -- Dumping database ...
Dumping PostgreSQL database gitlabhq_production ... [DONE]
2020-03-22 10:59:37 -0400 -- done
2020-03-22 10:59:37 -0400 -- Dumping repositories ...
2020-03-22 10:59:38 -0400 -- done
2020-03-22 10:59:38 -0400 -- Dumping uploads ...
2020-03-22 10:59:38 -0400 -- done
2020-03-22 10:59:38 -0400 -- Dumping builds ...
2020-03-22 10:59:38 -0400 -- done
2020-03-22 10:59:38 -0400 -- Dumping artifacts ...
2020-03-22 10:59:38 -0400 -- done
2020-03-22 10:59:38 -0400 -- Dumping pages ...
2020-03-22 10:59:38 -0400 -- done
2020-03-22 10:59:38 -0400 -- Dumping lfs objects ...
2020-03-22 10:59:38 -0400 -- done
2020-03-22 10:59:38 -0400 -- Dumping container registry images ...
2020-03-22 10:59:38 -0400 -- done
Creating backup archive: 1584889178_2020_03_22_12.9.0_gitlab_backup.tar ... done
Uploading backup archive to remote storage ... skipped
Deleting tmp directories ... done
done
done
done
done
done
done
done
done
Deleting old backups ... skipping
Backup task is done.
```
It is recommended to schedule backups with Cron so that you don’t need to run backups regularly.
You can schedule backups by editing the following file:
nano /etc/crontab
Add the following line to back up GitLab data every day at 8:00 PM:
```
0 20 * * * gitlab-rake gitlab:backup:create
```
Save and close the file when you are finished.
## Conclusion
Congratulations! You have successfully installed and configured GitLab CE on CentOS 8 server. You can now host your own repository with GitLab and start collaborating with other developers today with GitLab on a [VPS with Atlantic.Net](https://www.atlantic.net/vps-hosting/)!
---
# How to Install Syncthing Cloud Sync Service on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-syncthing-cloud-sync-service-on-ubuntu-18-04/ | Published: 2020-05-01 | Updated: 2024-07-02 | Author: Hitesh Jethva
Syncthing is a free and open-source file synchronization tool used to synchronize files across multiple devices. Syncthing uses peer-to-peer architecture, meaning that each device attached to your Syncthing network retains copies of the files in your shared folders and pushes new content whenever any changes have been made. Syncthing can be run on most operating systems including Linux, Windows, MacOS, FreeBSD, Solaris and OpenBSD.
**Syncthing offers many features and benefits, some of which are listed below:**
- Easy-to-use
- Secure against attacks
- Powerful and portable
- Safe from data loss
- Fully automatic
In this tutorial, we will show you how to install and configure the Syncthing Cloud Sync service on Ubuntu 18.04.
## Prerequisites
- **Two**fresh Ubuntu servers
- Root passwords configured on both servers.
## Step 1 – Install Syncthing on Both Servers
By default, Syncthing is not available in the Ubuntu 18.04 default repository, so you will need to add Syncthing repository in your system.
First, install the required packages with the following command:
```
apt-get install curl apt-transport-https -y
```
Once installed, download and import the GPG Key for the repository with the following command:
```
curl -s https://syncthing.net/release-key.txt | apt-key add -
```
Next, add the Syncthing repository with the following command:
```
echo "deb https://apt.syncthing.net/ syncthing release" > /etc/apt/sources.list.d/syncthing.list
```
Next, update the repository and install the Syncthing service with the following command:
```
apt-get update -y
apt-get install syncthing -y
```
Once installed, you can verify the installed version of Syncthing with the following command:
```
syncthing --version
```
You should get the following output:
```
syncthing v1.3.4 "Fermium Flea" (go1.13.7 linux-amd64) deb@build.syncthing.net 2020-01-14 07:01:03 UTC
```
**Note: Now repeat the process on Server 2**
## Step 2 – Create a Systemd Service File for Syncthing
Next, you will need to create a systemd service file to manage the Syncthing service on both servers.
On **server1**, create a systemd service file with the following command:
```
nano /etc/systemd/system/syncthing@.service
```
Add the following lines:
```
[Unit]
Description=Syncthing - Open Source Continuous File Synchronization for %I
Documentation=man:syncthing(1)
After=network.target
[Service]
User=%i
ExecStart=/usr/bin/syncthing -no-browser -gui-address="server1-ip-address:8384" -no-restart -logflags=0
Restart=on-failure
SuccessExitStatus=3 4
RestartForceExitStatus=3 4
[Install]
WantedBy=multi-user.target
```
Save and close the file when you are finished.
On **server2**, create a systemd service file with the following command:
```
nano /etc/systemd/system/syncthing@.service
```
Add the following lines:
```
[Unit]
Description=Syncthing - Open Source Continuous File Synchronization for %I
Documentation=man:syncthing(1)
After=network.target
[Service]
User=%i
ExecStart=/usr/bin/syncthing -no-browser -gui-address="server2-ip-address:8384" -no-restart -logflags=0
Restart=on-failure
SuccessExitStatus=3 4
RestartForceExitStatus=3 4
[Install]
WantedBy=multi-user.target
```
Save and close the file when you are finished. Next, reload the systemd daemon and start the Syncthing service as a root user **on both servers** with the following command:
```
systemctl daemon-reload
systemctl start syncthing@root
```
Next, enable the Syncthing service to start after system reboot with the following command:
```
systemctl enable syncthing@root
```
Next, verify the status of the Syncthing service with the following command:
```
systemctl status syncthing@root
```
You should get the following output:
At this point, Syncthing service is started and listening on port 8384.
## Step 3 – Access Syncthing Web Interface
Now, open your web browser and access the Syncthing web UI using the URL http://server1-ip-address:8384. You will be redirected to the Syncthing web interface as shown below:
By default, the Syncthing web interface can be accessed without username and password, so it is a good idea to set an admin user and password for Syncthing.
To do so, click on the **Actions => Advanced** in the top-right pane. You should see the following page:
Now, provide your admin username and password and click on the **Save** button to apply the changes. You should get an authentication prompt for the username and password as shown below:
Provide your admin username and password and click on the **Sign** **in** button. You should see the following page:
Do the same procedure on the second server to set the admin password.
## Step 4 – Sync Data Between Two Servers
In this section, we will create a shared directory on **server1** and sync it with **server2**.
### Create a Shared Directory
First, you will need to add a folder that you want to share between two servers.
On the server1 dashboard, click on **Add** **Folder**. You should see the following screen:
Provide your folder name, folder ID, and the path of the folder and click on the **Save** button. Once the folder has been created, you should see the following screen:
### Sync Device ID
In order to get your two servers to talk to each other, you will need to exchange device IDs with other servers.
First, you will need to find the device ID of the second server.
On the **server2**dashboard, click on the **Actions => Show ID** to obtain Device ID as shown below:
On the **server1**dashboard, click on **Add Remote Device** as shown below:
Provide **server2**device ID, Device Name and click on the **Sharing** tab. You should see the following page:
Select a directory that you created earlier and click on the **Save** button. You should see the following page:
On the **Server2**dashboard, refresh the page. You should see the following page:
Click on the **Add** **Device** button to add the Server1 device ID to Server2. You should see the following page:
Click on the **Save** button to add the Server1 device ID to Server2. You will be asked whether you want to add folder shared on Server1 as shown below:
Click on the **Add** button. You should see the following page:
Provide Folder label, Folder ID, Folder path and click on the **Save** button. You should see that **server1** has been added to **server2** in the following page:
On the server1 dashboard, refresh the page and you should see that server2 has been added to server1 in the following page:
At this point, both servers are connected and syncing the directory /opt/MyApp. Now, any changes made in the /opt/MyApp directory will be replicated to the other server.
## Conclusion
In the above guide, you learned how to install and configure the Syncthing service on Ubuntu 18.04 server. You also learned how to sync a directory between two servers. You can now add an additional directory or server to sync. Try it today on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install MySQL 8.0 on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-mysql-8-0-on-ubuntu-18-04/ | Published: 2020-05-04 | Updated: 2023-11-24 | Author: Hitesh Jethva
MySQL is a free and open-source relational database management system for Linux-based operating systems. MySQL is the most widely used database system and is used for many open-source projects and high availability systems. If your server is running the older version of MySQL 5.7, then it is recommended to install MySQL 8 to use newly released features.
In this tutorial, we will explain how to install MySQL 8 on Ubuntu 18.04.
## Step 1 – Install MySQL 8 Repository
By default, MySQL 8 is not available in the Ubuntu 18.04 default repository, so you will need to add the MySQL 8 repository in your system.
First, download the repository package with the following command:
```
apt-get update -y
wget -c https://repo.mysql.com//mysql-apt-config_0.8.13-1_all.deb
```
Once downloaded, install the downloaded package with the following command:
```
dpkg -i mysql-apt-config_0.8.13-1_all.deb
```
During the installation process, you will be asked to choose the MySQL version as shown in the following screen:
Scroll down, select **Ok** and hit **Enter** to finish the installation.
## Step 2 – Install MySQL 8
Next, update the repository with the following command:
```
apt-get update -y
```
Once the repository is updated, run the following command to install MySQL 8 in your system.
```
apt-get install mysql-server -y
```
During the installation process, you will be asked to set the MySQL root password as shown below:
Next, you will need to select the default authentication plugin for MySQL as shown below:
Select “**Use Strong Password Encryption**” and hit **Enter** to finish the installation.
Next, you can verify the installed version of the MySQL with the following command:
```
mysql -V
```
You should get the following output:
```
mysql Ver 8.0.19 for Linux on x86_64 (MySQL Community Server - GPL)
```
## Step 3 – Manage MySQL Service
You can manage the MySQL service with the systemctl utility.
To start the MySQL service, run the following command:
```
systemctl start mysql
```
To enable the MySQL service to start after a system reboot, run the following command:
```
systemctl enable mysql
```
To check the status of the MySQL service, run the following command:
```
systemctl status mysql
```
Output:
## Step 4 – Secure MySQL Installation
It is also recommended to secure the MySQL installation and set the MySQL root password. You can do it using the mysql_secure_installation script:
```
mysql_secure_installation
```
You will be asked to provide your current root MySQL password as shown below:
```
Securing the MySQL server deployment.
Enter password for user root:
```
Provide your root password and hit **Enter**. You will be asked to validate the password to improve security as shown below:
Type **Y** and hit **Enter** to check the password strength as shown below:
Here, you can select your desired password strength and hit **Enter** to continue:
```
Estimated strength of the password: 100
Change the password for root ? ((Press y|Y for Yes, any other key for No) : Y
```
Type **Y** and hit **Enter** to change the password to one with the selected password strength:
```
New password:
Re-enter new password:
```
Type your new password and hit **Enter** to continue. You should see the following output:
```
Estimated strength of the password: 100
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y
```
Type **Y** and hit **Enter** to continue with your provided password as shown below:
```
By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.
Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y
Success.
```
Next, type **Y** and hit **Enter** to remove the anonymous user. You should see the following output:
```
Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.
Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y
```
Next, type **Y** and hit **Enter** to disallow root login from the remote machine. You should see the following output:
```
By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.
Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y
```
Type **Y** and hit **Enter** to remove the test database. You should see the following output:
```
- Dropping test database...
Success.
- Removing privileges on test database...
Success.
Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.
Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y
```
Finally, type **Y** and hit **Enter** to reload the privileges tables.
## Conclusion
Congratulations! You have successfully installed and secured MySQL 8 on Ubuntu 18.04. You can now connect to MySQL and create a database, user, or table and integrate it with many applications. Get started with MySQL today on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install Java on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-java-on-centos-8/ | Published: 2020-05-06 | Updated: 2024-06-11 | Author: Hitesh Jethva
Java JDK is a free and open-source software development kit used for building applications, applets, and components using the Java programming language. Java JDK comes with a set of tools for developing and testing applications written in the Java programming language; these tools include JRE, Java, Javac (Compiler) and Jar (Archiver).
There are two different implementations of Java, OpenJDK and Oracle JDK:
- **OpenJDK** is the free and open-source implementation of the Java Platform.
- **Oracle JDK** is a paid and permits only non-commercial use of the software.
In this tutorial, we will show you how to install OpenJDK 8, OpenJDK 11 and Oracle Java JDK 14 on CentOS 8.
## Step 1 – Install OpenJDK 11
By default, OpenJDK 11 is available in the CentOS 8 default repository. You can install it by running the following command:
```
dnf install java-11-openjdk -y
```
Once installed, verify the installed Java version with the following command:
```
java -version
```
You should see the following output:
## Step 2 – Install OpenJDK 8
By default, OpenJDK 8 is available in the CentOS 8 default repository. You can install it with the following command:
```
dnf install java-1.8.0-openjdk -y
```
Once installed, verify the installed Java version with the following command:
```
java -version
```
You should see the following output:
## Step 3 – Set Up the Default Java Version
At this point, you have two different versions of Java installed on your system. You can switch between multiple Java versions using the following command:
```
alternatives --config java
```
In the following output, you should see that OpenJDK 8 is the default version on your system.
Type **1** and press **Enter** to switch the Java version from OpenJDK 8 to OpenJDK 11.
Now, verify the default Java version with the following command:
```
java -version
```
You should see that OpenJDK 11 is the default Java version on your system.
## Step 4 – Setup JAVA_HOME Environment Variable
In some Java-based applications, you will need to define the installation location of Java to specify which Java version you want to use to run the application. You can use the JAVA_HOME environment variable to define the Java installation path.
You can set the JAVA_HOME environment variable for OpenJDK 11 by editing the file /etc/profile:
```
nano /etc/profile
```
Add the following line at the end of the file:
```
JAVA_HOME="/usr/lib/jvm/java-11-openjdk-11.0.5.10-2.el8_1.x86_64/"
```
Save and close the file when you are finished. Then, activate the changes with the following command:
```
source /etc/profile
```
Next, verify the JAVA_HOME environment with the following command:
```
echo $JAVA_HOME
```
You should get the following output:
## Step 5 – Install Oracle Java 14
First, you will need to download the Oracle Java 14 RPM package file from the [Oracle download page](https://www.oracle.com/java/technologies/javase-jdk14-downloads.html), as shown below.
Here, you can see the different versions of Java 14. Click on [jdk-14_linux-x64_bin.rpm](https://www.oracle.com/java/technologies/javase-jdk14-downloads.html#license-lightbox) to download it in your system.
You *may* now need to upload the file to your Centos8 server from your local desktop. This can be done using WinSCP.
Download WinSCP and install WinSCP using the following guide:
[guide install](https://winscp.net/eng/docs/guide_install)
Upload the file using your CentOS 8 server information:
Once the upload has completed, you can install it with the following command:
```
dnf localinstall jdk-14_linux-x64_bin.rpm -y
```
Once installed successfully, change the default Java version to Oracle Java 8 with the following command:
```
alternatives --config java
```
You should see a list of different Java versions in the following output:
Type **3** and hit **Enter** to change the default Java version.
Next, verify the Java default version with the following command:
```
java -version
```
You should see the following output:
## Conclusion
Congratulations! You have successfully installed Java on CentOS 8. I hope you have now enough knowledge to switch between different Java versions and start building your application on your [virtual private server](https://www.atlantic.net/vps-hosting/).
---
# How to Install Laravel Framework on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-laravel-framework-on-ubuntu-18-04/ | Published: 2020-05-08 | Updated: 2023-11-25 | Author: Hitesh Jethva
Laravel is a free and open-source PHP framework that can be used to build modern, fast, and scalable web applications. Laravel comes with expressive and elegant syntax that makes it a popular framework among PHP developers. Laravel uses a model view controller architecture pattern and comes with a lot of features including pagination, a complete authentication system, a powerful ORM, sessions, caching and many more. Laravel also provides a command-line interface called Artisan that can be used for building and managing Laravel-based apps.
In this tutorial, we will show you how to install Laravel Framework on Ubuntu 18.04.
## Prerequisites
- A fresh Ubuntu 18.04 [VPS](https://www.atlantic.net/vps-hosting/).
- A valid domain name pointed to your server. In this tutorial, we will use example.com domain.
- A root password configured on your server.
## Step 1 – Install LAMP Server
Laravel is based in PHP, runs on the webserver, and uses MySQL/MariaDB as a database backend, so you will need to install Apache, MariaDB, PHP and other required PHP extensions in your system. You can install all of them by just running the following command:
```
apt-get install apache2 libapache2-mod-php7.2 mariadb-server php7.2 php7.2-common php7.2-cli php7.2-gd php7.2-mysql php7.2-curl php7.2-intl php7.2-mbstring php7.2-bcmath php7.2-imap php7.2-xml php7.2-zip unzip git curl -y
```
Once all the packages are installed, you can proceed to the next step.
## Step 2 – Configure Database
Before configuring the database, it is recommended to set a MySQL/MariaDB root password and secure the MariaDB installation. You can do it by running the following script:
```
mysql_secure_installation
```
Answer each question as shown below to set a root password and secure the MariaDB installation:
Enter current password for root (enter for none): Just Press Enter
```
Set root password? [Y/n] Y
New password:
Re-enter new password:
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
```
Next, log in to the MariaDB shell with root user:
```
mysql -u root -p
```
Provide your MariaDB root password, then create a database and user for Laravel with the following command:
```
CREATE DATABASE laraveldb;
GRANT ALL ON laraveldb.* to 'laravel'@'localhost' IDENTIFIED BY 'password';
```
Next, flush the privileges and exit from MariaDB with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Install Composer
Next, you will need to install Composer in your system. Composer is a PHP dependency manager used for installing PHP dependencies.
First, download the Composer setup file from Composer’s website with the following command:
```
curl -sS https://getcomposer.org/installer -o composer-setup.php
```
Next, check whether the installation script is corrupt with the following command:
```
HASH="$(wget -q -O - https://composer.github.io/installer.sig)"
php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
```
You should get the following output if everything is fine:
```
Installer Verified
```
Finally, run the following command to install Composer:
```
php composer-setup.php --install-dir=/usr/local/bin --filename=composer
```
You should get the following output:
```
All settings correct for using Composer
Downloading...
Composer (version 1.10.0) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer
```
## Step 4 – Install Laravel
Next, change the directory to the Apache web root directory and create a Laravel project named mylaravel using Composer command as shown below:
```
cd /var/www/html
composer create-project --prefer-dist laravel/laravel mylaravel
```
You should get the following output:
**NOTE: If you get errors in during the installation about not enough swap file space available –**[**follow this process**](https://askubuntu.com/questions/920595/fallocate-fallocate-failed-text-file-busy-in-ubuntu-17-04)**. Make sure you run*rm -fr /var/www/html/mylaravel* if you get this error only.**
After successful installation, change the directory to mylaravel and start the Laravel application:
```
cd mylaravel
php artisan serve --host=your-server-ip --port=8000
```
You should see the following output:
```
Laravel development server started: http://your-server-ip:8000
```
Laravel is now installed and listening on port 8000. You can check it by visiting the URL http://your-server-ip-8000 in your web browser. You should get the Laravel default dashboard in the following screen:
Next, press **Ctrl + C** to stop Laravel.
## Step 5 – Configure Laravel
Next, you will need to configure Laravel to use MariaDB database. You can do it by editing the .env file:
```
nano /var/www/html/mylaravel/.env
```
Change the following lines that match with your database:
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laraveldb
DB_USERNAME=laravel
DB_PASSWORD=password
```
Save and close the file when you are finished. Then, give proper permissions to the Laravel project directory:
```
chown -R www-data:www-data /var/www/html/mylaravel/
chmod -R 775 /var/www/html/mylaravel/
```
Once you are done, you can proceed to the next step.
## Step 6 – Configure Apache for Laravel
Next, you will need to configure an Apache virtual host configuration file to serve the Laravel project. You can create it with the following command:
```
nano /etc/apache2/sites-available/laravel.conf
```
Add the following lines:
```
ServerAdmin webmaster@example.com
DocumentRoot /var/www/html/mylaravel/public
ServerName www.example.com
Options FollowSymLinks
AllowOverride None
AllowOverride All
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
```
Save and close the file when you are finished. Then, enable the Apache virtual host file with the following command:
```
a2ensite laravel.conf
```
Next, restart the Apache service to apply the changes:
```
systemctl restart apache2
```
## Step 7 – Access Laravel Dashboard
Now, open your web browser and type the URL [http://example.com](https://example.com/). You will be redirected to the Laravel default dashboard in the following screen:
## Conclusion
That’s it for now. You can now start creating your fast and scalable application with the Laravel framework. For more information visit the Laravel official documentation at [Laravel Doc](https://laravel.com/docs). If you’re ready to try out Laravel, [get a VPS today](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Install TimescaleDB on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-timescaledb-on-ubuntu-18-04/ | Published: 2020-05-12 | Updated: 2023-11-26 | Author: Hitesh Jethva
There are two types of database systems: relational databases and NoSQL databases. Relational databases are used to store data and cannot process a large amount of time series data. NoSQL databases are especially useful for working with large sets of distributed data.
TimescaleDB is a free and open-source time-series database specially designed for scale, ease-of-use, and complex queries. TimescaleDB is an extension of PostgreSQL offering the best of both NoSQL and relational database systems. You can write millions of data points per second and store 100s of billions of rows and 10s of terabytes of data with TimescaleDB.
In this tutorial, we will explain how to install TimescaleDB on Ubuntu 18.04.
## Step 1 – Install PostgreSQL
TimescaleDB is powered by PostgreSQL and used to analyze time-series data with a PostgreSQL query language, so you will need to install the PostgreSQL server 9.6 or later in your server.
You can install it by running the following command:
```
apt-get update -y
apt-get install postgresql-10 -y
```
After installing the PostgreSQL server, start the PostgreSQL service and enable it to start after system reboot with the following command:
```
systemctl start postgresql
systemctl enable postgresql
```
You can now verify the status of the PostgreSQL service with the following command:
```
systemctl status postgresql
```
You should see the following output:
By default, PostgreSQL is configured to login without a password, so it is recommended to set a password for the Postgres user.
To do so, log in with PostgreSQL user with the following command:
```
su - postgres
```
Next, set a password for the Postgres user with the following command:
```
psql -c "alter user postgres with password 'new-password'"
```
Next, exit from the PostgreSQL shell with the following command:
```
exit
```
Once you are done, you can proceed to the next step.
## Step 2 – Install and Configure TimescaleDB
By default, TimescaleDB is not available in the Ubuntu 18.04 default repository, so you will need to add the repository for TimescaleDB. You can add it with the following command:
```
add-apt-repository ppa:timescale/timescaledb-ppa -y
```
Once the repository has been added, update the repository with the following command:
```
apt-get update -y
```
Finally, install TimescaleDB by running the following command:
```
apt-get install timescaledb-postgresql-10 -y
```
Once installed, you will need to edit your postgresql.conf file and include the TimescaleDB library.
```
nano /etc/postgresql/10/main/postgresql.conf
```
Add the following line at the end of the file:
```
shared_preload_libraries = 'timescaledb'
```
Save and close the file when you are finished. Then, restart the PostgreSQL service to apply the changes:
```
systemctl restart postgresql
```
## Step 3 – Verify TimescaleDB Installation
At this point, TimescaleDB is installed and configured. It’s time to test the TimescaleDB database.
To do so, log in to PostgreSQL shell with the following command:
```
su - postgres
postgres@ubuntu1804:~$ psql
```
Next, create a new database named testdb with the following command:
```
postgres=# CREATE DATABASE timedb;
```
Next, connect to your database with the following command:
```
postgres=# \c timedb
```
Output:
You are now connected to database “timedb” as user “postgres”.
Finally, enable the TimescaleDB extension with the following command:
```
timedb=# CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;
```
You should get the following output:
The above output clearly indicates that the TimescaleDB is enabled with PostgreSQL.
Next, exit from the PostgreSQL shell with the following command:
```
\q
exit
```
## Conclusion
Congratulations! You have successfully installed TimescaleDB on Ubuntu 18.04 server. You can now take advantage the key benefits TimescaleDB offers over traditional relational database systems. For more information, refer to the official documentation at [TimescaleDB Doc](https://docs.timescale.com/). Get started with TimescaleDB today on Atlantic.Net [VPS Hosting](https://www.atlantic.net/vps-hosting/)!
---
# How to Find the Best Hosting Platform for HIPAA-Compliant Forms
> URL: https://www.atlantic.net/hipaa-compliant-hosting/how-to-find-the-best-hosting-platform-for-hipaa-compliant-forms/ | Published: 2020-05-14 | Updated: 2025-09-19 | Author: Brandon Schroth
Whether you are a pediatrician, an emergency room doctor, or a psychologist, collecting patient information through an online form is more efficient than using paper forms.
And amid the COVID-19 pandemic, it’s also a lot safer to have patients fill out forms through their phone or laptop instead of filling out paper forms using shared pens and clipboards that may have lingering germs.
However, online forms carry their own unique risks and challenges, mainly related to HIPAA compliance.
Congress passed [The Health Insurance Portability and Accountability Act (HIPAA)](https://www.dhcs.ca.gov/formsandpubs/laws/hipaa/Pages/1.00WhatisHIPAA.aspx) in 1996 as a way to regulate and secure sensitive personal health information.
This means that both your online form as well as your hosting platform must be fully HIPAA compliant.
In this post, we’re sharing some tips to help you find the best hosting platform for your HIPAA-compliant forms.
## What’s a HIPAA-Compliant Form?
Before you dive into the key considerations for choosing the right hosting platform, it’s important to define what a HIPAA-compliant form is.
You can create, collect, and store sensitive patient information through an online or mobile HIPAA-compliant form.
These forms range from new patient registrations, health consent forms, medical history forms, and online bill payments to prescription refill requests, medical record releases, incident reports, and patient feedback surveys.
HIPAA-compliant platforms, such as [JotForm](https://www.jotform.com/hipaa/), make it easy to set up a new form (often in a matter of a few minutes) and collect this information.
For example, if you are a psychologist, you could use JotForm to create a contact form that allows new patients to book their first appointment right on your website. The confirmation screen could then take them to a new patient onboarding form that asks questions about their medical and mental health history.
This process is way more efficient for patients than having to call to schedule their first appointment and then spending 10–15 minutes of the appointment filling out countless forms.
## What’s a HIPAA-Compliant Hosting Platform?
The other critical part of this process is your hosting provider. This is where your [HIPAA-compliant web hosting](https://www.atlantic.net/hipaa-compliant-hosting/) website and all electronic records are stored.
### The key factors to consider when evaluating hosting platforms
You can never be too careful when choosing and vetting your hosting platform.
Here is a checklist of things to look for when evaluating providers.
1. Does it have a**secure private hosted environment?** In order to be HIPAA compliant, you need to be on secure and private server. You need to have control over the server and ensure it has dedicated resources available and reserved for your exclusive use.
2. Does the platform provide **encrypted VPNs and firewalls?** There are actually three types of firewalls: hardware, software, and web applications. Many companies have been fined for HIPAA violations because they have necessary firewalls in place for their software but forget about the one-off Chrome plug-in they built to handle a specific process six months ago. Most importantly, is the firewall configured properly? Atlantic.Net engineers can help not only choose the right firewall and encryption, but also set it up properly.
3. Does the company have **multifactor authentication** (aka MFA) in place? This ultimately boils down to having at least two ways to verify someone’s identity, such as a code sent to a user’s phone or email address after they enter their username and password.
4. Does the provider have all of the **proper technical, physical, and administrative safeguards and protocols in place to prevent improper access to personal health records or sensitive data?** Make sure the data is fully encrypted and secure. This means having secure, thoroughly documented processes in place with data logs available. Making sure your provider is HIPAA and HITECH audited will go a long way. SOC certifications are also a helpful way to ensure you are hosting on the right infrastructure.
5. Does the company **limit and enforce who has access to their physical offices and facilities?** This relates to the point above. Does your hosting provider have processes in place to ensure that only authorized employees and personnel can enter their offices, including having to key in to get access? After all, what good are proper electronic protocols if anyone can enter the building and potentially access sensitive information?
6. Does the provider have **fast, friendly, and helpful customer support?** If you have a question, or in the event something breaks, you’ll need help immediately. Do you have confidence that they will respond quickly and work with you to resolve the issue efficiently? For example, is customer service always available via phone or email?
7. Does the company have **an extensive disaster recovery plan, including off-site backups?** There is the old adage “Hope for the best, but plan for the worst.” When dealing with sensitive patient information, you need to have mountains of contingency plans, including multiple, offsite backups. These contingency plans range from protecting any hackers to how to respond if a tornado levels one of your offices in Kansas.
8. Will the provider**sign a Business Associates Agreement (BAA)?** This agreement clearly outlines the specific roles and responsibilities of the hosting platform for maintaining HIPAA compliance.
9. How **long has the platform been HIPAA compliant, and has it ever run into issues?** A good starting point is to see if they’ve ever been fined for a HIPAA compliance violation.
There is one big caveat to all of this.
You can do your due diligence and thoroughly vet your [HIPAA-compliant hosting](https://www.atlantic.net/hipaa-compliant-hosting/) provider and still run into compliance issues down the line.
Let’s look at an example.
HIPAA compliance is often compared to driving a car. If you have a valid driver’s license and insurance, the state says you are allowed to drive.
However, if you decide to have a few cocktails, get behind the wheel, and crash into a tree, you are no longer compliant and will likely end up with hefty medical and legal bills from your DUI and emergency room visit.
The same principles apply to your hosting provider. They could be fully compliant. However, if your dev-ops team makes a mistake and forgets to properly secure a Chrome plug-in (which is easy to do), you will no longer be compliant.
The consequences for a HIPAA compliance violation can be steep, ranging from a few thousand dollars to jail time for malicious or particularly egregious offenses.
***
There are a lot of factors to consider when it comes to proper HIPAA compliance. The consequences of getting it wrong can be dire. Make sure to do your due diligence upfront when choosing a hosting platform. It is always best practice to focus on your core business and let the experts take care of HIPAA compliance. If you’re in the market for fast compliance, consider trying Atlantic.Net with a [free HIPAA trial](https://www.atlantic.net/hipaa-compliant-hosting/) or call one of our engineers to get a custom solution built for you.
Learn more about our [HIPAA compliant web hosting](https://www.atlantic.net/hipaa-compliant-hosting/) and [HIPAA cloud hosting](https://www.atlantic.net/hipaa-compliant-hosting/) solutions.
---
# How Can Cloud Technology Empower eLearning and Distance Learning?
> URL: https://www.atlantic.net/vps-hosting/how-can-cloud-technology-empower-elearning-and-distance-learning/ | Published: 2020-05-19 | Updated: 2026-06-04 | Author: Alexander Wise
Cloud technology is facilitating an educational revolution in delivering teaching services to students. The interoperability of the learning technology, in conjunction with the ability for almost anyone to consume education via a laptop and an internet connection, has helped online education to thrive globally.
The eLearning industry has flourished since the inception of cloud technology. Established Ivy League universities, schools, and specialist training houses have long been offering online education programs. In addition, many organizations offer a variety of online-only education services, and there has been a significant increase in [free online learning](https://www.youtube.com/watch?v=cjGERWYvzqk) programs.
## What Are eLearning and Distance Learning?
eLearning and distance learning are often thought of as interchangeable terms, but there are some meaningful differences between these two types of learning.
- **eLearning** is when the technique of learning is the same; generally, a teacher is communicating directly to students. However, the medium is changed from the classroom to an online forum, typically video conferencing. eLearning is often used to complement classroom-based study, but as we have seen in recent weeks, eLearning has quickly become the new way to teach.
- **Distance learning** is designed for foreign or rural students, commonly those attending University but are unable to travel to the University town to complete their studies. This might include a student based in the UK distance learning at an American University without ever having to move to the USA.
## Why Is Online Learning so Popular?
Teaching faculties are often regarded as forward-thinking establishments, institutions that embrace new technology. As such, the revolution in information technology in the 20th and 21st centuries has been heavily intertwined with places of education. As such, students both young and old, from all professions and backgrounds, are embracing a new approach to online learning powered by the cloud. Programs like [Florida Virtual School](https://www.flvs.net/) are taking off.
Prior to the Covid-19 pandemic, online education services were already growing with significant popularity; some [elearning statistics](https://www.learnworlds.com/elearning-statistics/) suggest that the sector could become a $319 billion industry by 2029.
Since COVID-19, eLearning and distance learning have really shown their strengths, and cloud computing has powered the fallback option to in-person education. One of the few positive outcomes of the pandemic is the number of [free education services being offered to parents](https://www.khanacademy.org/donate).
However, as many as [1.2 billion children](https://www.weforum.org/agenda/2020/04/coronavirus-education-global-covid19-online-digital-learning/) globally could be embarking on eLearning initiatives as of April 2020. While it is almost impossible to provide statistically accurate figures at present, there are a huge number of students who have been forced to adapt to online teaching in light of the Coronavirus crisis.
## How Does the Cloud Empower Online Learning?
There are several ways in which the cloud has simplified and empowered education-as-a-service. eLearning and distance learning material are easy to access via the Web, they rarely require the installation of any client-side software, online learning services are easily consumed using low cost, pay by subscription tariffs, and [eLearning platforms](https://www.ispringsolutions.com/blog/elearning-platforms) for state schools typically offer free access for millions of students.
Cloud computing technology provides a number of core beneficial features needed to bring learning to the student. Two key beneficial features are scalability and accessibility. It is relatively easy to create an online learning application that can be used by students, that incorporates video streams provided by teachers, that includes downloadable learning materials and whiteboards, etc. However, creation of such a solution becomes more complex when introducing scale.
### Scalability & Accessibility
There are currently millions of American schools embarking on cloud teaching to their students, and [Cloud Service Providers](https://www.atlantic.net/cloud-platform/) are supplying the infrastructure to make it happen. The influx of network traffic and server load created by the multiple simultaneous connections from students’ devices to the learning material can put massive strain on the eLearning infrastructure.
Cloud technology handles this risk by introducing scalability, applications, and server workloads that can scale up and out as needed. Practically limitless cycles of CPU and memory can be made available, and the network layer, typically a cloud load balancer, can distribute heavy workloads to multiple endpoints.
What this means in real terms is that ten of thousands of students can live stream classroom content, contribute in-class discussion, and submit work in a seamless manner. Accessibility is key because every student is accessing the learning platform from a different internet endpoint. The connection needs to be stable, secure, and in many cases encrypted during transit. Only the massive scale of cloud infrastructure can absorb this level of intense workload on-demand.
### Privacy & Security
The cloud resolves many other technical challenges introduced by eLearning and distance learning. One such challenge is the maintenance of the security, privacy, and confidentiality of the enrolled students and participating staff. Many cloud service providers are extensively audited and certified for data protection safeguards. Cloud hosting introduces high availability, fault tolerance, and the option for automatic recovery in the event the infrastructure is overloaded.
### Distance Learning & School Choice
For the students of distance learning, cloud technology allows almost anyone to learn at the institution of their choice. Overseas learning has thrived since education providers have leveraged cloud resources to distribute learning, with some sources estimating that as many as 15% of enrolled students in the United States are doing distance learning.
## Final Thoughts
The COVID-19 pandemic has highlighted how important online learning services are for professionals, students, and parents. Few predicted the turmoil that would result from closing schools and universities around the world. Cloud technology has made a significant difference to many students’ lives, offering an education platform that can be accessed by everyone, on-demand.
Atlantic.Net is already helping many learning partners who have reached out to see how we can help them with server usage spikes and how to create a more cost-effective solution. Our [VPS hosting](https://www.atlantic.net/vps-hosting/) technology is cutting edge, available 24x7x365 with a 100% uptime guarantee, we offer a user-friendly cloud platform that can spin up what you need in seconds. We believe that eLearning powered by the cloud is the future of education services.
---
# How to Setup Passwordless Sudo for a Specific User
> URL: https://www.atlantic.net/vps-hosting/how-to-setup-passwordless-sudo-for-a-specific-user/ | Published: 2020-06-11 | Updated: 2023-11-25 | Author: Hitesh Jethva
In a Linux system, the root user is a superuser that has permission to access everything on the server. A standard user account only has limited privileges and can run only specific commands on the system.
The sudo command elevates a standard user account, granting root access to the system. Every time you sudo a sudo command you will be prompted for the sudoer password, which can become repetitive. However, there is a great way to securely configure a passwordless sudo account
In this tutorial, we will show you how to set up Passwordless Sudo in Linux.
## Step 1 – Configure Passwordless Sudo For a Specific User
If you want to allow a user named vyom to execute sudo without a password, edit the /etc/sudoers file:
```
nano /etc/sudoers
```
Add the following line at the end of the file:
```
your_username ALL=(ALL:ALL) NOPASSWD:ALL
```
For example:
```
Atlantic-Admin ALL=(ALL:ALL) NOPASSWD:ALL
```
Save and close the file.
Then, run any superuser command with sudo:
```
sudo fdisk -l
```
You don’t need to provide any password after running the above command.
## Step 2 – Configure Passwordless Sudo For a Specific Group
If you want to allow a member of a specific group named www-data to execute sudo without a password, edit the /etc/sudoers file:
```
nano /etc/sudoers
```
Add the following line at the end of the file:
```
%www-data ALL=(ALL:ALL) NOPASSWD:ALL
```
Save and close the file when you are finished.
## Step 3 – Configure Passwordless Sudo For All Users
If you want to allow all users to execute sudo without a password **(note: this is only advisable in test systems and should never be used on production workloads)**, edit the /etc/sudoers file:
```
nano /etc/sudoers
```
Find the following line:
```
%sudo ALL=(ALL:ALL) ALL
```
Replace it with the following line:
```
%sudo ALL=(ALL:ALL) NOPASSWD:ALL
```
## Step 4 – Configure Passwordless Sudo For Specific User to Execute Only Specific Command
If you want to allow a specific user named vyom to execute only “fdisk -l” command without password, edit the /etc/sudoers file:
```
nano /etc/sudoers
```
Add the following line at the end of the file:
```
your_username ALL=(ALL:ALL) NOPASSWD: /sbin/fdisk -l
```
Save and close the file when you are finished.
Now, only the user can only run the “fdisk -l” command without a password.
## Conclusion
In the above guide, you have learned how to configure passwordless sudo for a specific group, specific user and all users. Ready to get started with Passwordless Sudo in Linux? Get [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
Learn more about our [VPS hosting](https://www.atlantic.net/vps-hosting/) services and [Virtual private servers.](https://www.atlantic.net/vps-hosting/)
---
# New European and Californian data privacy regulations are creating a significant challenge to achieving the HIPAA disaster recovery safeguards
> URL: https://www.atlantic.net/hipaa-compliant-hosting/new-european-and-californian-data-privacy-regulations-are-creating-a-significant-challenge-to-achieving-the-hipaa-disaster-recovery-safeguards/ | Published: 2020-06-12 | Updated: 2026-06-17 | Author: Richard Bailey
While achieving HIPAA-compliant status has always been a significant accomplishment for cloud hosting providers, organizations that process electronic Protected Health Information (ePHI) for the purposes of business continuity and disaster recovery recently had two major constraints added on top of HIPAA compliance requirements.
Healthcare organizations, business associates, and third parties already must adhere to a stringent set of data handling regulations enforced ever since the enactment of [Health Insurance Portability and Accountability Act](https://www.hhs.gov/hipaa/for-professionals/security/laws-regulations/index.html) (HIPAA) in 1996. More recently, new data privacy requirements have been passed in the European Union (EU) and the state of California that have added further restrictions on data processing and data handling.
## Game-Changing New Regulations
The California Consumer Privacy Act (CCPA) and the General Data Protection Regulations (GDPR) are both recently passed privacy acts that update antiquated laws in relation to how personal information (PI) is handled, stored, and processed. Since the proliferation of Internet services, mobile telecommunications, and social media, campaigners have been demanding changes to how businesses handle PI.
[Hipaa Violations by Type – Pie Chart](https://commons.wikimedia.org/wiki/File:Hipaa_Violations_by_Type_-_Pie_Chart.png)
CCPA was passed in 2018 and came into force on January 1, 2020. GDPR was passed into law on May 25, 2018. Both legislations have similar recommendations and requirements, but GDPR is focused on European citizens’ personal information while CCPA relates to US citizens’ personal information.
Importantly, both legislations have a shared synergy that impacts businesses on both sides of the Atlantic. Any business in the United States that is responsible for processing European personal information, and any business in Europe that processes US personal information, must adhere to each of the new legislation guidelines to be compliant with the updated privacy rules.
To briefly summarise GDPR, some of the key protections introduced are:
- GDPR requires that permission must be granted prior to collecting data. This is why you now see “Accept All Tracking Cookies” popups when you enter your favorite websites.
- You must notify of a data breach within 72 hours.
- Upon request, data collectors must be able to explain what information is being collected, how it is being used, and whether the data is being shared.
- EU citizens have the right to have any and all data held on them deleted by the collector.
The CCPA protections are largely the same as GDPR, and some of the key elements are:
- US citizens have the right to know what personal information is being collected, sold, or disclosed.
- US citizens have the right to view their collected data and demand their data is not sold.
- CCPA applies if a company generates more than $25 million USD a year and half of that revenue is from selling personal data.
For those trying to [balance HIPAA compliance](https://www.atlantic.net/hipaa-compliant-hosting/hipaa-compliance-guide-what-is-hipaa/) with the requirements of these two new pieces of legislation, pay attention – here is the important information you need to know.
## When Data Disaster Strikes
HIPAA compliance requires that an organization must develop a contingency plan that allows an organization to both protect ePHI and quickly recover core business functions in the event of a disaster. Disaster recovery is an information technology safeguard designed to protect both the business operations and the access to ePHI. The ability of a healthcare facility to be able to resume day-to-day activities and process ePHI is an essential part of compliance.
[Ransomware pic jpg](https://commons.wikimedia.org/wiki/File:Ransomware-pic.jpg)
For a quick example, let’s consider a hypothetical hospital whose infrastructure has been [infected with ransomware](https://www.atlantic.net/vps-hosting/ransomware-in-the-wild/). Without normal access to patient medical records, one would expect the business operations of the hospital to grind to a halt quickly. HIPAA regulations were created to combat such an “Armageddon” scenario, meaning that the hospital could fail over technical services to a secondary location, thus restoring access to core applications and ePHI.
When the U.S. Department of Health and Human Services (HHS) created the HIPAA act, it is unlikely that they could have predicted what future local or international privacy rules might be introduced and their impact on US legislation. Likewise, GDPR and CCPA legislation was focused on protecting data privacy online, but was seemingly not tailored with the medical industry in mind.
## The Problem with Duplicate Data Centers
Prior to the recent legislation, a favorite disaster recovery solution to protect data was to simply create redundant data center(s) in different geographic location(s) or to contract a colocation facility. The end result is that if the onsite database becomes unavailable due to a malfunction, it is often a simple matter to switch over production services to the secondary location.
Complications arise due to the fact that both GDPR and CCPA require that all personally identifiable information related to any person in the database can be [removed upon request](https://www.csoonline.com/article/3292578/california-consumer-privacy-act-what-you-need-to-know-to-be-compliant.html). Handling these requests and securely wiping the requested data has to be done not only on the live database, but also any replica copies.
Healthcare organizations and cloud service providers are having to create automated processes and routines that identify expired data and delete what is out of scope. The business associates must work together to identify data that is in scope, as well as understand how long the data can be retained to remain compliant. The end result of these additional requirements is more work and an increased chance of mistakes, and this might place the entire organization in violation of the new regulations if not done correctly.
## The Problem of Unstructured Data
When it comes to protecting or deleting personal information, such as, in one example, a Social Security number from the Social Security Administration’s database, the task to achieve this is not overly complicated. This is because a Social Security number is structured data that is easily located within a database.
Unstructured data, such as documents, emails, form submissions, excel files are much more complex. The reason is that these files might contain Protected Information, and it would be an administrative nightmare to audit every single file for sensitive information. This problem makes precise analysis and location of personal data a huge challenge.
Advanced tools can be deployed that encrypt data at rest and in transit, or use AI to redact information buried in documents. In one popular example, if an administrator accidentally sent a manual payment receipt to a patient and the [PAN](https://en.wikipedia.org/wiki/PAN_truncation#:~:text=%22PAN%22%20is%20an%20acronym%20for,being%20replaced%20usually%20by%20asterisks.) was not hashed out, intelligent email software can identify this information in email attachments and reject sending of the email, automatically responding to the sender that their action would breach GDPR or CCPA regulations. However, the implementation of these toolsets is technically challenging and expensive to achieve.
## The Right to be Forgotten
Prior to GDPR and CCPA legislation, some speculated that personal privacy may have already been dead – check out this [article about Amazon Alexa](https://www.gadgetguy.com.au/alexa-invades-your-privacy-and-how-to-stop-it/?display=all) if you don’t believe it – but the foundations of both the GDPR and CCPA rest on the idea that an individual has the right to be forgotten. In other words, any website or business that holds your information in a database is required to delete it upon request.
This newly outlined right often clashes with practical business processes in reality. A good example is bank loans. Does it make sense that you can ask your banker to get rid of all your data he or she has on file immediately after you’ve taken out a $250,000 loan? Probably not.
The right to be forgotten directly impacts disaster recovery services, creating an almost impossible situation for business associates. HIPAA legislation demands that the location of ePHI is known explicitly to all involved. However, the reality is that many medical professionals do not have a firm grasp on what ePHI data that they do have, which makes the process of reliably deleting requested records an exercise in futility.
The added complication makes choosing the best HIPAA compliant hosting partner an essential due diligence exercise the healthcare organization must undertake. The right partner can help to guide healthcare professionals in achieving compliance and knowing exactly what ePHI data is in the scope of the legislation.
## Hackers Create a Huge Liability
It’s one thing if an earthquake, hurricane, flood, or tornado were to take out a hospital’s frontline database. Such “acts of God” are unavoidable. But if you own one or more of the [1.24 billion websites active online](https://hostingcanada.org/internet-statistics/) now, you have to be even more worried about human intrusion, which presents a greater danger when measured against the standards set out by these new regulations.
Cyberattacks that leave behind malware and steal personally identifiable information are often preventable. The responsibility lies with the organization and technology business partners, and failure to uphold this responsibility can bring a heavy financial penalty.
[European 451 Error Code Example png](https://en.m.wikipedia.org/wiki/File:European_451_Error_Code_Example.png)
For example, the first year GDPR was active yielded $344 million worth of fines that mostly fell in the category of “insufficient security measures.” GDPR penalties for a single incident can run [as high as $20 million euros](https://www.zdnet.com/article/gdpr-an-executive-guide-to-what-you-need-to-know/) or 4% of global income, whichever number is higher. That’s a hefty fine to be dropping on top of an organization that is already reeling from what might have been a costly security breach.
## Final Thoughts
Disaster recovery remains a critical part of HIPAA compliance, and healthcare organizations and their technology partners must be able to create a disaster recovery solution that protects ePHI, as well as the core applications that process and maintain ePHI, at all times.
In-scope ePHI must be identified, and its locations documented, within a Business Associate Agreement (BAA). The technology partner and the healthcare institution must work together to ensure ePHI is protected at all times. GDPR and CCPA require explicit consent to access ePHI, but HIPAA allows anonymized data to be made public.
The rules are slightly different when reporting a data breach to the authorities. HIPAA demands that the Officer for Civil Rights (OCR) must be informed for breaches of 500 or more patients within 60 days, while for GDPR there is a 72-hour breach reporting window.
From the preceding analysis, it’s easy to see why cyber insurance has become an increasingly popular solution. In theory, cyber insurance could protect an online company by paying off fines imposed by regulators. There are mixed opinions on this type of protection; for some, it adds peace of mind, while for others it provides protection when inadequate information technology is available.
For now, any organization under the auspices of HIPAA would do well to find a security expert with some track record of success in navigating the current regulatory minefield.
---
# File Permissions in Linux with Example
> URL: https://www.atlantic.net/vps-hosting/file-permissions-in-linux-with-example/ | Published: 2020-06-13 | Updated: 2023-11-16 | Author: Hitesh Jethva
Linux is a multi-user operating system with multiple users accessing the same system. System administrators are responsible for preventing a user from accessing another user’s confidential files. For these reasons, Linux divides authorization into two levels, Ownership and Permission.
## File Ownership
Each file and directory has three kinds of owners.
- **User:** A “user” is the owner of the file. If you create a new file, then you become the owner of the file.
- **Group:** Every user is a part of the specific “group.” A group contains multiple users, all of whom will have the same access permissions to the file.
- **Other:** All users and groups in the system are considered as “others.”
Owners are denoted with the following symbols:
- u = user owner
- g = group owner
- o = other
- a = all (user + group + other)
## Change the Ownership with chown
To display the ownership of the file *index.html* in */var/www/html*directory, run the following command:
```
ls -l /var/www/html/index.html
```
You should get the following output:
```
-rw-r--r-- 1 www-data www-data 11510 Feb 3 20:25 /var/www/html/index.html
```
As you can see, the group and user owner of the file is www-data.
A basic syntax to change the ownership of the file is shown below:
```
chown owner:group filename
```
To change the owner of the file *index.html* to root and group to root, run the following command:
```
chown root:root /var/www/html/index.html
```
You can use the -R option with the *chown*command to change the ownership of the directory recursively.
For example, to change the ownership of the directory */var/www/html* to www-data**as the user** and www-data **as the group**, run the following command:
```
chown -R www-data:www-data /var/www/html/
```
This will change the ownership of all files and directories located inside */var/www/html/.*
## File Permissions
Each file and directory has three types of permission:
- **Read:** You can view and read the content of the file, but can not edit or modify the file. You can list the content of the directory with “read” permission.
- **Write:** You can read and edit the content of the file. You can also rename and remove the file. You can add, remove, and rename files in the directory with “read” permission.
- **Execute:** You can execute the file.
Permissions are defined using **octal permissions**. These are nine characters created in three sets of three characters:
```
--- --- ---
rwx rwx rwx
user group other
```
Each letter denotes a particular permission:
- **r:** Read permission
- **w:** Write permission
- **x:** Execute permission
- **–:** No permission set
Permissions are also represented in numeric form as shown below:
- **r**(read) = 4
- **w**(write) = 2
- **x**(execute) = 1
- **–**(no permission) = 0
- **rwx**= 4+2+1 = 7
- **rw**= 4+2 = 6
You can also use mathematical operators to add and remove permissions.
- **+:** Add the permissions.
- **-:** Remove the permissions.
- **=:** Overriding existing permissions.
## Change the Permissions with chmod
*Chmod*stands for **change mode**, and it is a basic syntax used to change the permissions of the file:
```
chmod permissions filename
```
To check the permissions of the file, run the following command:
```
ls -l /var/www/html/index.html
```
Output:
```
-rw-r--r-- 1 www-data www-data 11510 Feb 3 20:25 /var/www/html/index.html
```
As you can see, the owner of the file has *read/write* permissions, the group has *read*permission and the other has *read*permission.
To add *execute*permissions to the user, run the following command:
```
chmod u+x /var/www/html/index.html
```
Now, verify the permissions with the following command:
```
ls -l /var/www/html/index.html
```
Output:
```
-rwxr--r-- 1 www-data www-data 11510 Feb 3 20:25 /var/www/html/index.html
```
To add write permissions to group and others, run the following command:
```
chmod g+w,o+w /var/www/html/index.html
```
Now, verify the permissions with the following command:
```
ls -l /var/www/html/index.html
```
Output:
```
-rwxrw-rw- 1 www-data www-data 11510 Feb 3 20:25 /var/www/html/index.html
```
To remove the write permissions from others, run the following command:
```
chmod o-w /var/www/html/index.html
```
Now, verify the permissions with the following command:
```
ls -l /var/www/html/index.html
```
Output:
```
-rwxrw-r-- 1 www-data www-data 11510 Feb 3 20:25 /var/www/html/index.html
```
You can also set the permissions using the **octal value**. You can use the following values for each permission:
**777 =** rwxrwxrwx
**765 =** rwxrw-r-x
**654 =** rw-r-xr–
For example, change the permissions of the file so that the user can *read/write and execute*, the group can *read*and *execute*and the others can only *read*the file.
```
chmod u=rwx,g=rx,o=r /var/www/html/index.html
```
Or
```
chmod 754 /var/www/html/index.html
```
## Conclusion
In the above guide, you learned how ownership and permissions work in Linux. You also learned how to set and change the ownership and permissions of the files and directories. I hope you have now enough understanding of file ownership and permissions – try it today on your [Linux VPS](https://www.atlantic.net/vps-hosting/).
---
# Top 8 MySQL Command-line Tips and Tricks
> URL: https://www.atlantic.net/vps-hosting/top-8-mysql-command-line-tips-and-tricks/ | Published: 2020-06-14 | Updated: 2025-09-19 | Author: Hitesh Jethva
MySQL is an open-source relational database management system that is developed, distributed, and supported by Oracle Corporation. There are several web-based tools available for managing the MySQL server, but best practice is to use the native MySQL command-line client for performing day-to-day MySQL tasks. It does take some time to get familiar with a command-line interface, particularly if you don’t regularly work in a CLI environment.
In this tutorial, we will show you some MySQL command-line tips and tricks that help you to perform day-to-day tasks.
## Prerequisites
- A fresh Ubuntu 18.04 [VPS](https://www.atlantic.net/vps-hosting/) with MySQL installed on the Atlantic.Net Cloud Platform.
- A root password configured on your server.
## Create Atlantic.Net Cloud Server
First, log in to your [Atlantic.Net Cloud Server](https://cloud.atlantic.net/?page=userlogin). Create a new [server](https://www.atlantic.net/vps-hosting/how-to-create-new-atlantic-net-cloud-server/), choosing Ubuntu 18.04 as the operating system with at least 1GB RAM. Connect to your Cloud Server via SSH and log in using the credentials highlighted at the top of the page.
Once you are logged into your Ubuntu 18.04 server, run the following command to update your base system with the latest available packages.
```
apt-get update -y
```
## 1 – Automate the MySQL Login
In order to connect the MySQL server, you will be required to authenticate by specifying a username and password.
If this is your routine process, then you can save your lots of time by specifying your MySQL username and password in ~/.my.cnf file to automate the login process.
To do so, create a ~/.my.cnf file in your home directory:
```
nano ~/.my.cnf
```
Add the following information containing your MySQL host, username, and password:
```
[client]
host = localhost
user = root
password = your-password
```
Save and close the file then change the ownership of the file to mysql:
```
chown mysql:mysql ~/.my.cnf
```
Now, you can connect your MySQL server without specifying a username and password as shown below:
```
mysql
```
You should get the following output:
```
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 5
Server version: 5.7.29-0ubuntu0.18.04.1 (Ubuntu)
Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql>
```
## 2 – Check Running Processes
To check all the running processes of the MySQL service, run the following command:
```
mysqladmin -u root -pnew-password processlist
```
You should see the following output:
```
mysqladmin: [Warning] Using a password on the command line interface can be insecure.
+----+------+-----------+----+---------+------+----------+------------------+
| Id | User | Host | db | Command | Time | State | Info |
+----+------+-----------+----+---------+------+----------+------------------+
| 6 | root | localhost | | Query | 0 | starting | show processlist |
+----+------+-----------+----+---------+------+----------+------------------+
```
## 3 – Shutdown MySQL Service
To shut down the MySQL server, run the following command:
```
mysqladmin -u root -pnew-password shutdown
```
## 4 – Create and Delete Database
To create a new database, run the following command:
```
mysqladmin -u root -pnew-password create dbname
```
To remove a database, run the following command:
```
mysqladmin -u root -pnew-password drop dbname
```
## 5 – Check the Status of MySQL
To check whether the MySQL server is running or not, use the following command:
```
mysqladmin -u root -pnew-password ping
```
You should get the following output:
```
mysqld is alive
```
To verify the current status of the MySQL server, run the following command:
```
mysqladmin -u root -pnew-password status
```
You should see the status of uptime with running threads and queries in the following output:
```
Uptime: 2607 Threads: 1 Questions: 30 Slow queries: 0 Opens: 112 Flush tables: 2 Open tables: 0 Queries per second avg: 0.011
```
If you want to check the status of remote MySQL server, run the following command:
```
mysqladmin -h remote-server-ip -u root -pnew-password status
```
## 6 – Check MySQL Version
To check the installed version of the MySQL server, run the following command:
```
mysqladmin -u root -pnew-password version
```
You should get the following output:
```
mysqladmin: [Warning] Using a password on the command line interface can be insecure.
mysqladmin Ver 8.42 Distrib 5.7.29, for Linux on x86_64
Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Server version 5.7.29-0ubuntu0.18.04.1
Protocol version 10
Connection Localhost via UNIX socket
UNIX socket /var/run/mysqld/mysqld.sock
Uptime: 44 min 44 sec
Threads: 1 Questions: 35 Slow queries: 0 Opens: 113 Flush tables: 2 Open tables: 1 Queries per second avg: 0.013
```
## 7 – Store MySQL Debug Information
If you want to tell MySQL server to write debug information in MySQL log file, run the following command:
```
mysqldump -u root -pnew-password debug
```
## 8 – Backup and Restore MySQL Database
To back up a single database, run the following command:
```
mysqldump -u root -pnew-password databasename > database-backup.sql
```
To back up multiple databases in a single file, run the following command:
```
mysqldump -u root -pnew-password database1 database2 database3 > database-backup.sql
```
To back up all databases in a single file, run the following command:
```
mysqldump -u root -pnew-password --all-databases --single-transaction --quick --lock-tables=false > full-database.sql
```
To restore a database from the backup file, run the following command:
```
mysqldump -u root -pnew-password databasename < database-backup.sql
```
## Conclusion
In the above guide, you learned some useful MySQL commands with examples. We hope this will help you to save lots of time when using MySQL on your [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Set Up Apache as Frontend Proxy Server for Node.js CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-set-up-apache-as-frontend-proxy-server-for-node-js-centos-8/ | Published: 2020-06-15 | Updated: 2024-07-02 | Author: Hitesh Jethva
Node.js is an open-source, cross-platform, JavaScript runtime environment that can be used to run JavaScript outside the web browser. It is most commonly used to build web applications with real-time, two-way connections, where both the client and server can initiate communication, allowing them to exchange data freely. Node.js uses an event-driven, non-blocking I/O model that makes it perfect for data-intensive applications that run across distributed devices.
In this tutorial, we will install Node.js and configure it to run as a backend server; then, we will configure Apache as frontend proxy server for Node.js.
## Step 1 – Install Node.js
By default, the latest version of the Node.js is not available in the CentOS 8, so you will need to add Node.js repository in your system.
You can install the Node.js repository using the following command:
```
curl --silent --location https://rpm.nodesource.com/setup_18.x | bash -
```
Once the repository is installed, you can install Node.js by simply running the following command:
```
dnf install nodejs -y
```
Once the installation has been completed, you can verify the installed version of Node.js with the following command:
```
node -v
```
You should get the following output:
```
v18.19.0
```
You can also check the NPM version with the following command:
```
npm -v
```
You should get the following output:
```
10.2.3
```
## Step 2 – Create a Sample Node.js Application
First, let’s create a directory to hold the Node.js application:
```
mkdir project
```
Next, change the directory to project and create a sample Node.js application with the following command:
```
cd project
nano app.js
```
Add the following contents:
```
var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Welcome to Node.js Server');
}).listen(8080, "127.0.0.1");
console.log('Server running at http://127.0.0.1:8080/');
```
Save and close the file when you are finished.
Your Node.js application is now ready to serve on port 8080. Next, start the application with the following command:
```
node app.js
```
You should get the following output:
```
Server running at http://127.0.0.1:8080/
```
The above output indicates that your Node.js application is working properly.
Next, press **CTRL + C** to stop the application.
## Step 3 – Install and Configure PM2 to Manage Node.js Application
PM2 is a process manager for the Node.js application. It allows you to keep Node.js application alive forever, to manage Node.js, to reload Node.js without downtime, and to facilitate common system admin tasks.
You can install it using the NPM as shown below:
```
npm i -g pm2
```
After installing PM2, change the directory to the project and start the Node.js application with PM2 as shown below:
```
pm2 start app.js
```
Once the application has been started successfully, you should get the following output:
```
-------------
__/\\\\\\\\\\\\\____/\\\\____________/\\\\____/\\\\\\\\\_____
_\/\\\/////////\\\_\/\\\\\\________/\\\\\\__/\\\///////\\\___
_\/\\\_______\/\\\_\/\\\//\\\____/\\\//\\\_\///______\//\\\__
_\/\\\\\\\\\\\\\/__\/\\\\///\\\/\\\/_\/\\\___________/\\\/___
_\/\\\/////////____\/\\\__\///\\\/___\/\\\________/\\\//_____
_\/\\\_____________\/\\\____\///_____\/\\\_____/\\\//________
_\/\\\_____________\/\\\_____________\/\\\___/\\\/___________
_\/\\\_____________\/\\\_____________\/\\\__/\\\\\\\\\\\\\\\_
_\///______________\///______________\///__\///////////////__
Runtime Edition
PM2 is a Production Process Manager for Node.js applications
with a built-in Load Balancer.
Start and Daemonize any application:
$ pm2 start app.js
Load Balance 4 instances of api.js:
$ pm2 start api.js -i 4
Monitor in production:
$ pm2 monitor
Make pm2 auto-boot at server restart:
$ pm2 startup
To go further checkout:
http://pm2.io/
-------------
[PM2] Spawning PM2 daemon with pm2_home=/root/.pm2
[PM2] PM2 Successfully daemonized
[PM2] Starting /root/project/app.js in fork_mode (1 instance)
[PM2] Done.
┌─────┬────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├─────┼────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ app │ default │ N/A │ fork │ 1437 │ 0s │ 0 │ online │ 0% │ 31.1mb │ root │ disabled │
└─────┴────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
```
Next, enable the Node.js application to start at boot time with the following command:
```
pm2 startup
```
This command will create a systemd service file for the Node.js application and enable it to start after system reboot as shown below:
```
[PM2] Init System found: systemd
Platform systemd
Template
[Unit]
Description=PM2 process manager
Documentation=https://pm2.keymetrics.io/
After=network.target
[Service]
Type=forking
User=root
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
Environment=PM2_HOME=/root/.pm2
PIDFile=/root/.pm2/pm2.pid
Restart=on-failure
ExecStart=/usr/lib/node_modules/pm2/bin/pm2 resurrect
ExecReload=/usr/lib/node_modules/pm2/bin/pm2 reload all
ExecStop=/usr/lib/node_modules/pm2/bin/pm2 kill
[Install]
WantedBy=multi-user.target
Target path
/etc/systemd/system/pm2-root.service
Command list
[ 'systemctl enable pm2-root' ]
[PM2] Writing init configuration in /etc/systemd/system/pm2-root.service
[PM2] Making script booting at startup...
[PM2] [-] Executing: systemctl enable pm2-root...
Created symlink /etc/systemd/system/multi-user.target.wants/pm2-root.service → /etc/systemd/system/pm2-root.service.
[PM2] [v] Command successfully executed.
+---------------------------------------+
[PM2] Freeze a process list on reboot via:
$ pm2 save
[PM2] Remove init script via:
$ pm2 unstartup systemd
```
You can also list your active application with the following command:
```
pm2 list
```
You should get the following output:
```
┌─────┬────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├─────┼────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ app │ default │ N/A │ fork │ 1437 │ 104s │ 0 │ online │ 0.1% │ 39.7mb │ root │ disabled │
└─────┴────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
```
## Step 4 – Configure Apache as a Frontend Proxy for Node.js
Next, you will need to install and configure the Apache webserver as a frontend server to access the Node.js application.
First, install the Apache webserver with the following command:
```
dnf install httpd -y
```
Next, create an Apache virtual host configuration file for Node.js application with the following command:
```
nano /etc/httpd/conf.d/example.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
ServerName node.example.com
ErrorLog /var/log/httpd/error.log
CustomLog /var/log/httpd/access.log combined
ProxyRequests On
ProxyPass / http://localhost:8080
ProxyPassReverse / http://localhost:8080
```
Save and close the file when you are finished. Then, start the Apache webserver and enable it to start at reboot with the following command:
```
systemctl start httpd
systemctl enable httpd
```
## Step 5 – Access Node.js Application
At this point, the Apache webserver is configured to access the Node.js application. Next, open your web browser and type the URL http://node.example.com. You will be redirected to the Node.js application page as shown below:
## Conclusion
Congratulations! You have successfully deployed Node.js application with Apache as a frontend server. You can now start building your Node.js application for the production environment – try it on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Create a SFTP User without Shell Access on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-create-a-sftp-user-without-shell-access-on-centos-8/ | Published: 2020-06-16 | Updated: 2024-06-04 | Author: Hitesh Jethva
SFTP stands for “SSH File Transfer Protocol.” SFTP is a file transfer protocol used to transfer files between two servers. By default, SFTP allows you to transfer files on all servers that have SSH access enabled. However, it will grant terminal access to all users and this is not recommended for security reasons.
In this tutorial, we will learn how to create an SFTP user without shell access so that the user has only SFTP access and not SSH access.
## Step 1 – Create an SFTP User
First, you will need to create a new user with only file transfer access. You can create a new user named sftp using the following command:
```
adduser sftp
```
Next, set the password for the above user:
```
passwd sftp
```
Provide your desired password and hit enter.
## Step 2 – Create a Directory Structure for File Transfers
Next, you will need to create a directory structure for file transfer to restrict SFTP access to one directory.
You can create a new directory with the following command:
```
mkdir -p /opt/sftp/public
```
Next, set the ownership of the /opt/sftp/ directory to root:
```
chown root:root /opt/sftp
```
Next, give proper permissions with the following command:
```
chmod 755 /opt/sftp
```
Next, set the ownership of the public directory to the sftp user:
```
chown sftp:sftp /opt/sftp/public
```
## Step 3 – Configure SSH for SFTP
Next, you will need to configure SSH to restrict access to one directory and disallow terminal access to the sftp user.
You can do it by editing the file /etc/ssh/sshd_config:
```
nano /etc/ssh/sshd_config
```
Add the following lines at the end of the file:
```
Match User sftp
ForceCommand internal-sftp
PasswordAuthentication yes
ChrootDirectory /opt/sftp
PermitTunnel no
AllowAgentForwarding no
AllowTcpForwarding no
X11Forwarding no
```
Save and close the file when you are finished. Then, restart the SSH service to implement the changes:
```
systemctl restart sshd
```
## Step 4 – Verify SFTP
Now, verify the SFTP access with the following command:
```
sftp sftp@your-server-ip
```
You will be asked to provide a password as shown below:
```
sftp@your-server-ip's password:
```
Provide your sftp user password and hit Enter. Once connected, you should see the following output:
```
Connected to your-server-ip.
sftp>
```
Next, run the following command to list the directory:
```
sftp> ls
```
You should see the public directory in the following output:
```
public
sftp>
```
Next, verify whether you are able to make SSH connection or not:
```
ssh sftp@your-server-ip
```
You will be asked to provide a password as shown below:
```
sftp@your-server-ip's password:
```
Provide your sftp user password and hit Enter. You should see the following output:
```
This service allows sftp connections only.
Connection to your-server-ip closed.
```
The above output indicates that sftp user can no longer access the server shell via SSH.
## Conclusion
Congratulations! You have successfully configured SFTP without shell access on CentOS 8. You can also use this setup for multiple users and directory. Get started with SFTP today on a [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# Why All Small Business Owners Need to Install SSL Certificates Immediately
> URL: https://www.atlantic.net/hipaa-compliant-wordpress-hosting/why-all-small-business-owners-need-to-install-ssl-certificates-immediately/ | Published: 2020-06-17 | Updated: 2026-05-04 | Author: Brandon Schroth
Consumer opinions about security are shifting as new technologies, such as the Internet of Things (IoT), enter the marketplace.
Studies increasingly show the impact of security breaches on average people. As many as [25% of people](https://www.experian.com/blogs/ask-experian/identity-theft-statistics/) have experienced some kind of identity theft.
When you start to build a website for your small business, you have to ensure that your customers’ data is protected and that your company is secured against cyber attacks and [data breaches](https://www.atlantic.net/hipaa-data-centers/data-breaches-caused-by-misconfigured-servers-within-a-healthcare-environment/).
Adequate defense of your business from malicious code is extremely difficult to achieve, especially when that code has been designed to destroy your infrastructure and allow cybercriminals to access your data, steal it, and sell it to the highest bidder on the black market.
With so many different forms of attack, it can be confusing to know where to begin, but one strategy every business should use is to protect their customers through a [Secure Sockets Layer certificate (SSL)](https://www.atlantic.net/vps-hosting/what-is-ssl-certificate/).
## What exactly is an SSL certificate?
An SSL certificate ensures that content provided to users originates from the correct sender – thus making communications through computer networks far more secure.
For example, if you are using an online service like Netflix, Amazon, or Google, an SSL certificate can ensure that you are confident you are using the right service, and not a fake one. Because of this, including an SSL in [your business plan](https://www.freshbooks.com/blog/5-simple-rules-for-writing-solid-business-plans) should be essential, as it helps to verify who you are to your customers.
In order to obtain certain (and reputable) SSL certificates, companies have to be thoroughly vetted before they will be allowed to [display the certificate](https://smallbusiness.chron.com/can-sites-ssl-certificate-57315.html) on their webpages and provide a secure connection.
## Why use SSL certification?
While you should also maintain other channels of communication with customers for convenience and security, protecting and [combining your business communications over the Internet](https://www.getweave.com/5-reasons-for-small-businesses-to-combine-communication-through-their-phone-system/) will always be key, especially as online communication becomes more frequent.
Consumers have come to expect their sensitive information to be secure when they are shopping online. By displaying an SSL certification to your customers, you are telling them that your business takes security seriously and you are taking steps to protect them from identity theft.
Not only does this help to protect you from a data breach, but it is also essential for building customer trust. While this may increase costs, most providers offer a verified SSL certificate typically at a low cost or free.
Alongside this, consider that failing to use a certification can lead to being penalized by search engines. Google has specifically stated that they have been testing to see whether secure sites tend to rank higher in searches. When they did, they [started using HTTPS and SSL](https://searchengineland.com/google-starts-giving-ranking-boost-secure-httpsssl-sites-199446) as a ranking signal. While this won’t be a primary ranking factor, they have suggested it will become more important over time.
## How to get an SSL certification
Every SSL company has a different approach for verifying a website, so your first step should always be getting background information about the company or Certification Authority (CA) that will be providing your SSL. You’ll want to see what their vetting process is and read reviews from other businesses so that you’re sure you’re being protected by a credible source.
Once you have decided on using a reputable provider, you will request certification and pay for it. After the payment is completed, the CA will then begin the process of verifying your website. The amount of time this takes can vary, but approval usually takes around an hour. The time taken depends on the complexity of your business and [the encryption required](https://www.thesslstore.com/blog/understanding-the-encryption-technology-behind-ssl/).
Once the certificate is paid for and approved, you can install it and secure your website behind the new web protocol.
## How do you check to see if a website is SSL protected?
When customer data is spread across emails, payments, data, and login information, users need to feel that their data is [safe with secure encryption methods](https://privacycanada.net/classical-encryption/).
While there may be vulnerabilities on their side, such as using a poorly secured browser, it builds confidence if they know you’ve taken steps to protect your organization and their data. Users also want to be sure that any website that they visit and use to make purchases has been thoroughly vetted and confirmed to be legitimate.
Here are some methods to check that your page, or another company’s, is SSL protected:
1. A padlock symbol will appear on the far left side of the browser bar. If this symbol is broken or absent, this indicates the page is not secured by an SSL. This symbol can be clicked and it will provide more information about the company that is connected to the website.
2. The URL will begin with “https”, which indicates that users are securely connected. HTTP (hypertext transfer protocol) was the old standard for websites, and the addition of S indicates the increased level of security. This is essential when websites are transmitting sensitive information such as credit card details, especially when your website is [built on vulnerable platforms](https://really-simple-ssl.com/hardening-your-websites-security/).
3. The address bar will sometimes have a green background color that indicates it has gone through additional layers of vetting. This is typically referred to as extended validation.
## Conclusion
Small business owners have multiple reasons to install SSL certificates as part of their overall plan to [mitigate cybersecurity risks](https://www.atlantic.net/hipaa-compliant-hosting/how-to-best-mitigate-cybersecurity-risks-and-protect-your-data/). If they are taking payments online, they want to make sure they limit the risk of a data breach by making sure payments take place over a secure connection.
Even if your business doesn’t handle payments online, securing your employee’s connections helps to ensure business-critical data isn’t at risk of being stolen in a data breach. By installing an SSL, you help to keep your business network and customers safe – a move that will improve trust in your company and keep your business secure from cybersecurity threats.
To learn more about how Atlantic.Net can help you secure your [web hosting server](https://www.atlantic.net/hipaa-compliant-wordpress-hosting/) with an SSL certificate, contact our sales team today at [sales@atlantic.net](mailto:sales@atlantic.net).
---
# How to Copy Files and Directories in Linux
> URL: https://www.atlantic.net/vps-hosting/how-to-copy-files-and-directories-in-linux/ | Published: 2020-06-18 | Updated: 2026-03-02 | Author: Hitesh Jethva
If you are a system administrator, copying files and directories is one of the most common tasks in your day-to-day work. The cp command is a basic Linux command used for copying files and directories from one location to another. By default, the cp command is available in almost all Unix- and Linux-like operating systems.
In this tutorial, we will show you how to use the cp command to copy files and directories in Linux.
## The cp Command Options
The basic syntax of the cp command is shown below:
```
cp [OPTION] [SOURCE] [DESTINATION]
```
A brief explanation of each available option is shown below:
- **-a :** Copy files and directories recursively and preserve links.
- **-i :** You will be prompted before overwriting any existing file on the destination.
- **-r :** Copy directory recursively.
- **-f :** Remove an existing destination file if it can not be opened.
- **-u :** Copy only when the SOURCE file is newer.
## Copy a File to Directory
If you want to copy a single file named /etc/crontab to the /mnt directory, run the following command:
```
cp /etc/crontab /mnt
```
You can now verify it with the following command:
```
ls -l /mnt
```
You should see your file in the following output:
```
-rw-r--r-- 1 root root 1042 Jun 21 11:32 crontab
```
## Copy Multiple Files to Directory
If you want to copy multiple files named /etc/hosts and /etc/hostname at the same time to the /mnt directory, run the following command:
```
cp /etc/hosts /etc/hostname /mnt
```
If you want to display verbose output during the copying process, run the following command:
```
cp -v /etc/hosts /etc/hostname /mnt
```
You should see the following output:
```
'/etc/hosts' -> '/mnt/hosts'
'/etc/hostname' -> '/mnt/hostname'
```
## Copy a File Interactively
If you want to copy a file interactively, use the option -i with cp command. This option will prompt you before copying the file to the destination directory if the same file already exists.
```
cp -i /etc/crontab /mnt
```
You should see the following output:
```
cp: overwrite '/mnt/crontab'? yes
```
If you don’t want to overwrite an existing file, you can use the option -n.
```
cp -vn /etc/crontab /mnt
```
This will not prompt for the overwrite and also will not overwrite the existing file.
## Copy a Directory Recursively
You can use option -r with cp command to copy files and directory recursively.
```
cp -r /etc/apache2 /mnt
```
You can also use -a option to archive the files and directory during the copy.
```
cp -ar /etc/apache2 /mnt
```
## Preserve mode, ownership, and timestamps
If you want to preserve mode, ownership, and timestamps after copying files and directories, you can use -p option:
```
cp -arp /etc/apache2 /opt
```
## Backup a Destination File
By default, the cp command will overwrite the file on the destination directory if the same file exists. In this case, you can use –backup option to back up any existing destination file during the copying process.
```
cp --backup=simple -v /etc/hosts /mnt
```
You should see the following output:
```
'/etc/hosts' -> '/mnt/hosts' (backup: '/mnt/hosts~')
```
## Copy Multiple Files from One Directory to Another
You can also copy multiple files from one directory to another using the *. For example, if you want to copy all PHP files from the /var/www/wordpress directory to the /mnt directory, you can copy them with the following command:
```
cp -r /var/www/wordpress/*.php /mnt/
```
This command will find all files with .php extension in the /var/www/wordpress/ directory and copy them into the /mnt directory.
## Conclusion
In this guide, you learned how to use the cp command to copy files and directories. Get started with the cp command today on a [Linux VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Schedule Cron Jobs with Crontab
> URL: https://www.atlantic.net/vps-hosting/how-to-schedule-cron-jobs-with-crontab/ | Published: 2020-06-19 | Updated: 2025-09-19 | Author: Hitesh Jethva
Cron is a time-based job scheduling daemon in Linux-based operating systems. It is used to schedule specific tasks to run periodically at fixed times, dates, or intervals. It is very similar to the Windows task scheduling utility and is very useful for routine tasks including:
- Daily backups
- System scanning
- Automated system maintenance
The cron daemon runs in the background and continuously checks the /etc/crontab file, and /etc/cron.*/ directories.
## Crontab Syntax
The basic syntax of crontab file is shown below:
```
M H DOM MON DOW USER COMMAND
* * * * * root command(s)
- - - - -
| | | | |
| | | | ----- Day of week (0 - 7) (Sunday=0 or 7)
| | | ------- Month (1 - 12)
| | --------- Day of month (1 - 31)
| ----------- Hour (0 - 23)
------------- Minute (0 - 59)
```
- **Minutes (M)** specified as a number from 0 to 59.
- **Hours (H)** specified as numbers from 0 to 23.
- **Days of the month (DOM)** specified as numbers from 1 to 31.
- **Months (MON)** specified as numbers from 1 to 12.
- **Days of the week (DOW)** specified as numbers from 0 to 7, with Sunday represented as either/both 0 and 7.
## Crontab Commands
Some commonly used crontab commands are shown below:
- crontab -e : Used to edit or create a new crontab file.
- crontab -l : Used to display the content of the crontab file.
- crontab -i : Used to remove the current crontab file with a prompt before removal.
- crontab -r : Used to remove the current crontab file without prompt.
- crontab -u : Used to edit other user’s crontab file.
## 1. Schedule a cron to execute at 10 AM Daily task
If you want to have a script named /opt/test.sh run every day at 10 AM, run the following command:
```
crontab -e
```
Add the following line:
```
0 10 * * * /bin/sh /opt/test.sh
```
## 2. Schedule a cron to execute on every 5 minutes
To run a test.sh script every 5 minutes, redirect the standard output to /dev/null, and send errors to a specified email address, run the following command:
```
crontab -e
```
Add the following line:
```
MAILTO=admin@example.com
*/5 * * * * /bin/sh /opt/test.sh > /dev/null
```
## 3. Schedule a cron to execute on every day, every hour, on the hour from 10 AM to 6 PM
To run a test.sh script every day, every hour, on the hour from 10 AM to 6 PM, run the following command:
```
crontab -e
```
Add the following line:
```
00 10-18 * * * /bin/sh /opt/test.sh
```
## 4. Schedule a cron to execute at 10 AM on the first of every month
To run a test.sh script at 10 AM on the first of every month, run the following command:
```
crontab -e
```
Add the following line:
```
00 10 1 * * /bin/sh /opt/test.sh
```
## 5. Schedule a cron to execute at 10 minutes after midnight and every three hours after that, every day
To run a test.sh script at 10 minutes after midnight and every 3 hours after that, every day, run the following command:
```
crontab -e
```
Add the following line:
```
10 0-23/3 * * * /bin/sh /opt/test.sh
```
## 6. Schedule a cron to execute on specific days
To run a test.sh script each Monday and Friday at 6 PM, run the following command:
```
crontab -e
```
Add the following line:
```
0 18 * * mon,fri /bin/sh /opt/test.sh
```
## 7. Schedule a cron to execute multiple scripts
To run a test.sh and test1.sh script at a 2-hour interval, run the following command:
```
crontab -e
```
Add the following line:
```
0 */2 * * * /bin/sh /opt/test.sh; /bin/sh /opt/test1.sh
```
## 8. Schedule a cron to execute every week, month or year
To run a test.sh every week, add the following line:
```
@weekly /bin/sh /opt/test.sh
```
To run a test.sh every month, add the following line:
```
@monthly /bin/sh /opt/test.sh
```
To run a test.sh every year, add the following line:
```
@yearly /bin/sh /opt/test.sh
```
## Conclusion
In the above guide, you learned what cron is and how to use it, with several examples. Start using cron jobs to automate daily tasks today with [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Backup and Restore a Database in PostgreSQL
> URL: https://www.atlantic.net/vps-hosting/how-to-backup-and-restore-database-in-postgresql/ | Published: 2020-06-22 | Updated: 2023-11-21 | Author: Hitesh Jethva
PostgreSQL is free, open-source, and one of the most popular relational database management systems, powering millions of applications. Suppose you are a database administrator using PostgreSQL in a production environment. In that case, it is essential to back up your database so you can quickly restore your system if your database is lost.
PostgreSQL has built-in utilities to create or restore the database backup by default. There are several ways to backup and restore your PostgreSQL databases. With PostgreSQL, you can easily take a full, incremental, or continuous backup. You can use the pg_dump utility to back up the PostgreSQL database. This function allows you to back up a local database and restore it on a remote database simultaneously.
In this tutorial, we will show you how to back up and restore the PostgreSQL database in Linux.
## Understand the Basic Syntax of pg_dump
PostgreSQL comes with built-in utilities called pg_dump for quickly creating and restoring backups.
The basic syntax of the pg_dump command is shown below:
```
pg_dump [OPTION]... [DBNAME]
```
A brief explanation of each option is shown below:
**-d, –dbname=DATABASENAME :** Used to specify the database that you want to back up.
**-h, –host=HOSTNAME :** Used to specify the hostname of your database server.
**-U, –username=USERNAME :** Used to specify the PostgreSQL username.
**-w, –no-password :** Used to ignore the password prompt.
**-p, –port=PORT :** Used to specify the PostgreSQL server port number.
**-W, –password :** Used to force password prompt.
**–role=ROLENAME :** SET ROLE before the dump.
## Backup and Restore a Single Database
You can back up and restore a single database using the pg_dump utility. The basic syntax to back up a single database is shown below:
```
pg_dump -d [source-database] -f [database_backup.sql]
```
For example, to back up a single database named testdb and generate a backup file named testdb_backup.sql, run the following command:
```
su - postgres
pg_dump -d testdb -f testdb_backup.sql
```
You can also restore a single database using psql command. The basic syntax to restore a single database is shown below:
```
psql -d [destination_database] -f [database_backup.sql]
```
For example, to restore a single database named testdb from a backup file named testdb_backup.sql, run the following command:
```
su - postgres
psql -d testdb -f testdb_backup.sql
```
You should get the following output:
```
SET
SET
SET
SET
SET
set_config
------------
(1 row)
SET
SET
SET
SET
```
If you want to stop the database restore process in case an error occurs, run the following command:
```
psql -d testdb --set ON_ERROR_STOP=on -f testdb_backup.sql
```
**Note :** Before restoring any database, it is recommended to terminate all connections to that database and prepare the backup file.
## Backup and Restore All Databases
You can [back up all databases in PostgreSQL](https://airbyte.com/tutorials/postgres-replication) using pg_dumpall utility. The basic syntax to backup all databases as shown below:
```
pg_dumpall -f [alldatabase_backup.sql]
```
For example, to back up all databases in PostgreSQL and generate a backup file named alldb_backup.sql, run the following command:
```
pg_dumpall -f alldb_backup.sql
```
To restore all databases from a backup file named alldb_backup.sql, run the following command:
```
psql -f alldb_backup.sql
```
## Backup and Restore Single Table
PostgreSQL also allows you to back up a single table from the specific database. You can achieve this using the following syntax:
```
pg_dump -d [source-database] -t [table_name]-f [dbtable_backup.sql]
```
For example, to back up a table named mytab from the database named testdb and generate a backup file named testdb_mytab.sql, run the following command:
```
pg_dump -d testdb -t mytab -f testdb_mytab_backup.sql
```
If you want to restore this table from the backup file, run the following command:
```
psql -d testdb -f testdb_mytab_backup.sql
```
## Backup and Restore Compressed Database
You can also back up the PostgreSQL database and compress it in .gz format to reduce the backup size.
To take a back up of database named testdb and generate a compressed backup file named testdb_compressed.sql.gz, run the following command:
```
pg_dump -d testdb | gzip > testdb_compressed.sql.gz
```
You can also restore the backup from the compressed file using the following command:
```
gunzip -c testdb_compressed.sql.gz | psql -d testdb
```
## Conclusion
In the above guide, you learned several ways to backup and restore a PostgreSQL database to help you perform day-to-day database backup operations. Get started today with a PostgreSQL database on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install and Secure MongoDB 4 in CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-secure-mongodb-4-in-centos-8/ | Published: 2020-06-23 | Updated: 2023-11-17 | Author: Hitesh Jethva
MongoDB is a cross-platform NoSQL database system written in C++. MongoDB is different from traditional table-based SQL databases like MySQL and PostgreSQL and is specially designed for high-volume data storage. MongoDB uses JSON-like documents with dynamic schemas and does not require a predefined schema before you add data to a database. MongoDB is free, open-source, and comes with a rich set of features including, storage, data replication, Ad-hoc queries, load balancing, and many more.
In this tutorial, we will explain how to install and secure MongoDB on CentOS 8.
## Step 1 – Add the MongoDB Repository
By default, MongoDB is not available in the CentOS 8 default repository, so you will need to create a repo file for MongoDB.
You can create it with the following command:
```
nano /etc/yum.repos.d/mongodb-org.repo
```
Add the following lines:
```
[mongodb-org-4.2]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.2.asc
```
Save and close the file when you are finished. Next, you can proceed to install MongoDB in your system.
## Step 2 – Install MongoDB
Now, you can install the MongoDB by simply running the following command:
```
dnf install mongodb-org -y
```
Once the installation has been completed, start the MongoDB service and enable it to start after system reboot with the following command:
```
systemctl start mongod
systemctl enable mongod
```
You can now check the status of the MongoDB service using the following command:
```
systemctl status mongod
```
You should see the following output:
```
● mongod.service - MongoDB Database Server
Loaded: loaded (/usr/lib/systemd/system/mongod.service; enabled; vendor preset: disabled)
Active: active (running) since Fri 2020-04-10 10:58:18 EDT; 7s ago
Docs: https://docs.mongodb.org/manual
Process: 2904 ExecStart=/usr/bin/mongod $OPTIONS (code=exited, status=0/SUCCESS)
Process: 2902 ExecStartPre=/usr/bin/chmod 0755 /var/run/mongodb (code=exited, status=0/SUCCESS)
Process: 2899 ExecStartPre=/usr/bin/chown mongod:mongod /var/run/mongodb (code=exited, status=0/SUCCESS)
Process: 2897 ExecStartPre=/usr/bin/mkdir -p /var/run/mongodb (code=exited, status=0/SUCCESS)
Main PID: 2906 (mongod)
Memory: 77.0M
CGroup: /system.slice/mongod.service
└─2906 /usr/bin/mongod -f /etc/mongod.conf
Apr 10 10:58:17 centos8 systemd[1]: Starting MongoDB Database Server...
Apr 10 10:58:17 centos8 mongod[2904]: about to fork child process, waiting until server is ready for connections.
Apr 10 10:58:17 centos8 mongod[2904]: forked process: 2906
Apr 10 10:58:18 centos8 mongod[2904]: child process started successfully, parent exiting
Apr 10 10:58:18 centos8 systemd[1]: Started MongoDB Database Server.
```
Now, MongoDB is running and listening on port 27017. You can verify it with the following command:
```
netstat -pnltu | grep 27017
```
You should get the following output:
```
tcp 0 0 127.0.0.1:27017 0.0.0.0:* LISTEN 2906/mongod
```
You can also access the MongoDB shell with the following command:
```
mongo
```
You should get the following output:
```
MongoDB shell version v4.2.5
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("b0f7656f-f939-4f50-87d2-01cbeca0849a") }
MongoDB server version: 4.2.5
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see
http://docs.mongodb.org/
Questions? Try the support group
http://groups.google.com/group/mongodb-user
Server has startup warnings:
2020-04-10T10:58:18.521-0400 I CONTROL [initandlisten]
2020-04-10T10:58:18.521-0400 I CONTROL [initandlisten] ** WARNING: Access control is not enabled for the database.
2020-04-10T10:58:18.521-0400 I CONTROL [initandlisten] ** Read and write access to data and configuration is unrestricted.
2020-04-10T10:58:18.521-0400 I CONTROL [initandlisten]
2020-04-10T10:58:18.521-0400 I CONTROL [initandlisten]
2020-04-10T10:58:18.521-0400 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2020-04-10T10:58:18.521-0400 I CONTROL [initandlisten] ** We suggest setting it to 'never'
2020-04-10T10:58:18.522-0400 I CONTROL [initandlisten]
---
Enable MongoDB's free cloud-based monitoring service, which will then receive and display
metrics about your deployment (disk utilization, CPU, operation statistics, etc).
The monitoring data will be available on a MongoDB website with a unique URL accessible to you
and anyone you share the URL with. MongoDB may use this information to make product
improvements and to suggest MongoDB products and deployment options to you.
To enable free monitoring, run the following command: db.enableFreeMonitoring()
To permanently disable this reminder, run the following command: db.disableFreeMonitoring()
---
```
You can exit from the MongoDB shell with the following command:
```
>exit
```
## Step 3 – Enable MongoDB Authentication
By default, authentication is disabled in MongoDB. Any user can interact with the database, and create and destroy databases. It is a good idea to enable authentication in MongoDB. You can enable it by editing mongod.conf file:
```
nano /etc/mongod.conf
```
Add the following line at the end of the file:
```
security:
authorization: enabled
```
Save and close the file when you are finished. Then, restart the MongoDB service to apply the changes:
```
systemctl restart mongod
```
## Step 4 – Create a MongoDB Admin User
Next, you will need to create an administrative user with all privileges to perform administrative tasks.
First, access the MongoDB shell with the following command:
```
mongo
```
You should get the following output:
```
MongoDB shell version v4.2.5
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("09e0e028-cd26-4f9d-9270-52b938925f99") }
MongoDB server version: 4.2.5
```
Next, change the database to admin with the following command:
```
> use admin
```
Next, create a MongoDB admin user called myadmin with the following command:
```
> db.createUser( { user: "myadmin", pwd: "password", roles: [ { role: "userAdminAnyDatabase", db: "admin" } ] } )
```
Once the user has been created, you should get the following output:
```
Successfully added user: {
"user" : "myadmin",
"roles" : [
{
"role" : "userAdminAnyDatabase",
"db" : "admin"
}
]
}
```
Next, exit from the MongoDB shell with the following command:
```
>exit
```
## Step 5 – Verify MongoDB Authentication
At this point, MongoDB is configured with authentication. Now you will be required to provide a username and password before interacting with MongoDB.
Next, connect the MongoDB without authentication:
```
mongo
```
You should get the following output:
```
MongoDB shell version v4.2.5
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("fecf1846-13fd-4959-91da-5cf323781e13") }
MongoDB server version: 4.2.5
```
Now, run the following command to list MongoDB users:
```
> show users
```
You should get the following error:
```
2020-04-10T11:08:04.598-0400 E QUERY [js] uncaught exception: Error: command usersInfo requires authentication :
_getErrorWithCode@src/mongo/shell/utils.js:25:13
DB.prototype.getUsers@src/mongo/shell/db.js:1638:15
shellHelper.show@src/mongo/shell/utils.js:883:9
shellHelper@src/mongo/shell/utils.js:790:15
@(shellhelp2):1:1
```
This demonstrates that you can not list the users without authenticating.
Now, exit from MongoDB with the following command:
```
>exit
```
## Step 6 – Access MongoDB with Administrative User
Now, let’s connect to the MongoDB with the administrative user:
```
mongo -u myadmin -p --authenticationDatabase admin
```
You will be asked to provide your admin password as shown below:
```
MongoDB shell version v4.2.5
Enter password:
```
Provide your admin password and hit **Enter**. You should get the following output:
```
connecting to: mongodb://127.0.0.1:27017/?authSource=admin&compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("a39f723c-f1b5-4c93-9e67-ff82379dfb62") }
MongoDB server version: 4.2.5
```
Next, change the database to admin and list the users with the following command:
```
> use admin
> show users
```
You should get the following output:
```
{
"_id" : "admin.myadmin",
"userId" : UUID("bcd920c1-63fd-4b82-a8a6-eb6515d51a34"),
"user" : "myadmin",
"db" : "admin",
"roles" : [
{
"role" : "userAdminAnyDatabase",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
```
Now, exit from the MongoDB shell with the following output:
```
> exit
```
## Conclusion
In the above guide, we learned how to install MongoDB on CentOS 8. We have also shown how to enable MongoDB authentication and create an administrative user. Your MongoDB on your Atlantic.Net VPS is now secured with username and password – if you don’t have a VPS from Atlantic.Net, get started with [VPS hosting](https://www.atlantic.net/vps-hosting/) today to install MongoDB!
---
# How To Secure PostgreSQL Server
> URL: https://www.atlantic.net/vps-hosting/how-to-secure-postgresql-server/ | Published: 2020-06-24 | Updated: 2023-11-27 | Author: Hitesh Jethva
PostgreSQL, also known as Postgres, is a general-purpose object-relational database management system. It is one of the most advanced open-source databases available. However, there are many security concerns and potential vulnerabilities if the application is not secured correctly.
If you are a system or database administrator, you need to know how to protect Postgres prior to going into production.
In this tutorial, we will show you how to secure the PostgreSQL server on Ubuntu18.04.
## Step 1 – Install PostgreSQL
By default, the PostgreSQL server package is available in the Ubuntu 18.04 default repository. You can install it by running the following command:
```
apt-get update -y
apt-get install postgresql postgresql-contrib -y
```
Once the installation has been completed, start the PostgreSQL server and enable it to start at reboot:
```
systemctl start postgresql
systemctl enable postgresql
```
## Step 2 – Create Database and User
Next, you will need to create a database and user for testing purposes.
First, log in to PostgreSQL shell with the following command:
```
sudo -i -u postgres psql
```
You should see the following output:
```
psql (10.12 (Ubuntu 10.12-0ubuntu0.18.04.1))
Type "help" for help.
postgres=#
```
Next, create a user named testuser and set the password.
```
postgres=# CREATE USER testuser WITH PASSWORD 'password';
```
Next, create a database named testdb and grant full access to the new user:
```
postgres=# CREATE DATABASE testdb OWNER testuser;
```
Next, exit from the PostgreSQL shell with the following command:
```
postgres=# \q
```
## Step 3 – Configure Listening Address
By default, the PostgreSQL server is listening on the localhost and can not be accessed from outside the network.
For the production environment, you will need to configure PostgreSQL to listen on a public interface.
You can change this setting by editing the file /postgresql.conf:
```
nano /etc/postgresql/10/main/postgresql.conf
```
Find the following line:
```
#listen_addresses = 'localhost'
```
Replace it with the following:
```
listen_addresses = 'localhost,your-server-ip'
```
Save and close the file when you are finished. Then, restart the PostgreSQL service to implement the changes:
```
systemctl restart postgresql
```
## Step 4 – Configure the Allowed Hosts
For better security, it is recommended to allow only specific IPs to access and modify the PostgreSQL database. You can do it by editing the file pg_hba.conf:
```
nano /etc/postgresql/10/main/pg_hba.conf
```
Find the following line:
```
# local DATABASE USER METHOD [OPTIONS]
```
Add the following line below the above line:
```
host testdb testuser client-ip-address/32 md5
```
Save and close the file when you are finished. Then, restart the PostgreSQL service to implement the changes:
```
systemctl restart postgresql
```
**Where:**
**host** : host is a plain or SSL-encrypted TCP/IP socket.
**database** : testdb is the name of the database the host can connect to.
**user** : testuser is the name of the user that is allowed to make the connection.
**address** : client-ip-address/32 specify the IP address of the client computer.
**auth-method** : md5 is the name of the authentication method.
## Step 5 – Configure UFW Firewall
By default, the UFW firewall comes pre-installed in all Debian based distributions. If not installed, you can install it with the following command:
```
apt-get install ufw -y
```
Next, it is recommended to configure the UFW firewall rule to grant access to the PostgreSQL default port 5432 to only the client’s IP.
**IMPORTANT:** Before starting, you will need to allow incoming SSH connection through UFW, as that will make you lose shell access. You will be locked and unable to connect to your instance.
You can allow SSH service using the following command:
```
ufw allow ssh
```
Next, enable the UFW firewall with the following command:
```
ufw enable
```
Next, allow PostgreSQL port 5432 to only client’s IP address using the following command:
```
ufw allow from client-ip-address to any port 5432
```
Next, check the status of the UFW rule with the following command:
```
ufw status
```
You should get the following output:
```
Status: active
To Action From
-- ------ ----
22/tcp ALLOW Anywhere
5432 ALLOW client-ip-address
22/tcp (v6) ALLOW Anywhere (v6)
```
## Step 6 – Verify the Remote Connection
At this point, the PostgreSQL server is secured and accessible only from the client’s IP.
To verify it, connect your PostgreSQL database from the client’s system:
```
psql -U testuser -h postgres-server-ip -d testdb
```
You will be asked to provide the password for testuser, as shown below:
```
Password for user testuser:
```
Type your password and hit **Enter**. Once the connection has been established, you should get the following output:
```
psql (9.3.24, server 10.12 (Ubuntu 10.12-0ubuntu0.18.04.1))
WARNING: psql major version 9.3, server major version 10.
Some psql features might not work.
SSL connection (cipher: ECDHE-RSA-AES256-GCM-SHA384, bits: 256)
Type "help" for help.
testdb=>
```
That’s it for now.
## Conclusion
In the above guide, you learned how to secure the PostgreSQL by configuring PostgreSQL to grant access to only specific hosts. You have also learned how to configure UFW to allow connections only from specific hosts. You should now be able to protect your PostgreSQL server from certain kinds of attacks. Get started today with [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Protect Business Data When Employees Are Working from Home
> URL: https://www.atlantic.net/hipaa-compliant-hosting/how-to-protect-business-data-when-employees-are-working-from-home/ | Published: 2020-06-29 | Updated: 2025-09-19 | Author: Richard Bailey
Over the last decade, the number of employees working from home has steadily increased. Estimates suggest that [1 in 10 US citizens](https://www.gensler.com/uploads/document/695/file/Gensler-US-Work-From-Home-Survey-2020-Briefing-1.pdf) had regularly worked from home up to 2019. Understandably, since the outbreak of Covid-19 in the first half of 2020, this figure has grown exponentially, a trend that is likely to continue for the foreseeable future.
Governments around the world have encouraged employees to work from home wherever possible. Key frontline workers are still required to continue their occupations, and millions have unfortunately lost their jobs, with tens of millions furloughed on government financial aid.
Some [reporters](https://www.bloomberg.com/news/articles/2020-02-02/coronavirus-forces-world-s-largest-work-from-home-experiment) are referring to this shift in working behavior as the greatest ever working-from-home experiment. With this paradigm shift of working behavior, organizations must consider the additional risks and [security concerns](https://www.swiftlane.com/best-access-control-systems/) to protect themselves from data breaches, fraud, ransomware, and exploitation.
Below are some of Atlantic.Net’s key recommendations to follow to help ensure that business data is protected when employees are [working from home](https://www.felixhomes.com/blog/tips-for-working-from-home).
## Protect User Devices
The biggest threat to data integrity with home working is seemingly obvious; when an employee works from home, business data is necessarily accessed, processed, and updated from that employee’s home. Businesses must prepare for the change in working environments to help protect company assets. People’s homes do not have [physical security controls](https://www.pelco.com/blog/physical-security-guide) found in the workplace such as building access cards and 24×7 security guards.
So what can be done to protect a user device?
- Employees should only use devices provided by the business, such as laptops, desktops, and cell phones. Bring-your-own-device (BYOD) practices should be discouraged. If an employee uses a personal device, protecting business information becomes a significant challenge.
- Employee laptops must be protected by automatic security updates, such as Windows Update and application updates.
- Employees must not be allowed to download or install any software without the administrator’s permission.
- Antivirus should be rolled out to all devices. Daily updates to Antivirus definitions must also be enforced and security controls should be put in place to prevent users from tampering with AV, such as uninstalling AV or stopping critical services.
- User devices must be secured using group policies that enforce automatic screen locks.
- Encrypt employee laptops; this ensures that if a device is stolen, the hard disk will be unreadable unless the user has the security key.
- If employees use WIFI in their home network, ensure that security controls are set to WPA2 or higher.
- Multi-Factor Authentication has become a must, as usernames and passwords are easily phished and stolen.
Atlantic.Net is uniquely positioned to help businesses tackle the distinct problems working from home can create. We currently provide an extensive number of Remote Desktop services that allow our clients to access our cloud platforms. This approach provides secure remote access to a centralized, easy-to-manage server or desktop.
This procedure helps greatly with regulated industries; for example, those impacted by [HIPAA](https://www.atlantic.net/hipaa-compliant-hosting/), HITECH, or SOC compliance requirements. Atlantic.Net’s data centers are already compliant with these standards, and home workers can connect to our secure infrastructure over a VPN. You, the customer, do not have to invest huge amounts in infrastructure to provide a service to your employees; simply leverage the servers we offer ready-to-go!
## Define a Strong Password Policy
Passwords are the first line of defense on a computer network; you might be surprised by how often [easy passwords](https://edition.cnn.com/2019/04/22/uk/most-common-passwords-scli-gbr-intl/index.html) are compromised by hackers. Businesses can protect against this by using technical measures that enforce password complexity.
- A strict password policy should be defined that enforces complex passwords.
- Password generators can be used, but as a rule of thumb, try to include at least 3 different words, a mixture of upper and lower case, and some special characters (*&^%%$£!”).
- Use different passwords for each of your accounts and note the password in a secured database application.
- Protect the secured database application with encryption keys and another strong password. Set the password to reset every few weeks. These user-friendly features are available when installing the password application.
- Consider saving your password database to secure cloud storage, such as OneDrive for Business Personal Vault for added security.
- Utilize Multi-Factor Authentication (MFA or 2FA) wherever possible to increase the security level of your user’s logins. MFA makes phishing and brute force attacks extremely hard for hackers.
All of Atlantic.Net’s infrastructure services provide best practice security for our clients, and our services not only are resilient, but also are built with security at the forefront of the design process. We offer compliant storage and databases that can be leveraged with guaranteed security hardening.
## Create a Work-from-Home Policy
Businesses need to work together with HR and technology teams to create an enforceable work-from-home policy. Businesses must always trust employees, and a work-from-home policy should only create boundaries of acceptable use of computer systems.
Businesses must ensure that they provide employees with the appropriate technology to work from home. This typically includes:
- Laptops
- Computer hardware
- VPN network access
- Access to email systems
- Collaboration tools (Skype / Teams / JIRA)
- Applications needed by the employee.
Businesses can then secure these assets to protect data integrity. Employees should find a dedicated workspace at home with minimal distractions, away from people that might read or overhear sensitive business conversations. Any business compliance regulations are still enforceable for home working, such as data protection laws or healthcare legislation. Ensure children or relatives do not use company assets.
If you’re looking for assistance with maintaining data security in a work-from-home environment, [contact Atlantic.Net](https://www.atlantic.net/about-us/corporate-contact/) for assistance with managed hosting services and IT support.
---
# How to Securely Transfer Files Using SCP
> URL: https://www.atlantic.net/vps-hosting/how-to-securely-transfer-files-using-scp/ | Published: 2020-06-30 | Updated: 2023-11-18 | Author: Hitesh Jethva
SCP stands for secure copy. It is a Linux command-line utility used to securely copy files and directories between servers. SCP uses the SSH protocol, so it requires a password or password less authentication between servers. With SCP, you can copy files between two remote hosts from your local system, as well as copy files between local and remote hosts.
In this tutorial, we will show you how to use the SCP command with examples.
## 1. SCP Syntax
The basic syntax of the SCP command is shown below:
```
scp [option] user@source-ip:/file_or_directory user@dest-ip:/directory
```
**user:** Name of the user.
**source-ip:** IP address of the system from where you want to copy files or directories.
**dest-ip:** IP address of the system destination system.
Some of the options used in scp command are listed below:
**-P:** Specify the ssh port number of the destination host.
**-r:** Used to copy files and directories recursively.
**-v:** Used to display verbose output during file transfer.
**-C:** Used to enable file compression.
**-i:** Specify the SSH key.
**-l:** Used to limit the bandwidth while copying.
**-p:** Used to preserve permissions, modes, and access time of files while copying.
## 2. Copying a File from Local to Remote Host
If you want to copy a file named /etc/rc.local from localhost to the remote host (172.20.10.3) in /mnt directory, run the following command:
```
scp /etc/rc.local root@172.20.10.3:/mnt/
```
You should see the following output:
```
root@172.20.10.3's password:
rc.local 100% 306 0.3KB/s 00:00
```
If you want to copy multiple files (in this example we will use */etc/fstab*and */etc/hosts,*and copy them to the remote host (172.20.10.3) into /mnt directory), run the following command:
```
scp /etc/fstab /etc/hosts root@172.20.10.3:/mnt/
```
You should see the following output:
```
root@172.20.10.3's password:
fstab 100% 628 0.6KB/s 00:00
hosts 100% 249 0.2KB/s 00:00
```
## 3. Copying Files and Directories Recursively
You can use the recursive option -r with SCP to copy the entire directory from one system to another.
For example, to copy the directory named */var/log/apache2* from localhost to the remote host (172.20.10.3) in /mnt directory recursively, run the following command:
```
scp -r /var/log/apache2 root@172.20.10.3:/mnt/
```
You should see the following output:
```
root@172.20.10.3's password:
error.log 100% 0 0.0KB/s 00:00
access.log.3.gz 100% 61KB 61.3KB/s 00:00
other_vhosts_access.log 100% 0 0.0KB/s 00:00
access.log.4.gz 100% 317 0.3KB/s 00:00
error.log.3.gz 100% 1622 1.6KB/s 00:00
error.log.1 100% 2352 2.3KB/s 00:00
access.log 100% 0 0.0KB/s 00:00
access.log.1 100% 1287 1.3KB/s 00:00
access.log.2.gz 100% 239 0.2KB/s 00:00
error.log.2.gz 100% 246 0.2KB/s 00:00
error.log.5.gz 100% 1471 1.4KB/s 00:00
error.log.4.gz 100% 2296 2.2KB/s 00:00
```
You can also use -v option with SCP to display verbose output during the copying process:
```
scp -vr /var/log/apache2 root@172.20.10.3:/mnt/
```
## 4. Copying File from Remote to Local Host
If you want to copy a file named /etc/hostname from the remote host (172.20.10.3) to the localhost in /opt directory, run the following command:
```
scp root@172.20.10.3:/etc/hostname /opt/
```
You should see the following output:
```
root@172.20.10.3's password:
hostname 100% 6 0.0KB/s 00:00
```
## 5. Copying File from one Remote Host to other Remote Host
To copy files and directories between two remote hosts, you will need to configure SSH key-based authentication between both remote hosts.
After configuring key-based authentication, copy a directory named /var/log from one remote host (172.20.10.3) to the other remote host (172.20.10.4) in /mnt directory, run the following command:
```
scp -r root@172.20.10.3:/var/log root@172.20.10.4:/mnt/
```
## 6. Limiting Bandwidth Usage While Copying
You can use -l option with SCP to limit the bandwidth during the copying process.
For example, to copy a file named google-chrome-stable_current_amd64.deb from localhost to the remote host (172.20.10.3) in /opt directory and limit the bandwidth to 1000 KB/sec (1000×8), run the following command:
```
scp -l 8000 /home/vyom/Downloads/google-chrome-stable_current_amd64.deb root@172.20.10.3:/opt/
```
You should see the following output:
```
root@172.20.10.3's password:
google-chrome-stable_current_amd64.deb 100% 60MB 1.0MB/s 01:01
```
## 7. Specify Specific Port with SCP
In some cases, the SSH port is different on the destination host. In this case, you can use -P option to specify the SSH port.
For example, to copy a file named /etc/hosts on the local system to the remote host (172.20.10.3) in /mnt directory using the port 8088, run the following command:
```
scp -P 8088 /etc/hosts root@172.20.10.3:/mnt/
```
## 8. Enabling Compression While Copying
You can use -C option with SCP to enable compression at source and decompression at the destination host. This can increase the transfer speed on large files.
For example, to copy a directory*/var/log/nginx*on the local host to the remote host (172.20.10.3) in /mnt directory with compression, run the following command:
```
scp -r -C /var/log/nginx root@172.20.10.3:/mnt/
```
You should see the following output:
```
root@172.20.10.3's password:
error.log 100% 0 0.0KB/s 00:00
access.log.3.gz 100% 217 0.2KB/s 00:00
error.log.1 100% 974 1.0KB/s 00:00
access.log 100% 0 0.0KB/s 00:00
access.log.1 100% 90 0.1KB/s 00:00
access.log.2.gz 100% 239 0.2KB/s 00:00
```
## 9. Preserve Permissions, Modes, and Access Time of Files While Copying
You can use -p option with SCP to preserve permissions, access time, and modes during the copying process.
For example, to copy a file named *magento-ce-2.3.5-p1-2020-04-24-08-59-28.tar.bz2* on the local host to the remote host (172.20.10.3) in /mnt directory and preserve permissions, access time, and modes, run the following command:
```
scp -p /home/vyom/Downloads/magento-ce-2.3.5-p1-2020-04-24-08-59-28.tar.bz2 root@172.20.10.3:/mnt/
```
You should see the following output:
```
root@172.20.10.3's password:
magento-ce-2.3.5-p1-2020-04-24-08-59-28.tar.bz2 100% 112MB 55.9MB/s 00:02
```
## Conclusion
In the above guide, you learned how to use SCP to securely transfer files and directories from one server to another. Get started with SCP on a [VPS Hosting](https://www.atlantic.net/vps-hosting/) account with Atlantic.Net today!
---
# How to Protect and Secure Website Infrastructure
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-protect-and-secure-website-infrastructure/ | Published: 2020-07-10 | Updated: 2024-09-11 | Author: Richard Bailey
There are four primary Web Server applications used to host websites: Apache HTTP Server, Microsoft IIS, Nginx, and LiteSpeed. While there are others, these four are by far the most popular.
You can deploy any of these web servers in the Atlantic.Net Cloud Platform. We have an extensive selection of detailed [step-by-step procedures](https://www.atlantic.net/blog/#gsc.tab=0&gsc.sort=)explaining how to deploy and secure these applications; [simply search the Atlantic.Net blog](https://www.atlantic.net/blog/#gsc.tab=0&gsc.sort=).
## Why Should You Secure Your Website?
There are an estimated [2 billion websites](https://hostingtribunal.com/blog/how-many-websites/#gref) on the World Wide Web, ranging from sites as simple as single homepages to huge, popular social media and sprawling eCommerce platforms. However, for any type of website, web security should be at the top of the priority list.
Web security is defined as “the protection of personal and organizational public-facing websites from cyberattacks.” There are various threats such as website vandalism, hacking backend services, and potentially stealing business data. Ransomware and malware attacks are another serious threat.
Victims of these kinds of cyberattacks often must spend a significant amount of money to resolve them and are likely to lose a lot of customer confidence, especially if data is compromised.
## Create a Secured Infrastructure
The keys to website security are to minimize the attack surface of the website infrastructure and place controls over how network traffic traverses the platform. A security-first architectural design is the only recommended way to protect web servers hosted on-premise or in the cloud.
If you decide not to go with [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/), VPS hosting is a very popular platform choice when designing websites, but it is important to check that your cloud provider has already done the hard work of creating a security-defined infrastructure as part of the VPS service.
Most web designers are happy to let someone else manage the infrastructure so they can focus on creating excellent web content, [designing a logo](https://www.brandcrowd.com/logo-maker), etc.
There are many distinct layers to web server infrastructure, typically comprised of the front end, the mid-tier, and the backend. Multi-tier web applications are arguably the most common configuration, wherein the infrastructure is usually protected by a load-balancer with enhanced security configuration and a network firewall at the network edge perimeter.
Only the front end web server(s) are externally-facing to the public internet within a DMZ, with the application and database servers logically positioned behind additional firewalls inside the core network.
The frontend should be protected by proxying TLS traffic through a secured web gateway, preferably virtual appliances such as a software-defined HAProxy; a cloud secured service, such as a [Web Application Firewall (WAF)](https://www.atlantic.net/vps-hosting/waf-web-application-firewall/#gsc.tab=0), will also work well.
## Network Edge Protection Services
Edge Services such as [DDoS](https://www.comptia.org/content/guides/what-is-a-ddos-attack-how-it-works) protection, Web Application Firewalls, Website Optimization, and Content Delivery Networks are cloud services that afford consumers great flexibility and added security. Downtime on revenue-generating websites must be avoided at all costs; if Walmart.com suffered downtime of only a few minutes, this would result in [several million dollars](https://www.gremlin.com/ecommerce-cost-of-downtime/)of lost revenue.
DDoS, or distributed denial of service, is an attack launched by hackers to overload a web server with fake requests with the intention of bringing the system down or blocking legitimate traffic. The end result is that legitimate users will encounter a slow or offline website.
Content Delivery Networks (CDN) reduce the attack surface of your website. User requests for content on your site are cached at the network edge CDN, the result is that your web server has to serve less web content, because the CDN delivers many of the duplicate requests.
Atlantic.Net provides our own CDN using servers positioned across key global points. As information travels across the web, our Content Delivery Network caches data and routes traffic according to server proximity, enabling users to reach your content quickly, regardless of their location. The system is easy to set up and offers affordable and predictable pricing.
## Secure Web Gateway (SWG)
A secure web gateway (SWG) is essentially the doorkeeper to your web server infrastructure. If you operate an on-premise infrastructure, an SWG is a great way to provide layer 7 termination and in-depth inspection of http/https web traffic to protect against web threats that target businesses.
The main difference between an SWG and a network firewall is that the SWG receives the complete request from the client before making a decision on where to send the traffic. This decision is made using predefined security policies and intelligent session termination, whereas a firewall makes decisions on a packet-by-packet basis, with no session termination.
It is highly recommended to create strict security policies to manage end-to-end traffic inside the perimeter network. Configure the secured gateway to disable and reject deprecated security cipher suites such as SSLv3, RC4, TLS1, TLS1.1, DES, 3DES, and so on.
Such legacy ciphers have been discontinued because there are a huge number of vulnerabilities and exploits embedded in them. Instead, enable a modern cipher suite such as AES or RSA.
## Scan for vulnerabilities
Website app servers are susceptible to hacks, exploits, and vulnerabilities. Because malware is a serious risk to websites, the ability to detect and remove malware is essential. Regular file scans and detailed reporting generate a holistic overview of the state of the network.
The software that runs websites is constantly evolving and being upgraded to prevent vulnerabilities. Scanning for vulnerabilities, sometimes known as penetration testing or pen testing, is a technique of testing external and internal computer infrastructure against all known vulnerabilities.
Vulnerability scans look for known vulnerabilities in your systems and report potential exposures. Penetration tests are intended to exploit weaknesses in the architecture of your IT network and determine the degree to which a malicious attacker can gain unauthorized access to your assets.
Atlantic.Net offers vulnerability scans as part of our [managed services offering](https://www.atlantic.net/managed-services/server-management/). We can provide biweekly vulnerability scans and penetration testing for host servers or configured websites, as well as assist with evaluating and interpreting scan results while working with our customers to patch vulnerabilities.
Additionally, social engineering can be conducted to test employee’s [susceptibility to ransomware](https://www.atlantic.net/vps-hosting/how-to-prepare-for-ransomware-malware-network-and-file-vulnerabilities/), phishing, or whaling attacks; these tasks are usually completed by an internal security team or outsourced to a managed service provider.
## Other best practices to consider
So far, we have mainly referenced hierarchical design decisions for implementing security on your website. There is, of course, much that system administrators can do to increase security awareness.
Network engineers are needed to monitor and update rules for Web Application Firewalls (WAF) and Secure Gateways (SWG). The network layer can prevent [SQL injections, cross-site scripting, vulnerability probing](https://www.tripwire.com/state-of-security/featured/web-hosting-security-best-practices/), etc.
Atlantic.Net offers a robust Web Application Firewall as part of our Network Edge protection. The WAF examines web traffic looking for suspicious activity; it then automatically filters out illegitimate traffic based on rulesets that Atlantic.Net applies for you or custom rulesets applied at your request.
The WAF looks at both GET and POST-based HTTP requests and applies a rule set, such as the ModSecurity core rule set covering the OWASP Top 10 vulnerabilities to determine what traffic to block, challenge or let pass.
The operating system is the next entity to be secured. Regardless of whether they are Windows or Linux based, operating systems must be regularly updated, preferably monthly. Default usernames and passwords should be changed, and consider disabling root or administrator accounts in addition to limiting the number of privileged user accounts. In other words, *do not make everyone a domain admin!*
The type of website application you host can also affect your security. In all cases, the latest versions of website code should be used; for example, expired and unsupported versions of Java are still surprisingly common. Middleware such as Apache Tomcat, IBM WebSphere, and IIS should be updated regularly and patched for known security issues.
Backups are also important, as even the most reliable servers are susceptible to failure, and in the event of a problem, a backup to restore the website is essential. Atlantic.Net offers [one-click backups](https://www.atlantic.net/cloud-platform/backups/) as part of our cloud service, and if you operate a large, revenue-generating website, you should consider [offsite backups](https://www.atlantic.net/resources/documents/brochures/pdf/acp-cloud-backups-atlantic-net-brochure.pdf).
Share your vision with us, and we will develop a hosting environment tailored to your needs!
Contact an advisor at 866-618-DATA (3282) or fill out the form at the link below.
---
# How to Enable User Quotas in cPanel/WHM
> URL: https://www.atlantic.net/hipaa-compliant-hosting/how-to-enable-user-quotas-cpanel-whm/ | Published: 2020-07-12 | Updated: 2026-02-28 | Author: Alexander Wise
This tutorial will explain how to enable user quotas on Atlantic.Net’s cPanel Cloud Servers. Before we get into the details, let’s do some housekeeping:
*Verified on 7/12/20 for cPanel on CentOS 7.2 64-bit*
## Prerequisites
- **Atlantic.Net Cloud Account**
[Click here to sign up for your free account!](https://cloud.atlantic.net/?page=signup)
- **SSH Program**
*Don’t have one? Follow the guides below for how to SSH:*
[From Windows](https://www.atlantic.net/vps-hosting/how-to-ssh-server-via-linux/)
[From Linux/Mac](https://www.atlantic.net/vps-hosting/how-to-ssh-linux-server-windows/)
- **Atlantic.Net cPanel Server**
*Follow this simple guide for how to quickly create a cPanel server:*
---
## Connecting to Your cPanel Server
Now it’s time to connect to your server via SSH:
```
ssh root@[IP Address]
```
## Check If Your System Has Quotas Enabled
```
mount
```
Find the line that says
```
/dev/sda1
```
and if there is no quota enabled, it will say
```
noquota...
/dev/sda1 on / type xfs (rw,relatime,attr2,inode64,noquota)
...
```
## Edit the default Grub file
By editing the default Grub file, we can specify that the file system should have quotas enabled when the system boots up.
Edit the default Grub file with your favorite editor:
```
nano /etc/default/grub
```
Modify the following line from:
```
GRUB_CMDLINE_LINUX=””
```
to:
```
GRUB_CMDLINE_LINUX="rd.lvm.lv=centos/root crashkernel=auto rhgb quiet rootflags=uquota,pquota"
```
*Note: By default, our cPanel Cloud Servers do not have **swap** enabled. If you have enabled it, you can prepend **rd.lvm.lv=centos/swap** before **rd.lvm.lv=centos/root**.*
The resulting file should look like this:
```
GRUB_TIMEOUT=5
GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)"
GRUB_DEFAULT=saved
GRUB_DISABLE_SUBMENU=true
GRUB_TERMINAL_OUTPUT="console"
GRUB_CMDLINE_LINUX="rd.lvm.lv=centos/root crashkernel=auto rhgb quiet rootflags=uquota,pquota"
GRUB_DISABLE_RECOVERY="true"
```
## Generate the New Grub Configuration File
Now that we have edited the default Grub file, we must use it to generate the Grub bootloader configuration file. First, let’s make a backup of our Grub configuration:
```
cp /boot/grub2/grub.cfg /boot/grub2/grub.cfg.bak
grub2-mkconfig -o /boot/grub2/grub.cfg
```
If done correctly, the system will let you know you generated the file successfully.
```
Generating grub configuration file ...
Found linux image: /boot/vmlinuz-3.10.0-327.10.1.el7.x86_64
Found initrd image: /boot/initramfs-3.10.0-327.10.1.el7.x86_64.img
Found linux image: /boot/vmlinuz-0-rescue-17115f95ddd92d410be8cb803e2d845d
Found initrd image: /boot/initramfs-0-rescue-17115f95ddd92d410be8cb803e2d845d.img
done
```
## Finishing Up
In order for the new changes to take effect, let’s reboot the system:
```
reboot
```
Allow a minute or two for the cPanel server to reboot. Once it has rebooted, SSH back into the server.
```
ssh root@[IP Address]
```
Let’s check **mount** again to see if **quota** shows up now:
```
mount
...
/dev/sda1 on / type xfs (rw,relatime,attr2,inode64,usrquota,prjquota)
...
```
As we can now see, user quotas and project quotas are now enabled. You have successfully completed enabling quotas on your Atlantic.Net cPanel Cloud Server!
Your next step is to log in to your cPanel’s WHM to setup quotas: https://[your IP address]:2087. There should no longer be any notification about enabling quotas.
*Note: If cPanel is telling you quotas are still not enabled for the filesystem, please run the following command in an SSH terminal:*
```
/scripts/fixquotas
```
---
Questions? Comments? Concerns? Let us know in the comments below or email us at cloudsupport@atlantic.net! Interested in a HIPAA-compliant hosting solution in the cloud? Atlantic.Net offers [HIPAA compliant cloud hosting](https://www.atlantic.net/hipaa-compliant-hosting/) services for healthcare organizations.
---
# What Is an Intrusion Detection System and Why Do I Need It?
> URL: https://www.atlantic.net/dedicated-server-hosting/what-is-an-intrusion-detection-system-and-why-do-i-need-it/ | Published: 2020-07-14 | Updated: 2025-10-21 | Author: Richard Bailey
A proven and reliable cybersecurity strategy is a major driving force behind business decision-making within the modern global organization. Having the ability to protect and secure information technology services enables tech-savvy organizations to prove that they can control and secure the network. Securing business assets is essential to help prevent information exposure or data breaches of confidential business data.
## Monitoring and Preventing Unwanted Traffic That Poses Threats to Your Organization
Most industry professionals already know how to protect their infrastructure with network firewalls and a securely architected networking design. A more recent technology, known as an [intrusion detection system](https://www.atlantic.net/managed-services/firewall/), is a software image or hardware-based appliance for the security-conscious organization. It monitors the entire network and [hosting environment](https://www.atlantic.net/dedicated-server-hosting/) by analyzing traffic and network activity throughout a corporate network. An IDS application is sometimes referred to as a security information event management ([SIEM](https://www.esecurityplanet.com/products/siem-tools/)) system.
A typical setup includes IDS appliances at various layers of the network, usually at choke points on the perimeter network. Each network packet is monitored and ranked according to a risk policy based upon information concatenated from a vast number of global threat prevention databases. The global database is used to compare networking data packets with known exploits or vulnerability hashes. This approach enables businesses to be on the forefront of the latest global threat trends and risks within the cybersecurity industry.
An IDS solution is designed to monitor and alert against scenarios such as an application or operating system exploit, buffer overflow attacks, unauthorized port scanning, cross-site scripting exploits, and many other vulnerabilities.
## How does an Intrusion Detection System (IDS) work?
The first time an IDS is configured and deployed within a networking environment, the IDS will securely scan the network and create a baseline of the current usage scenario of the compute, storage and networking configuration. Over time, the IDS will analyze all network traffic and start to compare changes against the baseline configuration. This enables the IDS to generate an anomaly-based identification intelligence that can work out what traffic is considered a threat.
TCP/IP network packets are multiple data objects that traverse the network at a single time. Each packet contains information such as a source and destination IP address, the data itself, information regarding QoS, and how the packet should be handled. All this information is encapsulated within the packet prior to being transported over the network.
The IDS screens each packet, which can help detect intrusions. This is done by comparing intercepted local data packets with information known about previous attacks via the global threat databases. This intelligence can be configured to trigger alerts and automatically raise incident reports which will allow a dedicated security team to identify and respond to suspicious traffic before any damage is done to the infrastructure.
The IDS will look for a signature-based flow of traffic that perfectly matches the previously known attack signatures over the network, and it will result in an ALLOW or DENY to the network request.
This intelligence is vital to help provide an organization with the opportunity to identify threats and risks. It can help with attack prevention, preparation, and response times by identifying behavior-based network changes. An IDS can also help with infrastructure visibility which enable engineers to manage a network more efficiently by monitoring and blocking unexpected network traffic, such as network traffic over higher port ranges or file transfers at unexpected times of day or night.
## The Atlantic.Net Comprehensive Intrusion Detection System (IDS)
To protect our valued clients at both a networking and hosting level, Atlantic.Net provides a dual IDS solution that implements a NIDS (Network Intrusion Detection System) and HIDS (Host Intrusion Detection System) solution.
The IDS is placed at strategic points within a network and works with your firewall by inspecting packets that the firewall has already accepted as legitimate. Another IDS resides directly on the network, protecting against local vulnerabilities on the network layer.
The first part of our IDS solution is a custom-build NIDS platform created by our experts using industry-leading, open-source technology. As it is based on open-source technology, the Atlantic.Net proprietary NIDS appliance can utilize a community consensus rule database and then customize it to fit the specific needs of the computing environment it protects.
Secondly, Atlantic.Net provides the host-based Trend Micro Deep Security HIDS to protect critical infrastructure against network vulnerabilities from the server-side, whether those servers are [dedicated](https://www.atlantic.net/dedicated-server-hosting/), virtual, or cloud. Trend Micro Deep Security includes protection against malware, including ransomware, targeted attacks, and advanced threats such as logging privileged user account access.
Both technologies are managed within a unified dashboard interface, allowing Atlantic.Net the ability to review the incident logs that are generated and automatically alert when a threat is identified or suspected. These detailed information logs can be extensive and can add up significantly within a short space of time, so the ability to rank and classify each identified incident is a priceless feature when attempting to get an accurate overview of what is happening on the networking estate.
With this, we offer excellent reporting facilities built into the IDS solution; the reports can be as granular or as high-level as required. Users can choose to receive weekly or monthly reports summarizing the current infrastructure vulnerabilities. These reports provide invaluable insight and are a perfect match for clients in regulated industries. The reports are offered in addition to any critical alerts which the Atlantic.Net IDS discovers.
To keep your network safe from attackers, Atlantic.Net uses Cisco-developed packet analyzer software that scans your network traffic for malicious activity. As an open-source network intrusion detection system, this software can perform real-time traffic analysis, packet logging on IP networks, protocol analysis, and content searching/matching, and can also be used to detect a variety of attacks.
## Next Steps
When you choose to work with Atlantic.Net, you can rest assured that your system will be protected with state-of-the-art IDS software. Our team can install and configure the software on your behalf and monitor your network for operating system fingerprinting attempts, common gateway interface, buffer overflows, server message block probes, and stealth port scans. You will not have to be concerned about updates and reporting. While business is free to innovate, Atlantic.Net will ensure your systems are running safely and smoothly. [Get started with an IDS](https://www.atlantic.net/managed-services/firewall/) from Atlantic.Net today.
---
#### Read More About Intrusion Detection
- [Intrusion Detection Service](https://www.atlantic.net/managed-services/firewall/) from Atlantic.Net
- [Intrusion Detection Systems](https://www.atlantic.net/hipaa-compliant-hosting/intrusion-detection-systems/) from Atlantic.Net
- [Penetration Testing Best Practices](https://www.atlantic.net/vps-hosting/best-penetration-testing-practices-you-need-to-know/)
---
---
# COVID-19: Will the OCR Exercise Enforcement Discretion and Waive Penalties for HIPAA Violations?
> URL: https://www.atlantic.net/hipaa-compliant-hosting/covid-19-will-the-ocr-exercise-enforcement-discretion-and-waive-penalties-for-hipaa-violations/ | Published: 2020-07-14 | Updated: 2024-10-22 | Author: Richard Bailey
The global pandemic Covid-19 ([SARS-CoV-2](https://www.who.int/emergencies/diseases/novel-coronavirus-2019/technical-guidance/naming-the-coronavirus-disease-(covid-2019)-and-the-virus-that-causes-it#:~:text=ICTV%20announced%20%E2%80%9Csevere%20acute,on%2011%20February%202020.)) has wreaked havoc around the world for the first half of 2020. The virus’s huge impact on the US Healthcare industry has overloaded physicians, doctors, and other hospital staff who have been caring for the sick or helping keep the hospital lights on 24×7. Non-frontline healthcare workers have been forced to work from home, small clinics have closed, and non-critical patient operations have been canceled.
## Impact of the Pandemic on the Healthcare Industry and HIPAA Regulation Enforcement
At the peak of the pandemic, [US hospital emergency room visits were down 42%,](https://www.cidrap.umn.edu/news-perspective/2020/06/emergency-visits-down-42-us-hospitals-reeling-covid-19) accompanied by a seismic shift toward visiting patients at home and conducting telephone or video conferencing appointments and consultation. On the 17th March 2020, the Office for Civil Rights (OCR) announced that [enforcement discretion and waiving penalties for HIPAA violations](https://www.hhs.gov/about/news/2020/03/17/ocr-announces-notification-of-enforcement-discretion-for-telehealth-remote-communications-during-the-covid-19.html) would be introduced.
However, it has become evident that this headline-grabbing announcement may have been misinterpreted by some HIPAA covered entities. Atlantic.Net is one of the largest and most successful providers of HIPAA compliant hosting solutions for the US healthcare industry. We have been extremely alarmed by reports that some covered entities have interpreted this news thinking that they do not need to meet HIPAA guidelines during this period of uncertainty.
**This interpretation is absolutely not true.** The OCR is *only waiving specific HIPAA enforcement rules to allow greater flexibility when providing healthcare services directly to patients* during these uncertain times. The OCR is not relaxing HIPAA regulation, and covered entities must at all times uphold the integrity of protected health information.
## CMS Blanket Waivers
Some of the confusion may have arisen because a number of blanket waivers were introduced by the CMS. The CMS (Center for Medicare and Medicaid Services) [has relaxed a number of rules](https://www.cms.gov/Medicare/Provider-Enrollment-and-Certification/SurveyCertEmergPrep/1135-Waivers) (mostly relating to patient interactions) during the pandemic.
Any healthcare facility that has declared an emergency due to Covid-19 is in the scope of the waivers. For example, doctors no longer have to seek patient approval to notify immediate family if they are affected by Covid-19. Also, patient health records can be shared with the CMS if patients are being seen at home or offsite (not at a hospital). It is possible that these CMS waivers created some confusion about the scope of the rule relaxation.
## The OCR Enforcement Waivers
The OCR waivers only relate to the teleconferencing technical safeguards of HIPAA compliance. Video conferencing services have proven invaluable during the pandemic, enabling clinics to continue operating and follow safe distancing guidelines. The technology has also helped to bring families closer together during the lockdown.
But, importantly, it has enabled GPs and medical teams to continue to offer front line services direct to patients. The discretion offered by the OCR relates directly to video conferencing technology – nothing more, nothing less!
## About Video Conferencing and HIPAA
Video conferencing is an approved technology that is allowed when using HIPAA-compliant service; however, there are usually strict rules about the technology, patient consent, and the need for a Business Associate Agreement (BAA) to meet the security restrictions needed. Prior to Covid-19, such a video conferencing tool would commonly have been non-public facing remote communication device that patients could consume, often using bespoke software solutions.
Since Covid-19, the rules have been relaxed significantly. [According to the HHS](https://www.hhs.gov/hipaa/for-professionals/special-topics/emergency-preparedness/notification-enforcement-discretion-telehealth/index.html): “Under this Notice, covered health care providers may use popular applications that allow for video chats, including Lets Talk, Apple FaceTime, Facebook Messenger video chat, Google Hangouts video, Zoom, or Skype, to provide telehealth without the risk that OCR might seek to impose a penalty for non-compliance with the HIPAA Rules related to the good faith provision of telehealth during the COVID-19 nationwide public health emergency.”
## What Types of Video Conferencing Are Covered by HIPAA?
Some banned video services such as Facebook, Twitch, Snapchat, and TikTok are simply not allowed under HIPAA. A number of video conferencing organizations have created HIPAA-compliant products that are approved by the HHS and OCR. However, the business associate agreements (BAA) offered by them have not been individually reviewed by the HHS; therefore, it is recommended that healthcare organizations conduct thorough due diligence to ensure that the product is suitable.
The type of video conferencing in-scope is usually the specific healthcare version, not the general public releases. The toolsets that have been whitelisted include Updox, VSee, Zoom for Healthcare, Doxy.me, Google G Suite Hangouts Meet, Cisco Webex Meetings / Webex Teams, GoToMeeting, and Spruce Health Care Messenger.
These platforms offer a number of technical safeguards that protect the integrity of PHI, including HIPAA-compliant levels of encryption that shield the audio and video stream, detailed logging of connection and session activity, and enforcement of user authentication with unique IDs and passwords. Conference rooms are protected with meeting access codes that are not publicly listed, and the presenter can specifically share applications needed which can prevent accidental exposure of PHI.
## Conclusion
To conclude, it is important to stress that the OCR has only relaxed some of the rules regarding video conferencing services implemented by HIPAA covered entities. This change in rules might be considered a sensible update to the rules as technology evolves. Video conferencing technology is everywhere, and relaxing these rules will greatly improve the patient experience.
All other physical, administrative, and technical safeguards required for HIPAA compliance are still enforceable by the OCR. One might argue that covered entities should be even more vigilant in these uncertain times as cyber-attacks have risen exponentially during the pandemic. Even the World Health Organization (WHO) has experienced a fivefold increase in cyber attacks.
## HIPAA Compliant Hosting
Are you in need of an infrastructure that can protect the health data of your organization? At Atlantic.Net, whatever your technical requirements, we can offer a top-grade [HIPAA-Compliant Hosting](https://www.atlantic.net/hipaa-compliant-hosting/) solution.
Learn more about our [HIPAA compliant web hosting](https://www.atlantic.net/hipaa-compliant-hosting/) and [HIPAA cloud hosting](https://www.atlantic.net/hipaa-compliant-hosting/) solutions.
---
# Overview of Redundant Systems
> URL: https://www.atlantic.net/dedicated-server-hosting/overview-of-redundant-systems/ | Published: 2020-07-26 | Updated: 2025-09-19 | Author: Richard Bailey
The purpose of this article is to explain redundancy in terms of computing, networking, and hosting. We will provide real-world examples of redundant technology solutions to illustrate what redundancy is and how it works.
Atlantic.Net has created multiple hosting environments, including a [durable cloud platform](https://cloud.atlantic.net/?page=signup), high-speed [VPS hosting](https://www.atlantic.net/vps-hosting/), [HIPAA compliant infrastructure](https://cloud.atlantic.net/?page=signup&s=hp), and [managed private cloud hosting](https://www.atlantic.net/dedicated-server-hosting/managed-private-cloud/). All of our systems are built with redundancy as a primary driving factor of the design process.
In everyday English, redundancy may have a negative connotation; something redundant is usually not needed or considered superfluous. However, in a [cloud hosting environment](https://cloud.atlantic.net/?page=signup), redundancy can mean the difference between seamless system availability and unwanted or unexpected downtime.
## What Is a Redundant System?
A redundant system will provide [failover](https://www.atlantic.net/hipaa-data-centers/increasing-uptime-of-your-web-assets-by-instituting-failover-services/) or [load balancing](https://www.atlantic.net/managed-services/load-balancing/) support to protect a live system in the event of an unexpected failure. In the case of [power, mechanical, or software failure](https://www.atlantic.net/blog/), a redundant system will have a duplicate component or platform to fall back to. In general, any component of a system with a single point of failure can be seen as a risk to production services.
Power or mechanical systems have simpler fall back strategies requiring the mere presence of another of the same type of service; software failovers usually require extra configuration on the host system or a master or gateway.
Redundancy capabilities are recommended for any business-critical system, but particularly for systems that have a significant impact during downtime. Some businesses may keep all of their critical customer information in a database; therefore, for business continuity purposes, protecting that database with redundancy will protect the data integrity in the event of a catastrophic failure.
## Types of Redundant Systems
A redundant system consists of at least two systems that are interconnected and designed for the same purpose. There are many different types of redundant system configurations available, and different implementations of the system provide unique approaches to how to keep a system up at all times.
Not all servers need to be configured with redundancy; rather, only the most critical should be considered. We highly recommended detailed risk assessment to understand what servers are in scope and the maximum amount of downtime your servers can handle. Use this assessment to determine an RTO (Recovery Time Objective) and RPO (Recovery Point Objective) strategy. RTO is the maximum amount of acceptable downtime. This can range from 5 seconds to 24 hours. The RPO is the point in time from which you require your data; for example, your business can function with a maximum loss of 24 hours worth of data.
Here are a few popular examples[2]:
- **Active-Inactive/Hot-Cold –** When one component of a system is the active system and another is inactive or shut down. The inactive component is activated only when the currently running component fails or undergoes maintenance
- **Active-Active/Hot-Hot**– When both systems are live and making connections. This is most commonly known as clustering. Usually, the device in front of both machines will determine how to split incoming traffic
- **Active-Standby/Hot-Warm** – When both systems are on, but only one is making connections. The second system is meant to periodically receive updates or backups from the primary system. In the event of a failure, the system on standby takes the primary role until the initial system can be recovered.
Each type has its own pros and cons.
- **Active-Inactive/Hot-Cold** systems can provide a simple redundant platform, but any failover will result in users seeing an older version of the system.
- **Active-Active/Hot-Hot**will require a constant update of both systems, either manually or through a separate service, to ensure that all users can use either system. This approach can heavily reduce the active load on a service you’re providing to customers.
- **Active-Standby/Hot-Warm** will provide the failover capabilities of hot-cold with a more up-to-date copy of your active system on the failover, but it does not provide any load easing.
Other forms of multiple node redundancy are available that allow for greater redundancy and robust load balancing solutions. At that point, you’ll have a high-availability cluster, also known as an HA cluster.
This can use any combination of the previously noted redundancy solutions with maximum flexibility in the approach or amount of redundancy needed. HA clusters can also be set up across multiple physical locations to allow for availability up to the internet backbone level.[3]
## Examples of Redundant Software Services
Short of low resource availability, there is very little reason to not have proprietary replication or redundant services set up in a virtual environment; thus, many such services are available by default in most virtualization systems. All of our cloud services have replication available, a feature that allows us to replicate any server from one node to another, whether they are in the same data center or separate data center regions.
### Hyper-V Replica
[Hyper-V Replica is a form of hot-warm redundancy](https://www.atlantic.net/dedicated-server-hosting/managed-private-cloud/). A primary virtual machine is created on one physical host and accepts incoming connections. When enabling replication, the virtual hard disks of the new machine are transferred to a separate physical Hyper-V host. This host then configures a VM on itself that replicates on a user-defined schedule to ensure that the most recent image of the active server is taken. Additional checkpoints points can be kept as well.[4] [Hyper-V private hosting with managed services](https://www.atlantic.net/dedicated-server-hosting/) is provided by Atlantic.Net with this feature baked in; [contact our team](https://www.atlantic.net/vps-hosting/what-is-private-cloud-hosting/) for further information.
### Hyper-V Clustering
[Hyper-V is also capable of clustering](https://www.atlantic.net/dedicated-server-hosting/managed-private-cloud/) through a connection to other Hyper-V hosts. VMs on any Hyper-V host can be clustered together on that singular host to provide redundancy on a local level through virtual networking.
Microsoft Network Load Balancing (NLB) can be used to create a single resource made up of multiple hosts that share the same information to provide a simple point of access for file sharing. Since this is only capped by the amount of resources you have available, you can theoretically set up multiple hosts with multiple VMs for maximum redundancy, which would also allow you to perform maintenance on individual VMs without sacrificing service or resource availability.[5] [Hyper-V private hosting with managed services](https://www.atlantic.net/dedicated-server-hosting/) is provided by Atlantic.Net with this feature baked in; [contact our team](https://www.atlantic.net/vps-hosting/what-is-private-cloud-hosting/) for further information.
### HAProxy
Aside from Hyper-V, a gateway device such as a firewall can be used for failover or load balancing services. For example, Atlantic.Net can provide pfSense with High Availability Proxy, also known as HAProxy.
HAProxy will act as a load balancer, a proxy, or a simple hot-warm high availability solution for TCP and HTTP-based applications.[6] HAProxy is a very popular, Linux-based open-source solution used by some of the most visited sites in the world.[7]
### Heartbeat
Heartbeat is a service available on most distributions of Linux that is used to determine whether nodes in a cluster are still up or responsive. It’s very simple to set up and provides failover capabilities to any system working over TCP.
The developers of Heartbeat also recommend other cluster resource managers which start or stop services based on whether a particular host is down. Heartbeat has this included, but other managers are available. Due to Heartbeat’s simplicity, it is highly customizable.[8] Cloud Hosting platforms provided by Atlantic.Net already have this feature baked in, and we can assist you with implementing Heartbeat on your own private Linux distribution, if needed.
## Examples of Redundant Hardware Services
The best part about redundant hardware is its simplicity. While software services may require excessive configuration and are possibly quite sensitive, the hardware is *usually*very simple to set up and incredibly durable. The first example we will look at is the widely used RAID technology.
### RAID
RAID stands for **R**edundant **A**rray of **I**ndependent **D**isks (or **R**edundant **A**rray of **I**nexpensive **D**isks depending on how long you’ve been using it) and has multiple levels used either for data protection or increased disk I/O.
RAID can either be set up via a software or hardware controller. The controller has the software and configuration necessary to manage the RAID disks. The configuration can be exported to different systems with little to no additional configuration.
RAID can be set up in a few different ways to provide a good balance of both of its qualities:
- **RAID 0** – This is essentially no redundancy. No disks on the system share data through mirroring, but all data is striped across each disk providing increased read/write speed. Each drive can still use the storage provided to it at its fullest, meaning the more drives you add to a RAID 0 the more space you’ll have.
- **RAID 1** – A basic form of mirroring providing excellent redundancy at the cost of space. In a two-drive system, a complete copy of the data on one drive is written to the other. This redundancy is enhanced with each drive added. Since all data must be mirrored across all drives, total space on the system will be limited to just the space of the smallest drive in the system.
- **RAID 5** – This form of RAID is usually used to increase read speed and reliability. In this case, stripes are placed about each drive in the system, with the minimum being 3 drives. At the same time, an extra block of error-correcting data is placed about each drive in a technique called parity. This checks whether data is changed when transferring from one drive to another.[10] This also provides a minimal form of redundancy since 1 of these drives can fail and the system can still run. The more drives added to this type of RAID setup, the more your read speed increases. With minimum redundancy and striping across all drives, the total amount of space in this setup is equal to the size of your logical RAID volume times the number of drives you use, minus one. For example, if you have 5 500 GB drives in a RAID 5, you would have 2000 GB usable, or 2 TB (500 *(5-1)=2000).
- **RAID 10** – This is a combination of RAID 1 and RAID 0. In this case, all data is striped across each device with blocks of data also being mirrored across the entirety of the striped system. For example, in a 4 drive RAID 10 system 2 500 GB drives may have the same data, but not all the data needed for the system to work properly. 2 other drives’ data would be required. Think of each RAID 1 system as a single drive, and each of those systems placed into a RAID 0 array. In this setup, performance can be drastically increased as in RAID 0, with some redundancy still in place with the mirroring. Up to half of the drives in the system can fail before the system crashes, but as with any redundant array, it’s best to replace drives as soon as possible. [Atlantic.Net uses RAID 10 for all SSD Cloud VPS Storage](https://cloud.atlantic.net/?page=signup).
For added protection, the RAID controllers are protected by battery backup units that power the ROM chips used to save the configuration in memory in case of power loss, etc. A BBU will provide power to a RAID array that’s part of a powered down system for a small amount of time, allowing the content of a RAID controller’s cache to stay intact. This can be a lifesaver if the information is constantly being fed into your [RAID array](https://www.atlantic.net/hipaa-data-centers/raid-10/) and any downtime could cause data corruption.[11]
So, your physical system and the services within can be constructed redundantly rather adequately. But what about your connection to any part of your system? As in, your direct internet connection to your system as a whole?
## Networking Redundancy
### First Hop Redundancy Protocols (FHRP)
In contrast to dynamic gateway discovery protocols, static gateways allow for straightforward hops between the client and their appropriate gateway, but this creates a single point of failure – namely the gateway itself.
To prevent or reduce the impact of gateway failure, FHRPs were created. They provide redundant gateways a fallback, or offer load-balancing for high traffic systems, along with redundancy. These protocols include VRRP, HSRP, and GLBP.[12]
#### **Virtual Router Redundancy Protocol (VRRP)**
VRRP is a form of redundancy used for routers that requires at least two physically separate routers connected via either Ethernet or optical fiber connections. In this situation, a ‘virtual router’ containing static routes is created and shared between each system.
One system is considered the ‘master’ and another the ‘backup’. When the master fails, the backup takes over as the next master. This can be set up with multiple backups for extra redundancy. The concept is very similar to Heartbeat in that the backup systems will check to see if the master is available. Once it does not receive a response, after a predetermined amount of time the backup will assume control of the virtual switch and accept connections for all requests coming in for the default IP configured for the master switch.[13][14]
#### **Hot Standby Router Protocol (HSRP)**
HSRP is like VRRP; however, in this scenario, the configured virtual switch isn’t a ‘switch’, but rather a logical group of multiple routers. The IP of the group is an IP not assigned to a physical host. Instead, the group is assigned an IP and one of the routers is determined to be the ‘active’ router.
A standby router is ready to take any connections should the active router go down. All routers besides the active and standby are all listening to determine its place in line. HSRP is a Cisco proprietary protocol and has very few, minor differences to VRRP such as their default timers determining when to failover. HSRP has been around a bit longer and is more well-known compared to VRRP.[12]
#### **Gateway Load Balancing Protocol (GLBP)**
GLBP’s main advantage over HSRP and VRRP is its ability to load balance on top of providing redundancy to a gateway with little to no extra configuration. Much like HSRP and VRRP, GLBP will create a group between physical routers and determine an Active Virtual Gateway, or AVG.
A virtual IP not currently used by any of the routers in the group is assigned to the AVG. The AVG then distributes virtual MAC addresses among the rest of the routers in the group. Each backup router is now considered an Active Virtual Forwarder, or AVF.
ARP requests sent to the AVG will provide a different virtual MAC address to the client sending the request. At that point, traffic from that client to the virtual IP of the group forwards to the router whose virtual MAC address they received, allowing each router to still be used instead of sitting idly by.
In the event of a failure of the AVG, priority-based election takes place, just like in HSRP and VRRP, and the next backup takes its place, distributing virtual MAC addresses as normal. The other routers still retain the virtual MAC address provided by the original AVG and things continue as normal. In the event of a failure of one of the AVFs, the AVG will prevent routing traffic to its virtual MAC address.
Just like HSRP, GLBP is a Cisco proprietary form of FHRP.
## Data Center Redundancy
In addition to redundancy measures for your personal servers or routers, data centers are designed to be resilient to system failure. Data centers fall under *tiers*defined by the Uptime Institute to provide fault tolerance for failure of any mechanical or service failure, allowing for as much uptime as possible.
There are four tiers, each building upon one another to provide high availability to all clients within a data center:
- **Tier I** ***– Basic Capacity***: This requires space for an IT group for data center operations, an uninterruptible power supply (UPS) that monitors and filters power usage and dedicated cooling equipment that is constantly running 24/7. This also includes a power generator in the case of electrical power failure.
- **Tier II** – **Redundant Capacity Components**: Everything that Tier I provides, plus redundant power and cooling to the facility. This can include extra UPS units or extra generators.
- **Tier III** – **Concurrently Maintainable**: Everything Tier II provides, plus extra equipment in place to prevent any need for shutdowns for equipment replacement or maintenance. At this tier, redundant power and cooling are applied directly to all technical equipment, and the equipment itself is configured for redundancy or seamless failover.
- **Tier IV** **– Fault Tolerance**: Everything Tier III provides, plus uninterrupted service at the provider level. While a data center may have electricity or water provided by a city or state provider, a secondary line of each service utilized by the data center is required. This includes the ISP as well. In the event of a failure at any section leading up to client equipment, there is a backup plan in place ready for a seamless transition.
## **Conclusion**
Redundancy has become an everyday term in the IT industry due to necessity. The high availability of services provides an easy, reliable experience for our customers.
Whether on the service level or the data center level, providing redundancy to your system is an important and difficult issue to tackle. Hopefully, this paper has shed some light on the options available and will help in any decisions made regarding high availability going forward.
Ready to take advantage of Atlantic.Net’s redundant systems? Contact us today to find out more about [Dedicated Server Hosting](https://www.atlantic.net/dedicated-server-hosting/) with Atlantic.Net.
===Sources===
[1] Redundant System Basic Concepts: http://www.ni.com/white-paper/6874/en/
[2] Cold/Warm/Hot Server: http://searchwindowsserver.techtarget.com/definition/cold-warm-hot-server
[3] High Availability Clustering: https://www.mulesoft.com/resources/esb/high-availability-cluster
[4] Hyper-V Replica: https://technet.microsoft.com/en-us/library/jj134172(v=ws.11).aspx
[5] Hyper-V and High Availability: https://technet.microsoft.com/en-us/library/hh127064.aspx
[6][HAProxy Description](https://www.haproxy.org/#desc)
[7][HAProxy – They use it!](https://www.haproxy.org/they-use-it.html)
[8] Heartbeat: http://www.linux-ha.org/wiki/Main_Page
[9] RAID Definition:[RAID techtarget](https://searchstorage.techtarget.com/definition/RAID)
[10] Striping:[techtarget com](https://searchstorage.techtarget.com/definition/disk-striping)
[11] [RAID Battery Backup Units](https://www.thomas-krenn.com/en/wiki/Battery_Backup_Unit_(BBU/BBM)_Maintenance_for_RAID_Controllers)
[12] High-Availability – VRRP, HSRP, GLBP: http://www.freeccnastudyguide.com/study-guides/ccna/ch14/vrrp-hsrp-glbp/
[13] [Understanding VRRP](https://www.juniper.net/techpubs/en_US/junos/topics/concept/vrrp-overview-ha.html)
[14] Configuring VRRP:[check cisco](https://www.cisco.com/c/en/us/td/docs/ios-xml/ios/ipapp_fhrp/configuration/15-mt/fhp-15-mt-book/fhp-vrrp.html)
[15] [Configuring GLBP](https://www.cisco.com/c/en/us/td/docs/ios-xml/ios/ipapp_fhrp/configuration/xe-3s/fhp-xe-3s-book/fhp-glbp.html)
[16] Explaining the Uptime Institute’s Tier Classification System: https://journal.uptimeinstitute.com/explaining-uptime-institutes-tier-classification-system/
---
# How to Set Up WireGuard VPN on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-set-up-wireguard-vpn-on-centos-8/ | Published: 2020-08-10 | Updated: 2024-09-25 | Author: Hitesh Jethva
WireGuard is an open-source, fast, security-focused virtual private network application that can be used to create secure point-to-point connections in routed configurations. It is simple, faster than OpenVPN, and uses proven cryptography protocols and algorithms to protect data. It can be installed in many operating systems including Windows, macOS, BSD, iOS, Linux, and Android. WireGuard is a peer-to-peer VPN and does not use the client-server model. It assigns static IP addresses to VPN clients, and user authentication is done by exchanging public keys.
In this tutorial, we will show you how to set up WireGuard VPN on CentOS 8.
## Step 1 – Enable IP Forwarding
Before starting, you will need to enable IP forwarding in your system. You can enable it by creating a new /etc/sysctl.d/99-custom.conf file:
```
nano /etc/sysctl.d/99-custom.conf
```
Add the following line:
```
net.ipv4.ip_forward=1
```
Save and close the file then run the following command to apply the changes:
```
sysctl -p /etc/sysctl.d/99-custom.conf
```
## Step 2 – Install Wireguard
First, you will need to install the Epel and Elrepo repositories in your system. You can install them with the following command:
```
dnf install epel-release elrepo-release -y
```
Once installed, install WireGuard by running the following command:
```
dnf install kmod-wireguard wireguard-tools -y
```
Once the installation is completed, restart your system to load the kernel module.
## Step 3 – Configure WireGuard
First, you will need to generate the public and private keys inside /etc/wireguard directory. Run the following command to generate them:
```
wg genkey | tee /etc/wireguard/privatekey | wg pubkey | tee /etc/wireguard/publickey
```
You should see your generated key in the following output:
```
Nnid+rqJBnsZ+SN68dILbmxMreKyFTlSjBI8bh4sbzU=
```
You can also list them with the following command:
```
ls /etc/wireguard/
```
You should see the following output:
```
privatekey publickey
```
Next, you will need to configure the tunnel device that will route the VPN traffic. You can do that by creating a new configuration file named wp0.conf:
```
nano /etc/wireguard/wg0.conf
```
Add the following lines:
```
[Interface]Address = 10.0.0.1/24SaveConfig = trueListenPort = 51820PrivateKey = Nnid+rqJBnsZ+SN68dILbmxMreKyFTlSjBI8bh4sbzU=PostUp = firewall-cmd --zone=public --add-port 51820/udp && firewall-cmd --zone=public --add-masqueradePostDown = firewall-cmd --zone=public --remove-port 51820/udp && firewall-cmd --zone=public --remove-masquerade
```
Save and close the file when you are finished.
Here are the relevant definitions for the lines above:
- **Address**: Specify the private IP address of the VPN server.
- **ListenPort**: Specify the WireGuard listening port.
- **PrivateKey**: Specify private key of the VPN server, which can be found in the /etc/wireguard/privatekey.
- **PostUp**: Specify any actions to execute at the time of bringing up the WireGuard interface.
- **PostDown**: Specify any actions to execute at the time of bringing down the WireGuard interface.
Next, bring up the WireGuard interface by using wg-quick command:
```
wg-quick up wg0
```
You should get the following output:
```
[#] ip link add wg0 type wireguard[#] wg setconf wg0 /dev/fd/63[#] ip -4 address add 10.0.0.1/24 dev wg0[#] ip link set mtu 1420 up dev wg0[#] firewall-cmd --zone=public --add-port 51820/udp && firewall-cmd --zone=public --add-masqueradesuccess
```
You can now check the status of the wg0 interface with the following command:
```
wg show wg0
```
You should see the following output:
```
interface: wg0
public key: 6hxSg1eZR9n4oPYckJbzXcNbVwcjF5vNsSzUREsoBEY=
private key: (hidden)
listening port: 51820
ip a show wg0
5: wg0: mtu 1420 qdisc noqueue state UNKNOWN group default qlen 1000
link/none
inet 10.0.0.1/24 scope global wg0
valid_lft forever preferred_lft forever
```
Next, enable the wg0 interface to start at system reboot with the following command:
```
systemctl enable wg-quick@wg0
```
## Step 4 – Install and Configure Wireguard VPN Client
First, install the Epel and Elrepo repositories on the client machine with the following command:
```
dnf install epel-release elrepo-release -y
```
Once installed, install WireGuard by running the following command:
```
dnf install kmod-wireguard wireguard-tools
```
Once the installation is completed, restart your system to load the kernel module.
Next, generate the public and private keys with the following command:
```
wg genkey | tee /etc/wireguard/privatekey | wg pubkey | tee /etc/wireguard/publickey
```
You should get the following output:
```
NvzqF7ilT01OD3uTAmNME1rHFnCcTdGSXo+f8tkRElQ=
```
Next, create a new wg0.conf configuration file with the following command:
```
nano /etc/wireguard/wg0.conf
```
Add the following lines:
```
[Interface]
PrivateKey = NvzqF7ilT01OD3uTAmNME1rHFnCcTdGSXo+f8tkRElQ=
Address = 10.0.0.2/24
[Peer]
PublicKey = Nnid+rqJBnsZ+SN68dILbmxMreKyFTlSjBI8bh4sbzU=
Endpoint = your-server-ip:51820
AllowedIPs = 0.0.0.0/0
```
Save and close the file when you are finished.
Here are the relevant definitions for the lines above:
- **PrivateKey** : Specify the client’s private key.
- **Address**: Specify the private IP address for wg0 interface.
- **PublicKey** : Specify the server public key.
- **Endpoint** : Specify the server IP address.
- **AllowedIPs** : Specify the allowed IPs.
## Step 5 – Add the Client Peer to the Server
Next, you will need to add your WireGuard client’s public key and IP Address in your WireGuard VPN Server.
On the server machine, run the following command to add the client public key and IP address to the server:
```
wg set wg0 peer NvzqF7ilT01OD3uTAmNME1rHFnCcTdGSXo+f8tkRElQ= allowed-ips 10.0.0.2
```
You can find the client-public key at /etc/wireguard/publickey on the client machine.
On the client machine, bring up the wg0 interface with the following command:
```
wg-quick up wg0
```
You should see the following output:
```
[#] ip link add wg0 type wireguard[#] wg setconf wg0 /dev/fd/63[#] ip -4 address add 10.0.0.2/24 dev wg0[#] ip link set mtu 1420 up dev wg0
```
On the server machine, you can check the WireGuard server status with the following command:
```
wg
```
You should get the following output:
```
interface: wg0
public key: 6hxSg1eZR9n4oPYckJbzXcNbVwcjF5vNsSzUREsoBEY=
private key: (hidden)
listening port: 51820
peer: NvzqF7ilT01OD3uTAmNME1rHFnCcTdGSXo+f8tkRElQ=
allowed ips: 0.0.0.0/0
latest handshake: 22 seconds ago
transfer: 126.15 KiB received, 123.12 KiB sent
```
## Conclusion
Congratulations, you have successfully set up a WireGuard VPN server on CentOS 8 and created a VPN tunnel between two CentOS 8 machines. You can now surf the web anonymously and keep your traffic data private. Get started today with a [virtual private server](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install Apache with Python Mod_wsgi on Debian
> URL: https://www.atlantic.net/vps-hosting/how-to-install-apache-with-python-mod-wsgi-on-debian/ | Published: 2020-08-11 | Updated: 2025-09-02 | Author: Hitesh Jethva
WSGI stands for “Web Server Gateway Interface,” which provides a standard and efficient method for dynamic web applications to communicate with web servers. It is used for deploying applications written in Django, Web.py, Werkzug, and Flask. Mod_wsgi simplifies the WSGI application deployment on an Apache webserver. Mod_wsgi is an Apache webserver module that can be used to serve Python applications using the HTTP protocol.
In this tutorial, we will show you how to install Apache with Python Mod_wsgi on Debian 12.
## Step 1 – Install Python
First, you will need to install Python in your system. You can install it by just running the following command:
```
apt-get install python3 libexpat1 -y
```
Once Python is installed, you can proceed to the next step.
## Step 2 – Install Apache with mod_wsgi Module
Next, you will need to install the Apache webserver package and mod_wsgi Python module in your system. Run the following command to install them:
```
apt-get install apache2 apache2-utils ssl-cert libapache2-mod-wsgi-py3 -y
```
Once all the packages are installed, restart the Apache service to apply the changes.
```
systemctl restart apache2
```
## Step 3 – Configure Apache with mod_wsgi Module
First, you will need to create a Python script in your Apache web root directory. You can create it with the following command:
```
nano /var/www/html/wsgi.py
```
Add the following lines:
```
def application(environ, start_response):
status = '200 OK'
html = b"\n" \
b"\n" \
b"\n" \
b"Welcome to Apache with mod_wsgi\n" \
b"
\n" \
b"\n" \
b"\n"
response_header = [('Content-type', 'text/html; charset=utf-8')]
start_response(status, response_header)
return [html]
```
Save and close the file when you are finished.
Next, you will need to create an Apache virtual host configuration file to serve the Python script with HTTP protocol.
You can create it with the following command:
```
nano /etc/apache2/conf-available/mod-wsgi.conf
```
Add the following line:
```
WSGIScriptAlias /wsgi /var/www/html/wsgi.py
Require all granted
```
Save and close the file. Then, activate the virtual host configuration with the following command:
```
a2enconf mod-wsgi
```
Next, restart the Apache service to apply the changes.
```
systemctl restart apache2
```
## Step 4 – Verify mod_wsgi Application
Now, open your web server and visit the URL http://your-server-ip/wsgi. You will be redirected to the following screen:
## Conclusion
Congratulations! You have successfully deployed Python application with mod_wsgi and Apache on Debian 12. Easily deploy a Python application in the production environment on your [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
---
# How to Install and Configure Memcached on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-configure-memcached-on-centos-8/ | Published: 2020-08-12 | Updated: 2024-09-25 | Author: Hitesh Jethva
Memcached is an open-source and high-performance in-memory caching system. Generally, it is used to speed up web applications by caching session data, user authentication tokens, and API calls. Its aim is to accelerate dynamic web applications by alleviating database load. Memcached reduces application load by storing data objects in dynamic memory.
In this tutorial, we will explain how to install Memcached on CentOS 8.
## Step 1 – Install Memcached
By default, Memcached is available in the CentOS 8 default repository. You can install it by just running the following command:
```
dnf update -ydnf install memcached libmemcached -y
```
After installing Memcached, start the Memcached service and enable it to start at boot with the following command:
```
systemctl start memcachedsystemctl enable memcached
```
You can also verify the status of the Memcached service with the following command:
```
systemctl status memcached
```
You should see the following output:
```
memcached.service - memcached daemon
Loaded: loaded (/usr/lib/systemd/system/memcached.service; disabled; vendor preset: disabled)
Active: active (running) since Fri 2020-08-07 06:30:57 EDT; 10s ago
Main PID: 9933 (Memcached)
Tasks: 10 (limit: 12537)
Memory: 3.6M
CGroup: /system.slice/memcached.service
└─9933 /usr/bin/memcached -p 11211 -u memcached -m 64 -c 1024 -l 127.0.0.1,::1
Aug 07 06:30:57 centos8 systemd[1]: Started memcached daemon.
```
## Step 2 – Configure Memcached
Memcached default configuration file is located at /etc/sysconfig/memcached. By default, Memcached is configured to listen on the localhost. If your application is hosted on the same server, then you don’t need to configure Memcached. If your application is hosted on the remote server, then you will need to configure Memcached to listen on that IP address and allow access to the Memcached port 11211 only from the client IP address.
To see the Memcached default configuration, run the following command:
```
cat -n /etc/sysconfig/memcached
```
You should see the following output:
```
1 PORT="11211" 2 USER="memcached" 3 MAXCONN="1024" 4 CACHESIZE="64" 5 OPTIONS="-l 127.0.0.1,::1"
```
If you want to configure Memcached for a remote application, you need to replace the **127.0.0.1** with the IP address of the remote system.
## Step 3 – Integrate Memcached with PHP
If you want to use Memcached as a caching database for your PHP application, then you will need to install the Memcached extension for PHP.
First, you will need to install the EPEL and Remi repository in your system. You can install them by running the following command:
```
dnf install epel-release -ydnf install https://rpms.remirepo.net/enterprise/remi-release-8.rpm -y
```
Next, enable the PHP Remi repository with the following command:
```
dnf module enable php:remi-7.4 -y
```
Next, install the PHP Memcached extension with the following command:
```
dnf install php-pecl-memcache php-pecl-memcached -y
```
Once you are finished, you can proceed to the next step.
## Step 4 – Verify Memcached
Next, install the Nginx web server and create a sample PHP page to test whether Memcached is enabled for PHP or not.
First, install Nginx with PHP by running the following command:
```
dnf install nginx php php-cli -y
```
Once installed, create a sample info.php page:
```
nano /var/www/html/info.php
```
Add the following lines:
```
```
Save and close the file, then create a symbolic link of info.php file to the Nginx default web root directory:
```
ln -s /var/www/html/info.php /usr/share/nginx/html/
```
Next, start the Nginx server and enable it to start at boot with the following command:
```
systemctl start nginxsystemctl enable nginx
```
Now, open your web browser and type the URL http://your-server-ip/info.php. You should see the Memcached section in the following screen:
## Conclusion
Congratulations! You have successfully installed and configured Memcached on CentOS 8. You can now integrate your web application with Memcached and use its features to speed up your website on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net. For more information, visit the [Memcached](https://github.com/memcached/memcached/wiki) documentation.
---
# How to Install Plesk Onyx on CentOS 7
> URL: https://www.atlantic.net/vps-hosting/how-to-install-plesk-onyx-on-centos-7/ | Published: 2020-08-13 | Updated: 2024-09-25 | Author: Hitesh Jethva
Plesk Onyx is the newest and smoothest upgrade of the traditional Plesk control panel. It is one of the best control panels for Linux and Windows servers. Plesk Onyx is very similar to cPanel and DirectAdmin and makes managing your website easy while providing a set of security improvements designed to help harden your server. It supports various databases, including Docker, Git, Ruby, Node.js, DNSSEC, and many more.
In this tutorial, we will show you how to install Plesk Onyx control panel on CentOS 7.
## Step 1 – Download Plesk Onyx Installer
Next, you will need to download the Plesk Onyx installation script from its official website.
You can download it using the wget command:
```
wget http://autoinstall.plesk.com/plesk-installer
```
Once downloaded, give execution permissions with the following command:
```
chmod +x plesk-installer
```
Next, start the installation using the following command:
```
./plesk-installer
```
You will be asked to choose the following options:
```
Select an action [F/q]: F
```
Type **F**and hit **Enter**to continue. You should see the following output:
```
Would you like to help Plesk make better products by sending information
about issues occurred, including installation and upgrade issues? [Y/n]: Y
```
Type **Y**and hit **Enter**. You should see the following output:
```
Select an action or a number [F/b/q/1-3]: F
```
Type **F**and hit **Enter**. You should see the following output:
```
Select an action [F/b/q/s]: F
```
Type **F**and hit **Enter**to start the installation. Once the installation has been completed, you should get the following output:
## Step 2 – Access Plesk Onyx Web Interface
Now, open your web browser and type **the URL from the above.** You will be redirected to the following screen:
Provide your administrator email, password, License key and click on the **Enter** **Plesk** button. You should see the Plesk dashboard in the following screen:
## Conclusion
Congratulations! You have successfully installed the Plesk Onyx control panel on CentOS 7. You can now manage your web hosting account, DNS, Domain, Mailbox, and Website easily with Plesk Onyx. For more information, visit the [Plesk Onyx](https://docs.plesk.com/en-US/onyx/) documentation. Try Plesk Onyx today with an Atlantic.Net [VPS Hosting](https://www.atlantic.net/vps-hosting/) account!
---
# How to Install Hestia Control Panel on Debian 12
> URL: https://www.atlantic.net/vps-hosting/how-to-install-hestia-control-panel-on-debian-12/ | Published: 2020-08-14 | Updated: 2025-09-05 | Author: Hitesh Jethva
Hestia Control Panel is a powerful, free, open-source web hosting control panel that can be used to host websites, mail servers, DNS, and other web hosting features from the central location. It is designed for speed, security, and stability, and capably runs on a low-resource server. Hestia Control Panel comes with a user-friendly web and command-line interface that enables deployment and management of web domains, mail accounts, and DNS zones without hassle.
In this tutorial, we will show you how to install Hestia Control Panel on Debian 12.
[jumpbox]
## Prerequisites
- A fresh Debian 12 64-bit [VPS](https://www.atlantic.net/vps-hosting/) with 4GB RAM.
- A valid domain name that your server IP points to.
- A root password configured on your server.
## Step 1 – Download Hestia Installation Script
Before starting, you will need to install the required dependencies on your server. You can install all of them with the following command:
```
apt-get install ca-certificates gnupg2 curl wget unzip systemd-timesyncd -y
```
Next, start and enable the timesyncd service.
```
systemctl enable --now systemd-timesyncd
```
After installing all the packages, you will need to download the Hestia installation script. You can download it with the following command:
```
wget https://raw.githubusercontent.com/hestiacp/hestiacp/release/install/hst-install.sh
```
Once downloaded, give proper permission to the downloaded script with the following command:
```
chmod 755 hst-install.sh
```
## Step 2 – Install Hestia
Now, run the downloaded installation script to start the installation with the following command:
```
bash hst-install.sh
```
You should see the following output:
```
Please use a valid username (ex. user).Please enter administrator username: hjethvaPlease enter administrator password: securepasswordPress Y to continue the installationPlease enter admin email address: example@atlantic.netPlease enter FQDN hostname [debian10]: hestia.example.com
```
Provide your admin username, password, email address and valid domain name, and hit **Enter**to start the installation. Once the installation has been completed successfully, you should see the following output:
```
Congratulations!
You have successfully installed Hestia Control Panel on your server.
Ready to get started? Log in using the following credentials:
Admin URL: https://hestia.example.com:8083
Backup URL: https://69.87.218.182:8083
Username: hjethva
Password: The password you chose during installation.
Thank you for choosing Hestia Control Panel to power your full stack web server,
we hope that you enjoy using it as much as we do!
Please feel free to contact us at any time if you have any questions,
or if you encounter any bugs or problems:
Documentation: https://docs.hestiacp.com/
Forum: https://forum.hestiacp.com/
GitHub: https://www.github.com/hestiacp/hestiacp
Note: Automatic updates are enabled by default. If you would like to disable them,
please log in and navigate to Server > Updates to turn them off.
Help support the Hestia Control Panel project by donating via PayPal:
https://www.hestiacp.com/donate
--
Sincerely yours,
The Hestia Control Panel development team
Made with love & pride by the open-source community around the world.
[ ! ] IMPORTANT: The system will now reboot to complete the installation process.
Press any key to continue
```
Press the **Enter** key to restart your server.
**Note** : Please remember the Hestia login URL and credentials as shown in the above output.
## Step 3 – Manage Hestia Service
You can manage the Hestia service easily with systemd utility.
For example, you can start and stop the Hestia service with the following command:
```
systemctl start hestiasystemctl stop hestia
```
You can also verify the status of the Hestia service with the following command:
```
systemctl status hestia
```
You should see the following output:
```
● hestia.service - LSB: starts the hestia control panel
Loaded: loaded (/etc/init.d/hestia; generated)
Active: active (running) since Fri 2025-09-05 12:11:06 UTC; 1min 55s ago
Docs: man:systemd-sysv-generator(8)
Process: 447 ExecStart=/etc/init.d/hestia start (code=exited, status=0/SUCCESS)
Tasks: 3 (limit: 4637)
Memory: 26.0M
CPU: 80ms
CGroup: /system.slice/hestia.service
├─471 "nginx: master process /usr/local/hestia/nginx/sbin/hestia-nginx"
├─474 "nginx: worker process"
└─496 "php-fpm: master process (/usr/local/hestia/php/etc/php-fpm.conf)"
```
## Step 4 – Secure Hestia with Let’s Encrypt SSL
By default, Hestia is secured with a self-signed certificate, but it is not signed by a certificate authority (CA). Therefore, it is recommended to install an SSL certificate signed by a CA to place normal traffic in a protected, encrypted wrapper.
Let’s Encrypt is a free and non-profit certificate authority run by Internet Security Research Group. Its aim is to create a more secure and privacy-respecting Web by promoting the widespread adoption of HTTPS.
You can secure your Hestia with Let’s Encrypt free SSL by just running the following command:
```
v-add-letsencrypt-host
```
If successful, nothing will be displayed on the screen.
## Step 5 – Access Hestia Control Panel
Now, open your web browser and type the URL **https://hestia.example.com:8083.** You will be redirected to the Hestia login screen:
Provide your admin username, password, and click on the **login** button. You should see the Hestia Control Panel default dashboard.
## Conclusion
Congratulations! You have successfully installed Hestia Control Panel and secure it with Let’s Encrypt SSL on Debian 12. You can now start setting up your host environment and other settings after logging on to the back-end panel. Get started today on your [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# 10 Telehealth Best Practices When Running a Remote Practice During COVID-19
> URL: https://www.atlantic.net/hipaa-compliant-hosting/10-telehealth-best-practices-when-running-a-remote-practice-during-covid-19/ | Published: 2020-08-17 | Updated: 2025-09-19 | Author: Brandon Schroth
As healthcare workers on the front lines put themselves at risk each day, more hospitals and healthcare systems are turning to telehealth services to keep workers safe.
In many cases, telehealth technology can keep patients out of hospitals, urgent care facilities, and doctors’ offices by providing timely diagnoses and access to medical care. This limits the spread of a contagious disease like COVID-19 by keeping patients safe at home.
However, implementing telehealth services comes with challenges. Potential limitations include the inability to perform a proper physical exam and a lack of patient comfort with the technology. However, during a pandemic, offering telehealth services lets you provide necessary healthcare and keep everyone safe. It even enables quarantined staff to continue working in a remote capacity and reduce the risk of spreading the illness.
In this post, we’ll share 10 telehealth best practices to help you make the most of the technology and efficiently care for your patients on a remote basis.
## 1. Set strategic goals
Before you implement or expand telehealth services within your organization, take the time to set appropriate goals. Realistic and measurable goals will help when determining staffing needs, evaluating performance, estimating costs, and picking the right equipment. Start small to improve the chances of success.
For example, say the ultimate goal of your telehealth program is to provide rural patients with access to care. A realistic goal might be to have at least 50 percent of your rural-based patients sign up for the telehealth service. If you know that the majority of rural patients in your practice are over the age of 60, it would make sense to make telehealth services available via a phone call instead of a smartphone-accessible patient portal.
Assessing your goals before implementing your plan will ensure you allocate resources correctly.
## 2. Create an implementation team
An internal team dedicated to implementing telemedicine services can help you keep costs down and smoothly roll out the new service. Using a third-party team instead of an internal one can result in time-consuming meetings and miscommunication. Keep in mind that the entire organization should be involved to get everyone’s input and assistance. Don’t just use IT staff; include your physicians and clinical staff as well.
For example, one of the first things you’ll need to set up is [telehealth video conferencing software](https://www.jotform.com/blog/telehealth-video-conferencing/). This software needs to be fully [HIPAA compliant](https://www.atlantic.net/hipaa-compliant-hosting/) and easy for your doctors, staff, and patients to use.
## 3. Search and apply for grants
It can be expensive to implement telemedicine services, and reimbursements often won’t fund the upgrades. However, there are technology grants that can help offset the cost. You can find tech grants designed to improve the quality of life for rural citizens through organizations like the U.S. Department of Agriculture or state rural health associations.
Take the time to look for grants available in your area and apply for any that your practice qualifies for. If you don’t feel confident in your writing skills, it may be worth working with a writer who specializes in grant applications to improve your chances of being awarded the funds.
## 4. Follow the CDC framework
When in doubt, stick to the guidelines set forth by the CDC in their Non-COVID-19 Care Framework. This framework gives healthcare systems key considerations and examples of how to triage and respond to both critical and noncritical care to keep everyone safe.
For instance, you’ll need to provide different levels of care and support for someone who is complaining of chest pains vs someone who needs a routine vaccine vs someone who needs a prescription refill. There’s only so much care you can provide in a telehealth consultation to someone with heart attack symptoms, so you’ll need to prioritize care in a hospital or in-person clinic safely. It might be OK to defer a routine vaccine a month or two or hold the appointment in a safer location with less COVID-19 community spread. And, you could most likely handle a simple prescription refill remotely on a telehealth appointment.
## 5. Train your team on new technology first
Before testing the new technology on patients, it’s important to train your doctors, nurses, and administrative staff first. If they spend 10 minutes fumbling around with how to get their webcam to work, they won’t inspire confidence with your patients.
*Pro tip: In addition to detailed training manuals, you might even want to provide mandatory training workshops and drills for anyone who will be using the technology. *
## 6. Share telehealth protocols with patients
Your patients won’t know about the new telehealth service unless you tell them. Even if it’s on your website, you cannot realistically expect all of your patients to discover the information on their own.
Here are some communication tactics you can use to promote the service:
- Communicate your organization’s policies during the COVID-19 health crisis as soon as you implement them.
- Call patients with upcoming appointments and let them know how any new policies will affect their appointment.
- Change your messaging scripts to share information about telehealth services. Contact high-risk patients, such as the elderly, as soon as possible.
## 7. Communicate with remote team members and vendors
To keep your telehealth services running smoothly, ensure open communication with all stakeholders. This means communicating with schedulers, presenters, clinicians, nursing staff, and anyone else working remotely. Be open to feedback and regularly check to make sure that billing systems, IT support, administration, and other functions are running as they should be.
It can help to bring onsite staff together on a regular basis, such as quarterly, to discuss any issues with the telehealth program or connecting with remote partners. Encouraging communication means the organization can gather feedback, make improvements, and move forward with patient care.
## 8. Maintain accurate records
Just as you would maintain detailed records for patients who walk through the door, you’ll also need to keep accurate electronic records for those using telemedicine services.
You’ll want to record as much as possible, including any assessments or treatment plans — in addition to collecting [signed HIPAA forms and waivers](https://www.jotform.com/hipaa/templates/) from all patients.
## 9. Come up with a backup plan
There will be times when you need to escalate care for a patient or consult with a specialist or other provider in person. And sometimes, your telehealth software might have an outage.
In these scenarios, you’ll need to have protocols in place so your staff can take the appropriate action.
For instance, if your video chat software fails, how will your staff reach out to the patient? Have a plan in place before the need arises so everyone’s on the same page.
## 10. Ask for patient feedback
While you can certainly anticipate some of the challenges patients will face when using telehealth technology — such as a learning curve on video chats for some elderly patients without smartphones — you can’t predict everything. There could be trouble areas that your IT department didn’t expect.
This is where asking for feedback from patients — whether it’s during their appointment or in a follow-up survey afterward — can be beneficial. You can use this valuable feedback to make continuous improvements as everyone adjusts to using the new service.
## **
In addition to the tips above, stay informed about COVID-19 cases in your community. Monitoring trends in local case counts will help you prepare for increased demand in telehealth services. Check with the CDC regularly for additional guidance on safely operating during the COVID-19 pandemic.
Start implementing these best practices today with [HIPAA compliant hosting](https://www.atlantic.net/hipaa-compliant-hosting/) from Atlantic.Net – the perfect hosting solution to support telehealth. Contact us today to start a free HIPAA hosting trial!
---
# How to Install Pure-FTPd on Ubuntu
> URL: https://www.atlantic.net/vps-hosting/how-to-install-pure-ftpd-on-ubuntu/ | Published: 2020-08-18 | Updated: 2025-09-19 | Author: Hitesh Jethva
Pure FTPd is a free and open-source FTP server designed with a strong focus on software security. It can be run on several operating systems including Linux, OpenBSD, NetBSD, FreeBSD, DragonFly BSD, Solaris, and many more. It is a very lightweight and stable daemon that supports various authentication backends such as Linux system users, puredb, MySQL, and PostgeSQL.
In this tutorial, we will explain how to install Pure FTPd with SSL/TLS on Ubuntu 24.04.
## Prerequisites
- A fresh Ubuntu 24.04 [VPS](https://www.atlantic.net/vps-hosting/) on the Atlantic.Net Cloud Platform.
- A root password configured on your server.
## Step 1 – Create Atlantic.Net Cloud Server
First, log in to your [Atlantic.Net Cloud Server](https://cloud.atlantic.net/?page=userlogin). Create a new [server](https://www.atlantic.net/vps-hosting/how-to-create-new-atlantic-net-cloud-server/), choosing Ubuntu 24.04 as the operating system with at least 1GB RAM. Connect to your Cloud Server via SSH and log in using the credentials highlighted at the top of the page.
Once you are logged in to your Ubuntu 24.04 server, run the following command to update your base system with the latest available packages.
```
apt-get update -y
```
## Step 2 – Install Pure FTPd
By default, Pure FTPd is available in the Ubuntu 24.04 default repository. You can install it with the following command:
```
apt-get install pure-ftpd -y
```
After installing Pure FTPd, you can verify the status of Pure FTPd with the following command:
```
systemctl status pure-ftpd
```
You should see the following output:
## Step 3 – Create FTP User
Next, you will need to create a FTP user in your system. You can create it with the following command:
```
adduser vyom
```
You will be asked to set a password as shown below:
```
Adding user `vyom' ...
Adding new group `vyom' (1000) ...
Adding new user `vyom' (1000) with group `vyom' ...Creating home directory `/home/vyom' ...
Copying files from `/etc/skel' ...
New password:
Retype new password:
passwd: password updated successfully
Changing the user information for vyom
Enter the new value, or press ENTER for the default
Full Name []:
Room Number []:
Work Phone []:
Home Phone []:
Other []:
Is the information correct? [Y/n] Y
```
## Step 4 – Create a Self-signed SSL/TLS certificate
Next, you will need to generate a self-signed certificate for Pure FTPd. You can generate it with the following command:
```
openssl req -x509 -nodes -newkey rsa:2048 -keyout /etc/ssl/private/pure-ftpd.pem -out /etc/ssl/private/pure-ftpd.pem -days 365
```
Answer all the questions with answers relevant to your installation, as shown below:
```
Generating a RSA private key.......................+++++....+++++writing new private key to '/etc/ssl/private/pure-ftpd.pem'-----You are about to be asked to enter information that will be incorporated into your certificate request.What you are about to enter is what is called a Distinguished Name or a DN.There are quite a few fields but you can leave some blankFor some fields there will be a default value,If you enter '.', the field will be left blank.-----Country Name (2 letter code) [AU]:INState or Province Name (full name) [Some-State]:GUJLocality Name (eg, city) []:JUNOrganization Name (eg, company) [Internet Widgits Pty Ltd]:AtlanticOrganizational Unit Name (eg, section) []:ITCommon Name (e.g. server FQDN or YOUR name) []:exampleEmail Address []:admin@example.com
```
## Step 5 – Configure Pure FTPd to use SSL/TLS
Next, you will need to configure Pure FTPd to use the certificate which we have generated above. You can configure it by editing the pure-ftpd.conf file:
```
nano /etc/pure-ftpd/pure-ftpd.conf
```
Change the following lines:
```
TLSCipherSuite HIGHCertFile /etc/ssl/private/pure-ftpd.pem
```
Save and close the file when you are finished.
Enable the TLS support.
```
echo "2" | tee /etc/pure-ftpd/conf/TLS
```
Then, restart the Pure FTPd service to apply the changes:
```
systemctl restart pure-ftpd
```
At this point, Pure FTPd is installed and configured to use SSL/TLS.
## Step 6 – Connect FTP Server from Client
Next, you will need to connect to your Pure FTPd server from the client machine using the FileZilla FTP client.
First, open the FileZilla client and click on the **Site Manager**. You should see the following screen:
Provide your Pure FTPd server IP, select FTP protocol, select “Require explicit FTP over TLS”, provide your FTP username and password, and click on the **Connect** button. You will be prompted to accept the certificate as shown below:
Accept the certificate and click on the **OK** button. Once you are connected, you should see the following screen:
## Conclusion
Congratulations! You have successfully installed Pure FTPd with SSL/TLS support on Ubuntu 24.04 server. You can now upload and download files and directories, to and from the FTP server. Try Pure FTPd today on Linux [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How To Install Calibre Web On Ubuntu 20.04 with Docker
> URL: https://www.atlantic.net/vps-hosting/how-to-install-calibre-web-on-ubuntu-20-04-with-docker/ | Published: 2020-08-25 | Updated: 2023-11-17 | Author: Hitesh Jethva
Calibre Web is a web-based application that allows you to browse, download, and read eBooks using an existing Calibre database. You can also integrate Google Drive or Dropbox, edit metadata, and update your Calibre library through the app itself. Calibre Web allows you to access your Calibre libraries and read books directly in a browser on your favorite mobile phone or tablet device.
**Features**
- Bootstrap 3 HTML5 interface
- User management
- Support for editing eBook metadata
- Restrict eBook download to logged-in users
- Support for reading eBooks directly in the browser
- Fine-grained per-user permissions
- Create a custom book collection
In this tutorial, we will show you how to install Calibre Web with Docker on Ubuntu 20.04.
## Step 1 – Install Docker and Docker Compose
By default, the latest version of Docker is not available in the Ubuntu 20.04 default repository, so it is recommended to add Docker’s official repository in your system.
First, install some required packages with the following command:
```
apt-get install apt-transport-https ca-certificates curl software-properties-common -y
```
Once all the packages are installed, import the GPG key with the following command:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
```
Next, add the Docker repository with the following command:
```
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
```
Next, install the latest version of Docker and Docker Compose with the following command:
```
apt-get install docker-ce docker-compose -y
```
Once installed, verify the version of Docker with the following command:
```
docker --version
```
You should see the following output:
```
Docker version 19.03.12, build 48a66213fe
```
You can also verify the Docker Compose version with the following command:
```
docker-compose --version
```
You should see the following output:
```
docker-compose version 1.25.0, build unknown
```
## Step 2 – Install Calibre Web
First, you will need to create a directory to store books and a database. You can create it with the following command:
```
mkdir -p /volume1/books/calibre
```
Next, give proper permission and ownership with the following command:
```
chown -R root:users /volume1/
chmod -R 770 /volume1
```
Next, create a Docker container for Calibre Web with the following command:
```
docker create --name=calibre-web --restart=always -v /volume1/books/calibre:/books -e SET_CONTAINER_TIMEZONE=true -e CONTAINER_TIMEZONE=Europe/Amsterdam -e PGID=100 -e PUID=1000 -p 8082:8083 technosoft2000/calibre-web:v1.1.9
```
You should get the following output:
```
Unable to find image 'technosoft2000/calibre-web:v1.1.9' locally
latest: Pulling from linuxserver/calibre-web
1b6b131f80dd: Pull complete
0644a6c93828: Pull complete
5ce05b5dfdaa: Pull complete
9ffa5f0d8822: Pull complete
6bfcd0e10365: Pull complete
b92a89a4f19d: Pull complete
Digest: sha256:27f5979ffc9ba3e5c4b2ef4385cc30e2af42a6a7d453302f45ecdc75f47c4bf8
Status: Downloaded newer image for technosoft2000/calibre-web:v1.1.9
f9a32db589bdc00a34ee089d3da14d416f97f4376f2249dd9a0d955f43e9e2a7
```
Next, start the container with the following command:
```
docker start calibre-web
```
At this point, Calibre Web is installed and listening on port 8082. You can check it with the following command:
```
ps -ef | grep 8082
```
You should see the following output:
```
root 3248 425 0 10:46 ? 00:00:00 /usr/bin/docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 8082 -container-ip 172.17.0.2 -container-port 8083
root 3943 855 0 10:56 pts/0 00:00:00 grep --color=auto 8082
```
## Step 3 – Access Calibre Web
Now, open your web browser and type the URL http://your-server-ip:8082. You will be redirected to the following screen:
Now, provide the location of the eBook and click on the **Login** button. You should see the following screen:
Now, provide default username as **admin** and password as **admin123**, and click on the **Login** button. You should see the Calibre Web dashboard in the following screen:
## Conclusion
Congratulations! You have successfully installed Calibre Web with the Docker on Ubuntu 20.04. You can now easily upload, download, and read your book online through a web browser. Try Calibre Web today on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Install CodeIgniter PHP Framework on Debian
> URL: https://www.atlantic.net/vps-hosting/how-to-install-codeigniter-php-framework-on-debian/ | Published: 2020-08-26 | Updated: 2025-09-02 | Author: Hitesh Jethva
CodeIgniter is a free and open-source PHP MVC Framework used for building websites in PHP. It is a very powerful framework that allows you to easily create full-featured web applications. CodeIgniter provides a set of useful libraries used for performing various operations like sending emails, uploading files, managing sessions, and more. Lightweight but powerful, CodeIgniter enables developers to write their applications much more quickly.
In this tutorial, we will explain how to install the CodeIgniter PHP Framework on Debian 12.
## Step 1 – Install LAMP Stack
First, you will need to install the Apache web server, MariaDB server, PHP, and other required packages in your system. You can install all of them by running the following command:
```
apt-get install apache2 mariadb-server libapache2-mod-php php php-cli php-intl php-mysql php-zip php-gd php-mbstring php-curl php-xml php-pear php-bcmath unzip git wget nano -y
```
Once all the packages are installed, start the Apache and MariaDB services and enable them to start at system reboot with the following command:
```
systemctl start apache2
systemctl start mariadb
systemctl enable apache2
systemctl enable mariadb
```
## Step 2 – Configure the MariaDB Database
Next, you will need to create a database and user for CodeIgniter. First, log in to MySQL shell with the following command:
```
mysql
```
Once logged in, create a user and database with the following command:
```
CREATE USER 'codeigniter'@'localhost' IDENTIFIED BY 'password';
CREATE DATABASE codeigniterdb;
```
Next, grant all the privileges to the codeigniter database with the following command:
```
GRANT ALL ON codeigniterdb.* to 'codeigniter'@'localhost';
```
Next, flush the privileges and exit from the MariaDB console with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Install and Configure CodeIgniter
First, download the latest version of CodeIgniter from the Git repository with the following command:
```
wget https://github.com/codeigniter4/CodeIgniter4/archive/refs/heads/4.7.zip
```
Once downloaded, unzip the downloaded file to the Apache web root directory:
```
unzip 4.7.zip
mv CodeIgniter4-4.7 /var/www/codeigniter
```
Set proper ownership and permission with the following command:
```
chown -R www-data:www-data /var/www/codeigniter
chmod -R 755 /var/www/codeigniter
```
Once you are done, you can proceed to the next step.
## Step 4 – Configure Apache for CodeIgniter
Next, you will need to create an Apache virtual host configuration file to serve the CodeIgniter application.
You can create it with the following command:
```
nano /etc/apache2/sites-available/codeigniter.conf
```
Add the following lines:
```
ServerName codeigniter.example.comDocumentRoot /var/www/codeigniter/publicAllowOverride AllErrorLog ${APACHE_LOG_DIR}/error.logCustomLog ${APACHE_LOG_DIR}/access.log combined
```
Save and close the file, then enable the virtual host configuration file with the following command:
```
a2ensite codeigniter.conf
```
Next, restart the Apache service to apply the changes:
```
systemctl reload apache2
```
## Step 5 – Access CodeIgniter
At this point, CodeIgniter is installed and configured with Apache. Now, open your web browser and access the URL **http://codeigniter.example.com.** You should see your CodeIgniter application in the following screen:
## Conclusion
Congratulations! You have successfully installed CodeIgniter Framework with Apache on Debian 12. For more information about how to use this PHP web application framework visit the CodeIgniter [documentation](https://www.codeigniter.com/user_guide/) page. Get started with CodeIgniter today on a Debian 12 VPS with [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install Bitwarden Password Manager with Docker on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-bitwarden-password-manager-with-docker-on-ubuntu-20-04/ | Published: 2020-08-27 | Updated: 2024-06-04 | Author: Hitesh Jethva
Bitwarden is a free and open-source password manager that can be used to store passwords for any device and browser. Bitwarden helps you to not only create and manage your passwords but also sync them across all devices. It offers several client applications including mobile apps, a CLI, a web interface, browser extensions, and desktop applications.
In this tutorial, we will show you how to install the Bitwarden Password Manager on Ubuntu 20.04 server.
## Step 1 – Install Required Dependencies
First, you will need to install some dependencies in your server. You can install all of them by running the following command:
```
apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common -y
```
Once all the packages are installed, you can proceed to the next step.
## Step 2 – Install Docker and Docker Compose
By default, the latest version of Docker is not available in the Ubuntu 20.04 default repository, so it is a good idea to add the Docker official repository in your system.
First, download and add the GPG key with the following command:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
```
Next, add the Docker repository with the following command:
```
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
```
Once the repository is added, you can install the Docker and Docker Compose using the following command:
```
apt-get install docker-ce docker-ce-cli containerd.io docker-compose -y
```
After installing both packages, check the installed version of Docker with the following command:
```
docker --version
```
You should get the following output:
```
Docker version 19.03.12, build 48a66213fe
```
You can also verify the Docker Compose version with the following command:
```
docker-compose --version
```
You should see the following output:
```
docker-compose version 1.25.0, build unknown
```
## Step 3 – Install Bitwarden
First, you will need to download the Bitwarden installation script from their official website. You can download it with the following command:
```
curl -Lso bitwarden.sh https://go.btwrdn.co/bw-sh
```
Next, give the execution permission to the downloaded script:
```
chmod +x bitwarden.sh
```
Before installing Bitwarden, you will need to generate the Bitwarden installation ID and Key. You can generate them from the Bitwarden website.
Provide your email address and click on the **Submit** button. You should see your installation ID and Key in the following screen:
Next, start the Bitwarden installation with the following command:
```
./bitwarden.sh install
```
During the installation, you will be asked to provide your server IP, installation key and installation ID as shown below:
```
_ _ _ _
| |__ (_) |___ ____ _ _ __ __| | ___ _ __
| '_ \| | __\ \ /\ / / _` | '__/ _` |/ _ \ '_ \
| |_) | | |_ \ V V / (_| | | | (_| | __/ | | |
|_.__/|_|\__| \_/\_/ \__,_|_| \__,_|\___|_| |_|
Open source password management solutions
Copyright 2015-2020, 8bit Solutions LLC
https://bitwarden.com, https://github.com/bitwarden
===================================================
Docker version 19.03.12, build 48a66213fe
docker-compose version 1.25.0, build unknown
(!) Enter the domain name for your Bitwarden instance (ex. bitwarden.example.com): 69.87.216.49
(!) Do you want to use Let's Encrypt to generate a free SSL certificate? (y/n): n
1.36.1: Pulling from bitwarden/setup
6ec8c9369e08: Pull complete
fe8522826504: Pull complete
658bf4619169: Pull complete
0392978bbc2e: Pull complete
33dd02257803: Pull complete
2a69859c8164: Pull complete
d68079cd71ee: Pull complete
7c08df4e94b0: Pull complete
653a8af878c4: Pull complete
d252f877c4a2: Pull complete
Digest: sha256:5b2c43b46c03da54aecc6d19098b0574b5fb205f0cd3046019725925cadfdf29
Status: Downloaded newer image for bitwarden/setup:1.36.1
docker.io/bitwarden/setup:1.36.1
(!) Enter your installation id (get at https://bitwarden.com/host): 97e9325e-f0e7-47cf-9667-ac0f008645b9
(!) Enter your installation key: tloMiUlAn4NTUCgWTSC5
(!) Do you have a SSL certificate to use? (y/n): n
(!) Do you want to generate a self-signed SSL certificate? (y/n): y
Generating self signed SSL certificate.
Generating a RSA private key
........................++++
..................++++
writing new private key to '/bitwarden/ssl/self/69.87.216.49/private.key'
-----
Generating key for IdentityServer.
Generating a RSA private key
.........++++
.......................++++
writing new private key to 'identity.key'
-----
!!!!!!!!!! WARNING !!!!!!!!!!
You are using an untrusted SSL certificate. This certificate will not be
trusted by Bitwarden client applications. You must add this certificate to
the trusted store on each device or else you will receive errors when trying
to connect to your installation.
Building nginx config.
Building docker environment files.
Building docker environment override files.
Building FIDO U2F app id.
Building docker-compose.yml.
Installation complete
If you need to make additional configuration changes, you can modify
the settings in `./bwdata/config.yml` and then run:
`./bitwarden.sh rebuild` or `./bitwarden.sh update`
Next steps, run:
`./bitwarden.sh start`
```
Once the installation has been completed, start the Bitwarden service with the following command:
```
./bitwarden.sh start
```
You can see all command line options with the following command:
```
./bitwarden.sh help
```
Output:
```
_ _ _ _
| |__ (_) |___ ____ _ _ __ __| | ___ _ __
| '_ \| | __\ \ /\ / / _` | '__/ _` |/ _ \ '_ \
| |_) | | |_ \ V V / (_| | | | (_| | __/ | | |
|_.__/|_|\__| \_/\_/ \__,_|_| \__,_|\___|_| |_|
Open source password management solutions
Copyright 2015-2020, 8bit Solutions LLC
https://bitwarden.com, https://github.com/bitwarden
===================================================
Docker version 19.03.12, build 48a66213fe
docker-compose version 1.25.0, build unknown
Available commands:
install
start
restart
stop
update
updatedb
updaterun
updateself
updateconf
renewcert
rebuild
help
```
## Step 4 : Access Bitwarden
Now, open your web browser and access the Bitwarden using the URL http://your-server-ip. You should see the Bitwarden login screen:
Click on the **Create** **account** button. You should see the following screen:
Provide your email address, name, and master password, then click on the **Submit** button. You should see the Bitwarden login screen:
Provide your email address and password and click on the **Log** **in** button. You should see the Bitwarden dashboard in the following screen:
## Conclusion
Congratulations! You have successfully installed the Bitwarden password manager on Ubuntu 20.04 server. I hope this will helps you to store, manage, and sync your password across all devices. Try using Bitwarden with your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
Learn more about our [VPS hosting](https://www.atlantic.net/vps-hosting/) services and [Virtual private servers.](https://www.atlantic.net/vps-hosting/)
---
# How to Install Cockpit on Debian
> URL: https://www.atlantic.net/vps-hosting/how-to-install-cockpit-on-debian/ | Published: 2020-08-28 | Updated: 2025-09-03 | Author: Hitesh Jethva
Cockpit is a free and open-source remote management software sponsored by Red Hat. It provides a web-based interface to manage and monitor a Linux-based server through a web browser. It runs on several operating systems, including Debian, Ubuntu, CentOS, Fedora, RHEL, and Arch Linux. With Cockpit, you can perform server management tasks remotely, such as manage services, create user accounts, monitor system, configure networks, inspect log, system update, manage firewall, domain management, setup OpenVPN, and many more. It also supports Kubernetes and Openshift cluster. Cockpit also provides graphs and easy-to-use forms to measure system performance and make changes to your systems.
In this tutorial, we will explain how to install Cockpit on Debian 12.
## Step 1 – Install Cockpit
By default, Cockpit is available in the Debian 12 default repository. You can install it by simply running the following command:
```
apt-get update -yapt-get install cockpit -y
```
Once Cockpit is installed, start the Cockpit service and enable it to start at system reboot with the following command:
```
systemctl start cockpit
systemctl enable cockpit
```
You can also verify the status of Cockpit with the following command:
```
systemctl status cockpit
```
You should get the following output:
```
● cockpit.service - Cockpit Web Service
Loaded: loaded (/lib/systemd/system/cockpit.service; static; vendor preset: enabled)
Active: active (running) since Tue 2025-08-28 05:57:44 UTC; 3s ago
Docs: man:cockpit-ws(8)
Process: 30466 ExecStartPre=/usr/sbin/remotectl certificate --ensure --user=root --group=cockpit-ws --selinux-type= (code=exited, status=0/SU
Main PID: 30469 (cockpit-ws)
Tasks: 2 (limit: 2359)
Memory: 2.2M
CGroup: /system.slice/cockpit.service
└─30469 /usr/lib/cockpit/cockpit-ws
Aug 28 05:57:44 debian12 systemd[1]: Starting Cockpit Web Service...
Aug 28 05:57:44 debian12 remotectl[30466]: Generating temporary certificate using: sscg --quiet --lifetime 3650 --key-strength 2048 --cert-key-
Aug 28 05:57:44 debian12 remotectl[30466]: Error generating temporary dummy cert using sscg, falling back to openssl
Aug 28 05:57:44 debian12 remotectl[30466]: Generating temporary certificate using: openssl req -x509 -days 36500 -newkey rsa:2048 -keyout /etc/
Aug 28 05:57:44 debian12 systemd[1]: Started Cockpit Web Service.
Aug 28 05:57:44 debian12 cockpit-ws[30469]: Using certificate: /etc/cockpit/ws-certs.d/0-self-signed.cert
```
## Step 2 – Access Cockpit Web Interface
At this point, Cockpit is installed and listening on port 9090. You can verify the listening port with the following command:
```
apt install net-tools -y
netstat -tunelp | grep 9090
```
You should see the following output:
```
tcp6 0 0 :::9090 :::* LISTEN 0 192987 1/init
```
Next, create a dedicated administrative user using the below command:
```
adduser adminuser
```
Set your password as shown below:
```
Adding user `adminuser' ...
Adding new group `adminuser' (1000) ...
Adding new user `adminuser' (1000) with group `adminuser (1000)' ...
Creating home directory `/home/adminuser' ...
Copying files from `/etc/skel' ...
New password:
Retype new password:
passwd: password updated successfully
```
Add your user to sudo group.
```
usermod -aG sudo adminuser
```
Now, open your web browser and access the Cockpit web UI using the URL **https://your-server-ip:9090.** You will be redirected to the Cockpit web interface as shown below:
Provide your username and password, and click on the **Log** **in** button. You should see the Cockpit dashboard in the following screen:
In the above screen, you should see the summary of your system information and performance graphs for CPU, Memory, Disk I/O, and network traffic.
## Step 3 – How to Use Cockpit
In this section, we will show you how to use Cockpit web interface.
In the left pane, you should see a lot of useful options.
In the left pane, click on the **Logs** menu. You should see the logs page which allows for logs inspection.
The **Storage**menu provides a summary of the system disk, partition, and file system as shown below:
The **Networking**menu provides network interface, IP address, and traffic information. You can also add Bond, Bridge, and VLAN using this menu.
With the **Services**menu, you can see Targets, System Services, Sockets, Timers, and Paths pages. You can also manage system services using this menu.
The **Terminal**menu provides a command-line interface to execute commands in your system.
## Conclusion
In this guide, you learned how to install and use Cockpit on Debian 12. This tool is very useful for Linux beginners who don’t know the command-line and helps you to control a Linux server through a web interface. Get started with Cockpit on your Linux server on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install and Configure Parse Server on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-configure-parse-server-on-ubuntu-20-04/ | Published: 2020-09-01 | Updated: 2024-09-25 | Author: Hitesh Jethva
Parse Server is a free and open-source Backend-as-a-Service platform developed by Facebook. It is written in Node.js and can be used for any application running Node.js. Parse Server comes with a simple and easy-to-use web interface that can be used for data manipulation, to view analytics, and to schedule and send push notifications.
In this tutorial, we will show you how to install Parse Server on Ubuntu 20.04.
## Step 1 – Install MongoDB
By default, MongoDB is available in the Ubuntu 20.04 default repository. You can install it by running the following command:
```
apt-get install mongodb-server -y
```
Once the MongoDB is installed, you can verify the status of MongoDB with the following command:
```
systemctl status mongodb
```
You should see the following output:
```
● mongodb.service - An object/document-oriented database
Loaded: loaded (/lib/systemd/system/mongodb.service; enabled; vendor preset: enabled)
Active: active (running) since Thu 2020-08-06 07:32:44 UTC; 30s ago
Docs: man:mongod(1)
Main PID: 3222 (mongod)
Tasks: 23 (limit: 4691)
Memory: 42.0M
CGroup: /system.slice/mongodb.service
└─3222 /usr/bin/mongod --unixSocketPrefix=/run/mongodb --config /etc/mongodb.conf
Aug 06 07:32:44 ubuntu2004 systemd[1]: Started An object/document-oriented database.
```
## Step 2 – Install Node.js
First, install the necessary dependencies using the following command.
```
apt-get install -y ca-certificates curl gnupg
```
Next, download the Node.js GPG key.
```
mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
```
Next, add the NodeSource repo to the APT source list.
```
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_18.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
```
Then, update the repository index and install the Ndoe.js with the following command.
```
apt update
apt-get install -y nodejs
```
Next, verify the Node.js version using the following command.
```
node -v
```
Output.
```
v18.19.0
```
## Step 3 – Install Parse Server
You can install the parse-server module using the Yarn package manager as shown below:
```
yarn global add parse-server
```
Once installed, you will need to create a parse server configuration file and define the attributes of the parse server. You can create it with the following command:
```
nano config.json
```
Add the following lines:
```
{
"appName": "My Parse Server",
"databaseURI": "mongodb://localhost:27017/parsedb",
"appId": "KSDJFKASJFI3S8DSJFDH",
"masterKey": "LASDK823JKHR87SDFJSDHF8DFHASFDF",
"serverURL": "https://localhost:1337/parse",
"publicServerURL": "https://0.0.0.0:1337/parse",
"port": 1337
}
```
Save and close the file then start the parse server using the following command:
```
nohup parse-server config.json &
```
At this point, the parse server is started and listening on port 1337. You can verify it with the following command:
```
ss -ant | grep 1337
```
You should get the following output:
```
LISTEN 0 511 0.0.0.0:1337 0.0.0.0:*
TIME-WAIT 0 0 127.0.0.1:1337 127.0.0.1:40568
```
## Step 4 – Configure Parse Server Dashboard
Parse server comes with a powerful dashboard that allows you to access the Parse server through a web browser. You can install the parse dashboard with the following command:
```
yarn global add parse-dashboard
```
After installing the Parse dashboard, create a configuration file for the Parse dashboard with the following command:
```
nano parse-darshboard-config.json
```
Add the following lines:
```
{
"apps": [
{
"serverURL": "http://your-server-ip:1337/parse",
"appId": "KSDJFKASJFI3S8DSJFDH",
"masterKey": "LASDK823JKHR87SDFJSDHF8DFHASFDF",
"allowInsecureHTTP": "true",
"appName": "MyApp1"
}
],
"users": [
{
"user":"admin",
"pass":"yourpassword"
}
],
"iconsFolder": "icons"
}
```
Save and close the file, then start the Parse dashboard with the following command:
```
nohup parse-dashboard --dev --config parse-darshboard-config.json &
```
At this point, the Parse dashboard is started and listening on port 4040. You can verify it with the following command:
```
ss -ant | grep 4040
```
You should get the following output:
```
LISTEN 0 511 0.0.0.0:4040 0.0.0.0:*
```
## Step 5 – Verify Parse Server
At this point, the Parse server is installed and configured. Now, perform some tests to make sure it’s running.
First, add some values to the Parse server with the following command:
```
curl -X POST -H "X-Parse-Application-Id: KSDJFKASJFI3S8DSJFDH" -H "Content-Type: application/json" -d '{"score":1337,"InventoryName":"Desktops","cheatMode":false}' http://localhost:1337/parse/classes/Inventory
```
You should get the following output:
```
{"objectId":"BCq9j8fPfM","createdAt":"2020-08-06T07:48:14.530Z"}
```
Now, fetch the value from the Parse server using the following command:
```
curl -X GET -H "X-Parse-Application-Id: KSDJFKASJFI3S8DSJFDH" http://localhost:1337/parse/classes/Inventory/BCq9j8fPfM
```
You should get the following output:
```
{"objectId":"BCq9j8fPfM","score":1337,"InventoryName":"Desktops","cheatMode":false,"createdAt":"2020-08-06T07:48:14.530Z","updatedAt":"2020-08-06T07:48:14.530Z"}
```
## Step 6 – Access Parse Server Dashboard
You can also access the parse server dashboard by visiting the URL http://your-server-ip:4040 in your web browser. You should see the following screen:
Provide your admin username and password which you have defined in the Parse dashboard configuration file and click on the **Log** **in** button. You should see the Parse server dashboard in the following screen:
## Conclusion
In this guide, you learned how to install Parse Server and Parse Dashboard in Ubuntu 20.04 server. You can now build your mobile application’s backend with Parse Server on a [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# Hybrid Hosting – One Size Does Not Fit All
> URL: https://www.atlantic.net/hipaa-compliant-hosting/hybrid-hosting-one-size-not-fit/ | Published: 2020-09-11 | Updated: 2025-09-19 | Author: Kent Roberts
A hosting service provider may tend to focus more on standardized packages or on its ability to customize and provide highly specialized service on a case-by-case basis. When a provider is known for its central attention to customization and creating unique systems to meet the challenges of organizations one at a time, they will often have to find ways to problem-solve sophisticated technical issues of their clients.
Again, customization of solutions should not be a standard expectation. Often a company will sell simplified one-size-fits-all plans or will simply offer external server management. On the other hand, a company with a broad array of customizable solutions will offer a range of services that could include dedicated servers and nodes, public cloud, private cloud, and colocation, along with managed services – all of which can be ingredients of a hybrid hosting setup.
## Examples of Hybrid Hosting Solutions
In terms of different types of situations that benefit from a customized approach, here are a few:
A company will often want to improve its cost savings, security, and efficiency by transitioning to a cloud environment from an internal data center, colocation setup, or hosted servers. These customers might need services that will handle migration and management of the system, along with the infrastructure services that will allow them the raw resources to run their workloads and support to maintain their systems.
An organization might run an advertising demand-side platform (DSP) or other type of online ad network with very specific stipulations in terms of their IT space. They will have to find an environment that gives them incredible memory, processing, and network connectivity performance. At the same time, they need to be conscientious about cost since they do not have big margins with which to work. An organization of that type will generally want to use a public cloud plan along with some sort of private cloud. These two types of systems may or may not be fully integrated with one another by the provider.
A hosting client might need to have the strongest possible security mechanisms and protocols in place. These elements might include **two-factor authentication** (2FA), **firewalls**, and **encrypted backup**. Often the companies that will need this degree of security are those concerned with compliance – as is typical of healthcare organizations. A fully compliant setting can be provided by a host that has a properly designed system within public cloud; note that there should be total isolation of data and compute to allow for the greatest possible organizational control and agility.
One other type of company for which a hybrid setup is useful is an aviation business that specializes in flight controls. A firm of this type might want to use colocation services in order to maintain full control of the aspect of the system that they want to run through equipment they own. For the rest of their infrastructure, though, these companies will often choose to spin up servers on Public Cloud, allowing them to avoid a large initial expense and ongoing maintenance.
## Priority #1 – Security
For many organizations, especially those in highly regulated industries such as healthcare, data security is the first priority. When security is a paramount concern, firms want to know the best practices in terms of storing something in a private cloud vs. a public one.
However, a high-quality hosting provider will have a [data center](https://www.atlantic.net/hipaa-data-centers/) audited to meet the exacting parameters of the Service Organization Control Reports ([SOC 1 and SOC 2](https://www.aicpa.org/interestareas/frc/assuranceadvisoryservices/downloadabledocuments/faqs_service_orgs.pdf)), formulated within the Statement on Standards for Attestation Engagements No. 18 (SSAE 18), a standard developed by the American Institute of Certified Public Accountants (AICPA). Called “Reporting on Controls at a Service Organization,”
SSAE 16 is a highly respected set of guidelines used for auditing purposes, to check for appropriate security safeguards and other best-practice accounting and monitoring controls. The effort and expense required to get this voluntary certification is an indicator that a host cares about data safety, and that it wants to prove it.
Within an SSAE 16 compliant setting, backed by a hosting provider with years in the industry, anyone using the hybrid hosting provider should feel confident that they can get secure solutions in the full range of environments – dedicated servers and private cloud, [as well as public cloud](https://urldefense.proofpoint.com/v2/url?u=https-3A__www.atlantic.net_hipaa-2Dcompliant-2Dhosting_how-2Dsecure-2Dis-2Dthe-2Dcloud_&d=DQIGaQ&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A_CdpgnVfiiMM&r=UChi3C1F2KzF3gDdKeDIWT0Y2FVnGxMftp5efqLBa9U&m=WeBwqR0vC2QPmHQe1L_HqvKB4WvOk9cwp4FMsQLtHmc&s=zl-KJ8gy3EUWCiMwkRiZ_wJ3JUyTnQtBDO7Ih_qycNQ&e=). Since many thought leaders have suggested recently that cloud might even outdo on-premise from a raw security perspective, more companies are transitioning their systems to cloud, including test environments. At many companies, very little of the infrastructure is now maintained internally.
## Choosing a Hybrid Host
The challenge with setting up a customized solution is that it is, by its nature, unique. Setting up environments in this manner requires engineering skill and an environmental culture of flexibility. Specifically in terms of networking, you want an organization that commonly utilizes technologies such as virtual private networks (VPNs) and multi-protocol label switching (MPLS) so that communications can occur through standardized security protocols.
Are you looking for a hybrid host? At Atlantic.Net, we have a lot of flexibility and go as far as the client requires, with customized solutions configured to individual specifications, including [HIPAA Managed Hosting](https://www.atlantic.net/hipaa-compliant-hosting/). We are audited to meet SOC 1 and SOC 2 for broad SSAE 18 compliance, and offer years of networking and connectivity experience, having originally formed as an internet service provider (ISP).
### Atlantic.Net Hybrid Hosting Services
One size does not fit all and we understand that. Do you already have an extensive IT infrastructure in place? Are you simply looking to store a bit of data offsite? Atlantic.Net can help in both situations, with our custom Hybrid Hosting.
### Extend Your IT Infrastructure
We put our vast experience in connectivity and advanced computing to use, to help provide our clients with unique, powerful and flexible hosting options. Below are some scenarios, where Atlantic.Net can assist but you’re also free to mix and match:
- Dedicated Virtualization in combination with an existing Atlantic.Net Hosting Solution.
- Dedicated Virtualization in tandem with server colocation at a data center of your choice.
- Secondary dedicated hosting platform established in parallel to an existing cloud environment.
- Virtualization Hosting in combination with existing computing solutions elsewhere.
- On-site and off-site private virtualization, combined for a robust hybrid hosting infrastructure.
- Cloud in combination with the Atlantic.Net Hosting Solution of your choice.
- Cloud in tandem with server colocation at our data center or a data center of your choice.
- Secondary cloud hosting platform established in parallel to an existing cloud.
- Cloud Solutions in combination with existing computing solutions elsewhere.
- On-site and off-site private and public clouds, combined for a robust hybrid hosting infrastructure.
With Hybrid Hosting, you’ll have the best of both worlds – tremendous savings and the ability to enjoy the latest, dedicated, secure, and robust hosting platform. And with Atlantic.Net, you’ll have a host with all the expertise necessary to enable you to get the most out of hybrid hosting. Count on it.
With our hybrid solutions for your team, Atlantic.Net outperforms the competition. Along with the highly redundant hosting solutions, Atlantic.Net also provides a wide array of managed services, including backup as a service, firewall as a service, security as a service, and more. If you have any questions about Atlantic.Net’s Hybrid Solutions, please call 866-618-DATA or email [sales@atlantic.net](mailto:sales@atlantic.net) for a free evaluation of your environment to see how Atlantic.Net can help you today!
---
# Replace Your Physical Tape Backups with Atlantic.Net Cloud Backups and Save
> URL: https://www.atlantic.net/dedicated-server-hosting/replace-your-physical-tape-backups-with-atlantic-net-cloud-backups-and-save/ | Published: 2020-09-14 | Updated: 2025-09-19 | Author: Richard Bailey
Tape backup technology became popular in the early 1960s. IBM pioneered the technology, creating the first tape libraries and introducing tape media for data backup into the public domain.
Today, many organizations, governments, and professional institutions still rely on tape backup for legacy systems; however, the use of tapes is rapidly declining. This decline has been hastened by the surge in cloud computing, with many tech firms adopting flexible cloud backup solutions.
Atlantic.Net has various backup solutions available; all of our Cloud solutions are underpinned by a managed [cloud backup service](https://www.atlantic.net/cloud-platform/backups/). This is a flexible service that can be enabled with the click of a mouse. For our Managed Hosting and [Dedicated Server Hosting](https://www.atlantic.net/dedicated-server-hosting/) customers, we can provide a fully managed [Veeam Backup solution](https://www.atlantic.net/managed-services/veeam-services/) and also a proprietary Atlantic.Net Cloud Platform (ACP) Backups.
## What is Cloud Backup?
Atlantic.Net’s Cloud Backups are a fully automated, flexible service that is surprisingly easy to set up; for the Atlantic.Net Cloud Platform (ACP) Backups, you only have to press a checkbox when building a Virtual Machine or when adding a backup to an existing Atlantic.Net VM. Cloud Backups enables File-Level Recovery as well as Full System Restore capabilities.
Optional ACP Offsite Backups are protected offsite using the latest offsite backup technology. Did you know that you can even take a separate snapshot of a server and export it to another Atlantic.Net location, or recover the snapshot onto a brand new VM? ACP Snapshots are great when upgrading your server, as they offer a working rollback option.
## What is a Managed Veeam Service?
Veeam is a highly versatile agent-based backup solution that works incredibly well with both Virtual Machines and Physical Hosts. Veeam can back up entire environments and restore data into sandbox locations for testing. The service offers significant savings, as we onboard you to our licensing model, meaning significantly less financial outlay when compared with creating your own Veeam solution.
The incremental forever backups are super-fast and very lightweight, and recovery is lightning-quick and bulletproof, as each backup is validated for integrity prior to being marked successful. Veeam can snapshot data and replicate critical datasets to an alternative Atlantic.Net location.
## Why Replace Your Tape Backups?
Tape libraries are hugely expensive to buy, maintain, license, and replace if a fault occurs. Tape media is pricey, and its capacity may be considered too small for modern enterprise workloads. Tape libraries have limited scalability, as each library can only expand to a predefined number of tape drives. If you run out of drives, you need to purchase an entirely new library and pool resources.
Tape read and write access speeds are also considered very slow, and tape backups are inefficient as they can often span multiple tapes, resulting in slow media inventories when attempting to restore a backup set from tape.
The tape media degrades over time and can easily become damaged, especially if dropped by mistake. There is a lot of manual effort needed to accurately track tape rotations, and tapes are prone to getting stuck in the tape drive mechanism, often requiring an on-site engineer to fix.
## What are the Advantages of a Managed Backup Service?
Atlantic.Net Cloud Backup solutions don’t have the problems with efficiency, fragility, and cost that tape backups have. They are fully managed services, meaning that you do not need to worry about the backend systems; Atlantic.Net will look after all of that. Our solutions are disk-based, and our locations are interconnected using rapid network connectivity for seamless data transfer.
Another major problem with tape backups is the day-to-day management of the tape media. Skilled media administrators are difficult to find, and tape rotations are very difficult to manage accurately unless sophisticated tape handling processes are defined or expensive tape management software is used.
These complexities can result in human error, potentially resulting in missed backups or incorrectly following the backup rotation policy. All of these limitations make it very easy to lose track of tapes or miss key backup schedules, such as month- or year-end backups, and mismanagement of tape backups can create issues such as the wrong backup tapes being sent to offsite storage.
Again, with a managed backup service from Atlantic.Net, these problems go away. Our highly trained backup specialists monitor, manage, and maintain all our backup platforms 24x7x365.
### Getting Started with Cloud Backups
We are proud to welcome you to the Atlantic.Net [Cloud Backups service](https://www.atlantic.net/cloud-platform/backups/) and the [Veeam Managed Service](https://www.atlantic.net/managed-services/veeam-services/). Both are designed to protect your critical data in the cloud and eliminate the problems of inefficiency created by tape backups.
There are significant advantages to embracing cloud backup and save technology. You can transfer your infrastructure to our cloud backup storage, ensuring you have the critical restore points needed for your organization’s disaster recovery and data retention requirements.
The technology provides multiple opportunities for cost savings, including an OPEX cost model that only charges our customers for what they use on a pay-as-you-go basis. Cost savings can be recovered by saving on the manpower needed to manage the backup solution, as this responsibility is managed by Atlantic.Net; you can rest assured that all your critical data is backed up as per the terms of our SLA agreement, leaving you the time to concentrate on your core business.
The Cloud Backup solution utilizes an advanced agentless technology that uses none of the customer’s system resources, and industry-leading deduplication technology drastically cuts bandwidth utilization and reduces overall storage costs.
Data is saved on the Atlantic.Net proprietary cloud storage solution; this custom-designed technology offers immense flexibility, usability, and accessibility. Best of all, we can ingest huge quantities of data into the cloud storage without restriction. The storage provides fault tolerance, redundancy, and data replication capabilities between your choice of 8 data center locations.
## Cloud Archiving
Our existing customers enjoy an agile cloud solution that provides secure storage of business-critical data in their preferred location. Cloud archiving is a non-disruptive service where the only prerequisite is network connectivity.
Some of our clients choose to operate the service over their existing network circuits, while others decide to purchase additional dedicated backup circuits for more intense workloads. Our customers can utilize their existing trusted backup software as part of this service if required.
Cloud Archiving streamlines the entire backup process, reduces costs, and provides our clients with class-leading service level agreements for data retrieval. The customer systems can remain on-premise, as the data is transferred to the Atlantic.Net storage solutions.
Gone are the days of painstakingly slow restore requests, managing the process of recalling tapes, or waiting for the tapes to be located or couriered to site; instead, data is available near-instantly and on-demand, and there is no need to wait hours, days, weeks for data recovery.
Ready to get started with Atlantic.Net [Cloud Backups](https://www.atlantic.net/cloud-platform/backups/) and [Veeam Managed Service](https://www.atlantic.net/managed-services/veeam-services/)? Contact Atlantic.Net today and we’ll help you take advantage of our easy-to-use backups, and can help you with a plan to transfer your data from your legacy tape backup system to our environment!
---
# How to Install Ansible AWX on Debian 10
> URL: https://www.atlantic.net/vps-hosting/how-to-install-ansible-awx-on-debian-10/ | Published: 2020-09-17 | Updated: 2023-11-17 | Author: Hitesh Jethva
Ansible is a free and open-source configuration management and automation tool used to manage hundreds and thousands of servers from a central location.
Ansible AWX is an open-source project, sponsored by Red Hat, that helps you control Ansible in IT environments. It provides a web-based interface REST API and task engine for Ansible. You can manage playbooks, secrets, inventories, and cron jobs using the AWX web-based interface.
In this tutorial, we will show you how to install Ansible AWX with Docker on Debian 10.
## Step 1 – Install Docker
First, you will need to install the Docker and Docker compose in your system. By default, the latest version of Docker is not available in the Debian standard repository, so you will need to add the Docker repository to your system.
Install the required dependencies with the following command:
```
apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common -y
```
Next, download and add the Docker GPG key with the following command:
```
curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
```
Next, add the Docker repository with the following command:
```
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
```
Next, update the Docker repository and install Docker with Docker compose using the following command:
```
apt-get update -y
apt-get install docker-ce docker-compose -y
```
Once both packages are installed, verify the installed version of Docker with the following command:
```
docker --version
```
You should get the following output:
```
Docker version 19.03.13, build 4484c46d9d
```
## Step 2 – Install Ansible
AWX is built on the top of the Ansible. so you will need to install Ansible in your system.
First, add the Ansible repository with the following command:
```
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 93C4A3FD7BB9C367
echo "deb http://ppa.launchpad.net/ansible/ansible/ubuntu bionic main" | tee /etc/apt/sources.list.d/ansible.list
```
Next, update the repository and install the Ansible with the following command:
```
apt-get update -y
apt-get install ansible -y
```
Once the Ansible is installed, verify the installed version of Ansible using the following command:
```
ansible --version
```
You should get the following output:
```
ansible 2.9.13
config file = /etc/ansible/ansible.cfg
configured module search path = [u'/root/.ansible/plugins/modules', u'/usr/share/ansible/plugins/modules']
ansible python module location = /usr/lib/python2.7/dist-packages/ansible
executable location = /usr/bin/ansible
python version = 2.7.16 (default, Oct 10 2019, 22:02:15) [GCC 8.3.0]
```
## Step 3 – Install Nodejs and Python Library
First, install the Node.js, NPM and Git with the following command:
```
apt-get install nodejs npm git -y
npm install npm --global
```
Next, install the Python module for Docker and other required dependencies with the following command:
```
apt-get install python3-pip pwgen python3-docker -y
pip3 install requests==2.14.2
```
Next, update the default Python version with the following command:
```
update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
update-alternatives --install /usr/bin/python python /usr/bin/python3 2
```
Next, you will need to install Docker compose Python module in your system.
First, check the installed version of Docker compose with the following command:
```
docker-compose version
```
You should get the following output:
```
docker-compose version 1.21.0, build unknown
docker-py version: 3.4.1
CPython version: 3.7.3
OpenSSL version: OpenSSL 1.1.1d 10 Sep 2019
```
Next, installed the matching version of Docker compose Python module with the following command:
```
pip3 install docker-compose==1.21.0
```
## Step 4 – Install Ansible AWX
First, download the latest version of AWX source from the Git repository using the following command:
```
git clone --depth 50 https://github.com/ansible/awx.git
```
Once downloaded, change the directory to awx and generate the secrete key with the following command:
```
cd awx/installer/
pwgen -N 1 -s 30
```
You should get the following output:
```
4NaNkNcMBOj4Jxp4fWi91mymuW9TbR
```
Next, create a new inventory file with the following command:
```
nano inventory
```
Add the following lines including, admin user, password, secret key, port, and hostname as shown below:
```
dockerhub_base=ansible
awx_task_hostname=awx
awx_web_hostname=awxweb
postgres_data_dir=/tmp/pgdocker
host_port=80
host_port_ssl=443
docker_compose_dir=/tmp/awxcompose
pg_username=awx
pg_password=awxpass
pg_database=awx
pg_port=5432
admin_user=admin
admin_password=adminpassword
create_preload_data=True
secret_key=2fCkx2K5GnIjBz4OterhOC3ey0WPdj
```
Save and close the file when you are finished.
Next, run the playbook to install the Ansible AWX with the following command:
```
ansible-playbook -i inventory install.yml
```
Once the Ansible AWX has been installed, you should get the following output:
```
TASK [local_docker : Create Docker Compose Configuration] *************************************************************************************
changed: [localhost] => (item={u'mode': u'0600', u'file': u'environment.sh'})
changed: [localhost] => (item={u'mode': u'0600', u'file': u'credentials.py'})
changed: [localhost] => (item={u'mode': u'0600', u'file': u'docker-compose.yml'})
changed: [localhost] => (item={u'mode': u'0600', u'file': u'nginx.conf'})
changed: [localhost] => (item={u'mode': u'0664', u'file': u'redis.conf'})
TASK [local_docker : Render SECRET_KEY file] **************************************************************************************************
changed: [localhost]
TASK [local_docker : Start the containers] ****************************************************************************************************
changed: [localhost]
TASK [local_docker : Update CA trust in awx_web container] ************************************************************************************
changed: [localhost]
TASK [local_docker : Update CA trust in awx_task container] ***********************************************************************************
changed: [localhost]
PLAY RECAP ************************************************************************************************************************************
localhost : ok=15 changed=7 unreachable=0 failed=0 skipped=86 rescued=0 ignored=0
```
Next, you can verify the list of running containers using the following command:
```
docker ps
```
You should get the following output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
167d008ee26f ansible/awx:14.1.0 "/usr/bin/tini -- /u…" About a minute ago Up About a minute 8052/tcp awx_task
260c028bf07d ansible/awx:14.1.0 "/usr/bin/tini -- /b…" About a minute ago Up About a minute 0.0.0.0:80->8052/tcp awx_web
e15d5ee1c940 postgres:10 "docker-entrypoint.s…" About a minute ago Up About a minute 5432/tcp awx_postgres
6472ee690066 redis "docker-entrypoint.s…" About a minute ago Up About a minute 6379/tcp awx_redis
```
## Step 5 – Access Ansible AWX Dashboard
Now, open your web browser and access the Ansible AWX dashboard using the URL **http://your-server-ip**. You will be redirected to the AWX login page:
Provide your admin username and password that you have defined in the inventory file and click on the **SIGN** **IN** button. You should see the Ansible AWX dashboard on the following page:
## Conclusion
Congratulations! You have successfully installed Ansible AWX with Docker on Debian 10. You can now easily control Ansible inventory, secrets, playbooks, and more from the AWX dashboard; try it now on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install ArangoDB on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-arangodb-on-ubuntu-20-04/ | Published: 2020-09-18 | Updated: 2024-09-25 | Author: Hitesh Jethva
ArangoDB is a free, open-source NoSQL database with a flexible data model for documents, graphs, and key-values. It is a multi-purpose and multi-model database developed by triAGENS GmbH. ArangoDB comes with a simple and easy-to-use web interface and CLI for managing and monitoring databases. It is used in small and large organizations that process large amounts of data. ArangoDB is designed for high-performance and scalable applications that use SQL-like query language.
In this tutorial, we will explain how to install the ArangoDB database on Ubuntu 20.04.
## Step 1 – Install ArangoDB
By default, ArangoDB is not available in the Ubuntu 20.04 default repository, so you will need to add the ArangoDB repository to your system.
First, install some required dependencies using the following command-
```
apt-get install gnupg2 apt-transport-https -y
```
Once all the dependencies are installed, import the ArangoDB GPG key and add the repository with the following command:
```
wget -q https://download.arangodb.com/arangodb34/DEBIAN/Release.key -O- | apt-key add -
echo 'deb https://download.arangodb.com/arangodb34/DEBIAN/ /' | tee /etc/apt/sources.list.d/arangodb.list
```
Next, update the repository and install the ArangoDB with the following command:
```
apt-get update -y
apt-get install arangodb3 -y
```
During the installation, you will be asked to set the root password as shown below:
Provide your desired password and hit **OK** button. You should see the following page:
Re-enter the password and hit **OK**. You should see the following page:
Click on the **OK** button to automatically upgrade database files. You should see the following page:
Select the database storage engine and hit the **Ok** button. You should see the following page:
Click on the **Yes** button to back up the database before upgrading.
Once the installation has been completed, start the ArangoDB service and enable it to start at system reboot with the following command:
```
systemctl start arangodb3
systemctl enable arangodb3
```
## Step 2 – Connect ArangoDB Shell
ArangoDB comes with a command-line utility to manage the databases. You can connect the ArangoDB shell with the following command:
```
arangosh
```
You will be asked to provide the password as shown below:
```
Please specify a password:
```
Provide the root password which you have set during the installation and hit enter. You should see the following output:
Now, create a database named mydb with the following command:
```
127.0.0.1:8529@_system> db._createDatabase("mydb");
```
Next, create a database user with the following command:
```
127.0.0.1:8529@_system> var users = require("@arangodb/users");
127.0.0.1:8529@_system> users.save("myuser@localhost", "password");
```
You should see the following output:
```
{
"user" : "myuser@localhost",
"active" : true,
"extra" : {
},
"code" : 201
}
```
Next, grant all the privileges to the mydb database with the following command:
```
127.0.0.1:8529@_system> users.grantDatabase("myuser@localhost", "mydb");
```
Now, you can list your databases using the following command:
127.0.0.1:8529@_system> db._databases()
You should see the following output:
```
[
"_system",
"mydb"
]
```
Now, exit from the ArangoDB shell with the following command:
```
127.0.0.1:8529@_system> exit
```
Now, verify the ArangoDB connection using the database and user which you have created earlier using the following command:
```
arangosh --server.username "myuser@localhost" --server.database mydb
```
You will be asked to provide password as shown below:
```
Please specify a password:
```
Provide the password of the myuser and hit Enter. You should see the following output:
Now, exit from the ArangoDB shell with the following command:
```
127.0.0.1:8529@_system> exit
```
## Step 3 – Access ArangoDB Web Interface
ArangoDB comes with a web-based interface for managing and monitoring ArangoDB. By default, it is configured to access only from the localhost. So you will need to configure ArangoDB for external access. You can configure it by editing the file /etc/arangodb3/arangod.conf:
```
nano /etc/arangodb3/arangod.conf
```
Find the following line:
```
endpoint = tcp://127.0.0.1:8529
```
And replace it with the following line:
```
endpoint = tcp://your-server-ip:8529
```
Save and close the file, then restart the ArangoDB service to apply the changes.
```
systemctl restart arangodb3
```
Now, open your web browser and type the URL http://your-server-ip:8529. You should see the ArangoDB login page:
Provide your ArangoDB root username and password and click on the Login button. You should see the ArangoDB dashboard in the following page:
## Conclusion
In this tutorial, you learned how to install ArangoDB on Ubuntu 20.04. You also learned how to user ArangoDB shell to create a database and user. ArangoDB is a very good alternative to MongoDB and can be used in a mission-critical environment. Get started with ArangoDB on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# Best Practice for Creating a HIPAA-Compliant LAMP Stack
> URL: https://www.atlantic.net/hipaa-compliant-hosting/best-practice-for-creating-a-hipaa-compliant-lamp-stack/ | Published: 2020-09-21 | Updated: 2025-09-19 | Author: Richard Bailey
A LAMP stack is a collection of applications that work seamlessly together to create a powerful open-source web server. The application stack is not only completely free, but also unbelievably powerful and highly customizable, both of which make it a popular choice for developers.
**Why is it called LAMP?**
- **L**inux is the base operating system used on the server.
- **A**pache is the most popular web server used today, powering about 37% of all websites.
- **M**ySQL (or MariaDB) is a relational database application that is perfect for storing website data.
- **P**HP is a highly adaptable scripting language that is especially suited to web development.
One of the best things about a LAMP stack is its ease of deployment. The one-click application is our recommended deployment method, but if you want to give it a try yourself you can:
> **Did you know?**
>
> Atlantic.Net has a one-click application that spins up an Ubuntu LAMP stack in under 30 seconds.
## How to secure a HIPAA-compliant LAMP stack
Any LAMP stack that will host or process Protected Health Information (PHI) must adhere to the administrative, physical, and technical safeguards of HIPAA to ensure the confidentiality of data uploaded or made available through a website or application.
## Linux – Hardening the Operating System
If you are a relative newcomer to Linux, Atlantic.Net recommends you let our [one-click LAMP application](https://cloud.atlantic.net/?page=signup) handle the deployment for you. However, if you want to take the plunge and try it yourself, here is what you need to do:
- Update the operating system monthly
- Utilize the built-in hard drive encryption tools
> **Did you know?**
>
> Two of the best filesystem encryption tools are [eCryptfs](https://launchpad.net/ecryptfs)and [EncFS](https://github.com/vgough/encfs).
>
> Two of the best block level (disk) encryption tools are [DMCrypt](https://gitlab.com/cryptsetup/cryptsetup) and [VeraCrypt](https://www.veracrypt.fr/en/Home.html).
- Only use very strong passwords, and never reuse passwords throughout the LAMP stack
- Only use sFTP encryption to transfer files to and from the webserver
- Update file permissions so that no user can change or modify files
- Ensure no system services or applications run as the root user
> **Did you know?**
>
> You can set up a cron job to *chown*and *chmod*files every night as a scheduled task. This helps with preventing user error and correcting careless mistakes when updating web server files.
## Apache Security Tips
- Keep Apache up-to-date
- Configure Apache to increase DDOS (denial of service) protection level
> **Did you know?**
>
> Editing the httpd.conf file and reducing the *RequestReadTimeout*, *Timeout*, *KeepAliveTimeout*, and *MaxRequestWorkers*thresholds will greatly improve DDOS protection.
- Set strict *chown*, *chmod*, and *chggrp*permissions on *ServerRoot Directories*; this will reduce the ability of a hacker to run arbitrary code
- Enforce TLS certificate encryption using *mod_ssl,*ensuring you use a strong cipher suite and OCSP stapling
- Implement dynamic content security
> **Did you know?**
>
> The Apache module [mod_security](https://www.modsecurity.org/) can be finely tuned as a HTTP firewall, perfect for dynamic content security.
- Protect system settings with .htaccess restrictions
- Protect access to service files
> **Did you know?**
>
> To enable this protection, add this to your httpd.conf:
>
> <**Directory** “/”> **AllowOverride** None
>
> <**Directory** “/”> **Require** all denied
## MySQL Best Practice
The database is where many users will save protected health information. There are strict regulatory compliance rules regarding the masking and de-identification of data, as well as encryption.
- Invoke MySQL Enterprise Data Masking and De-identification routines
> **Did you know?**
>
> A server-side plugin called *data_masking* can manage a SQL-Level API to perform masking and de-identification tasks on your data when it is used by an application.
- Data must be encrypted at rest
> **Did you know?**
>
> Atlantic.Net’s Cloud Platform is encrypted at rest with every server deployed by default, saving you time and effort from implementing encryption inside MySQL
- Enable SELinux for mandatory access controls to protect the MySQL daemon
- Implement MySQL plugins to authenticate users and restrict access by user, password, and approved IP address
- Enable MySQL Enterprise Audit plugin to enable standard, policy-based monitoring and logging of connection and query activity executed on the 8MySQL servers
## PHP Best Practice
PHP is a popular programming language used by websites to display enhanced content. PHP can either run as an Apache plugin or as a standalone CGI binary. No HIPAA legislation relates directly to PHP; instead, PHP must adhere to access and transmission security, and the browser connections must be secure.
- Ensure PHP is kept up-to-date
- Use PHP to hash and verify all passwords entered by users; BCrypt is included with PHP 7 onwards
> **Did you know?**
>
> Passwords can be hashed using the *password_hash* PHP function.
- Use PHP to enforce a user registration system and prevent access to unauthorized users
- Use PHP to protect against Cross-site scripting (XSS) and Request Forgery XSFR
> **Did you know?**
>
> You can protect against XSS and XSFR by sanitizing data input. The *htmlspecialchars()* and*htmlentities*functions prevent special characters that can hijack PHP code.
Ready to get started with setting up a HIPAA-Compliant LAMP Stack? Choose Atlantic.Net for a one-click LAMP installation that will set you well on your way to a [HIPAA-Compliant LAMP Server](https://www.atlantic.net/hipaa-compliant-hosting/) – get started today!
---
# Best Practice for Creating a HIPAA-Compliant LEMP Stack
> URL: https://www.atlantic.net/hipaa-compliant-hosting/best-practice-for-creating-a-hipaa-compliant-lemp-stack/ | Published: 2020-09-22 | Updated: 2025-09-19 | Author: Richard Bailey
A LEMP stack is a collection of applications that work seamlessly together to create a powerful open-source web server. Unlike a LAMP Stack, which uses Apache, a LEMP Stack is powered by Nginx (pronounced Engine-Ex, hence the E in LEMP).
Nginx is about 2.5x faster than Apache for high traffic websites with static content, so if you have a popular website that serves multiple concurrent connections, then Nginx is what you need. The stack is completely free, and Nginx has many additional modules built-in, including the popular reverse proxy.
> **Did you know?**
>
> Atlantic.Net has a 1-click application that spins up an Ubuntu LEMP stack in under 30 seconds.
## Best Practice to Secure a HIPAA-Compliant LEMP Stack
Any LEMP stack that will host or process Protected Health Information (PHI) must adhere to the administrative, physical, and technical safeguards of HIPAA to ensure the confidentiality of data uploaded or made available through a website or application.
> **Did you know?**
>
> You can automatically deploy a LEMP stack on the Atlantic Cloud Platform in less than 30 seconds using our 1-Click Applications. Visit [https://cloud.atlantic.net](https://cloud.atlantic.net/?page=userlogin) for further information.
## Linux – Hardening the Operating System
If you are a relative newcomer to Linux, Atlantic.Net recommends you let our [one-click LEMP application](https://cloud.atlantic.net/?page=userlogin) handle the deployment for you. However, if you want to take the plunge and try it yourself, here is what you need to do:
- Update the operating system monthly
- Utilize the built-in hard drive encryption tools
> **Did you know?**
>
> Two of the best filesystem encryption tools are [eCryptfs](https://launchpad.net/ecryptfs)and [EncFS](https://github.com/vgough/encfs).
>
> Two of the best block-level (disk) encryption tools are [DMCrypt](https://gitlab.com/cryptsetup/cryptsetup) and [VeraCrypt](https://www.veracrypt.fr/en/Home.html).
- Only use very strong passwords, and never reuse passwords within the LEMP stack
- Only use sFTP encryption to transfer files to and from the webserver
- Update file permissions so that no user can change or modify files
- Ensure no system services or applications run as the root user
> **Did you know?**
>
> You can set up a cron job to chownand chmodfiles every night as a scheduled task. This helps with preventing user error and correcting careless mistakes when updating web server files.
## Nginx Best-Practice Tips
- Ensure Nginx is updated regularly
- Obfuscate Nginx server information from the public
> **Did you know?**
>
> You can mask server information on Nginx by adding this to the Nginx.conf file:
>
> server_tokens off;
- Enforce HTTP Strict Transport Security (HSTS on TLS) to add a layer of encryption in communications
> **Did you know?**
>
> Enforcing HTTP Strict Transport Security means using HTTPS. You can enforce it by adding this to your ssl.conf:
>
> add_header Strict-Transport-Security “max-age=63072000; includeSubdomains; preload”;
- Disable deprecated SSL standards and weak cipher suites
- Disable unwanted modules to reduce the attack surface
- Enforce cross-site scripting (XSS) protection
> **Did you know?**
>
> XSS protection can be implemented by updating your ssl.conf file
>
> add_header X-XSS-Protection “1; mode=block”;
## MySQL Best Practice
The database is where many users will save protected health information. There are strict regulatory compliance rules regarding the masking and de-identification of data, as well as encryption.
- Invoke MySQL Enterprise Data Masking and De-identification routines
> **Did you know?**
>
> A server-side plugin called data_masking can manage a SQL-Level API to perform masking and de-identification tasks on your data when it is used by an application.
- Data must be encrypted at rest
> **Did you know?**
>
> Purekit for MariaDB is perfect for encrypting data at rest; it uses record layer encryption of the database, per-user encryption, and a zero-trust KMS.
- Enable SELinux for mandatory access controls to protect the MySQL daemon
- Implement MySQL plugins to authenticate users and restrict access by user, password, and approved IP address
- Enable MySQL Enterprise Audit plugin to enable standard, policy-based monitoring and logging of connection and query activity executed on the 8MySQL servers
## PHP Best Practice
PHP is a popular programming language used by websites to display enhanced content. PHP can either run as an Apache plugin or as a standalone CGI binary. No HIPAA legislation relates directly to PHP; instead, PHP must adhere to access and transmission security, and the browser connections must be secure.
- Ensure PHP is kept up-to-date
- Use PHP to hash and verify all passwords entered by users; BCrypt is included with PHP 7 onwards
> **Did you know?**
>
> Passwords can be hashed using the *password_hash* PHP function.
- Use PHP to enforce a user registration system and prevent access to unauthorized users
- Use PHP to protect against Cross-site scripting (XSS) and Request Forgery XSFR
> **Did you know?**
>
> You can protect against XSS and XSFR by sanitizing data input. The *htmlspecialchars()* and*htmlentities*functions prevent special characters that can hijack PHP code.
Ready to get started with setting up a HIPAA-Compliant LEMP Stack? Choose Atlantic.Net for a one-click LEMP installation that will set you well on your way to a [HIPAA-Compliant LEMP Server](https://www.atlantic.net/hipaa-compliant-hosting/) – get started today!
---
# Install and Configure DRBD on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/install-and-configure-drbd-on-centos-8/ | Published: 2020-09-23 | Updated: 2024-03-02 | Author: Hitesh Jethva
DRBD, also known as “Distributed Replicated Block Device,” is a distributed storage solution for Linux. It is used to mirror the data on block devices such as hard disks, partitions, and logical volumes from one server to another over a network connection. If one server crashed, then the data on the other could be used. DRBD also ensures high availability (HA) for Linux applications by networked mirroring.
In this tutorial, we will show you how to install DRBD and use it to replicate the partition between two servers.
## Prerequisites
- Two fresh CentOS 8 [VPS](https://www.atlantic.net/vps-hosting/) on the Atlantic.Net Cloud Platform with one block storage device attached to each VPS. The server must be created in USA-EAST1 (Orlando)
- A root password configured on both servers
## Step 1 – Setup Hostname on Each Node
First, you will need to set up a hostname on each node.
On the first node, run the following command to setup hostname.
```
hostnamectl set-hostname node1.example.com
```
On the second node, run the following command to setup hostname.
```
hostnamectl set-hostname node2.example.com
```
Once you are finished, you can proceed to the next step.
## Step 2 – Prepare Storage Device on Each Node
Next, you will need to set the same size storage device on each node for your DRBD resource. In this tutorial, we will use /dev/sdb block storage on each node.
On both nodes, create a GPT partition table and partition with the following command:
```
parted -s -a optimal -- /dev/sdb mklabel gpt
parted -s -a optimal -- /dev/sdb mkpart primary 0% 100%
parted -s -- /dev/sdb align-check optimal 1
```
Next, verify the partition with the following command:
```
fdisk -l
```
You should get the /dev/sdb1 partition in the following output:
```
Disk /dev/sda: 80 GiB, 85899345920 bytes, 167772160 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x7e9dbe13
Device Boot Start End Sectors Size Id Type
/dev/sda1 2048 167770112 167768065 80G 83 Linux
Disk /dev/sdb: 50 GiB, 53687091200 bytes, 104857600 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 4CBB1682-09B1-4785-B96C-2B9D2B3BEB53
Device Start End Sectors Size Type
/dev/sdb1 2048 104855551 104853504 50G Linux filesystem
```
## Step 3 – Install DRBD
**Important**: Repeat this process on both nodes.
By default, DRBD is not available in the CentOS standard repository, so you will need to install the EPEL repository in your system.
You can install it with the following command:
```
dnf -y install https://www.elrepo.org/elrepo-release-8.el8.elrepo.noarch.rpm
rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
```
Once the repository is installed, install the DRBD package with the following command:
```
dnf install drbd90-utils kmod-drbd90 -y
```
Once the installation is completed, you can proceed to the next step.
## Step 4 – Configure DRBD Resource
**Important**: Repeat this process on both nodes.
The default DRBD configuration file is located at /etc/drbd.conf, and other files are located inside /etc/drbd.d/ directory.
To replicate storage device between two servers, you will need to create a new configuration file inside /etc/drbd.d/ directory:
```
nano /etc/drbd.d/resource0.res
```
Add the following lines:
```
resource resource0 {
on node1.example.com {
device /dev/drbd1;
disk /dev/sdb1;
address node1-ip-address:7789;
meta-disk internal;
}
on node2.example.com {
device /dev/drbd1;
disk /dev/sdb1;
address node2-ip-address:7789;
meta-disk internal;
}
}
```
**Note**: The resource0.res is the same on both nodes.
Where:
- **node1.example.com** and **node2.example.com** are the hostnames of each node.
- **/dev/drbd1** is the name of the DRBD device.
- **/dev/sdb1** is the name of the storage device on each node.
- **Node1-ip-address** is the IP address of the first node.
- **Node2-ip-address** is the IP address of the second node.
- **7789** is the DRBD port.
Save and close the file when you are finished.
## Step 5 – Initialize and Enable DRDB Resource
Next, you will need to initialize DRBD’s metadata on both nodes.
Run the following command on both nodes to initialize the DRBD resource:
```
drbdadm create-md resource0
```
You should get the following output:
```
md_offset 53684989952
al_offset 53684957184
bm_offset 53683318784
Found ext3 filesystem
2097152 kB data area apparently used
52425116 kB left usable by current configuration
Even though it looks like this would place the new meta data into
unused space, you still need to confirm, as this is only a guess.
Do you want to proceed?
[need to type 'yes' to confirm] yes
initializing activity log
initializing bitmap (1600 KB) to all zero
Writing meta data...
New drbd meta data block successfully created.
success
```
After initializing the DRBD resource on both nodes, you will need to enable the resource.
Run the following command on both nodes to enable the resource.
```
drbdadm up resource0
```
This will attach the resource with its backing device; then, it sets replication parameters and connects the resource to its peer.
On the first node, check the status of the DRBD with the following command:
```
drbdadm status resource0
```
You should get the following output:
## Step 6 – Set Primary Resource of Initial Device Synchronization
At this point, DRBD is ready for operation. Next, you will need to tell it which node should be used as the source of the initial device synchronization.
On the first node, start the initial full synchronization with the following command:
```
drbdadm primary --force resource0
```
Now, check the status on the first node with the following command:
```
drbdadm status resource0
```
You should get the following output:
You can also get device mapping for a name with the following command:
```
lsblk
```
You should see the new DRBD device **drbd1** in the following output:
## Step 7 – Create a Filesystem on DRBD Device
Next, you will need to create a filesystem on the DRBD device, mount it, and check whether we can use it for replicated data storage.
On the first node, create an ext4 filesystem on the DRBD device with the following command:
```
mkfs.ext4 /dev/drbd1
```
**Note**: This Process can take a while depending on the size of your block storage.
You should get the following output:
Next, mount the DRBD device on /opt directory using the following command:
```
mount /dev/drbd1 /opt/
```
Next, create some test files inside /opt directory.
```
cd /opt
touch file1 file2 file3 file4 file5 file6 file7 file8 file9
```
Next, verify the mounted device with the following command:
```
df -hT /opt
```
You should see the following output:
```
Filesystem Type Size Used Avail Use% Mounted on
/dev/drbd1 ext4 49G 53M 47G 1% /opt
```
## Step 8 – Mount the DRBD Device on Second Node
In this section, we will mount the DRBD device on the second node and check whether the replication is working or not.
On the **first node**, unmount the DRBD device and make it a secondary node with the following command:
```
cd
umount /opt
drbdadm secondary resource0
```
On the **second node**, make the second node primary with the following command:
```
drbdadm primary resource0
```
Next, mount the DRBD device on the /opt directory with the following command:
```
mount /dev/drbd1 /opt
```
Now, run the following command to print the list of files in the /opt directory:
```
ls /opt
```
If everything is fine, all the files stored in the DRBD device should be there:
You can also check the mounted partition of the DRBD device with the following command:
```
df -hT /opt
```
You should get the following output:
```
Filesystem Type Size Used Avail Use% Mounted on
/dev/drbd1 ext4 49G 53M 47G 1% /opt
```
## Conclusion
Congratulations! You have successfully installed and setup replication with DRBD on CentOS 8. DRBD is a great tool if you are looking to increase the availability of your data. For more information, you can visit the DRBD [documentation](https://www.linbit.com/drbd/). Try DRBD today on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# Best Practices for Creating a HIPAA-Compliant WordPress Site
> URL: https://www.atlantic.net/hipaa-compliant-wordpress-hosting/best-practice-for-creating-a-hipaa-compliant-wordpress-site/ | Published: 2020-09-25 | Updated: 2025-09-19 | Author: Richard Bailey
WordPress is a widely used website creation application powering about [38% of all websites](https://w3techs.com/technologies/details/cm-wordpress) on the Internet today. WordPress achieved mainstream popularity because of its ease of use, allowing almost anyone to create detailed and professional-looking websites with a few clicks.
WordPress is particularly popular with small-to-medium size businesses, web developers, graphic designers, and personal blogs. However, it is also [used by big companies](https://wpclipboard.com/famous-brands-companies-using-wordpress/), [such as](https://www.isitwp.com/popular-big-name-brands-using-wordpress/) BBC America, Sony Music, and Microsoft News.
> **Did you know?**
>
> On the Atlantic.Net Cloud Platform (cloud.atlantic.net), you can auto-deploy a WordPress client-server in seconds. Our secure, defined one-click WordPress application uses Ubuntu 20.04 with PHP, MySQL, Apache, WordPress, and Postfix included as standard.
WordPress sites that include Protected Health Information (PHI), as with any website handling PHI, must adhere to the administrative, physical, and technical safeguards of HIPAA to ensure the confidentiality of data uploaded or made available through the website.
## HIPAA-Compliant Design Rules for WordPress
The following three-step HIPAA-compliant framework facilitates the development of a WordPress site that can handle PHI:
- HIPAA compliance built into the ***website design*** process
- ***Server hardening*** to meet the technical requirements of HIPAA
- [HIPAA-compliant WordPress ***hosting***](https://www.atlantic.net/hipaa-compliant-wordpress-hosting/)
> **Did you know?**
>
> HIPAA rules are applicable regardless of whether the WordPress site is being used in-house or connected to the public Internet.
## Website Design
HIPAA compliance must drive the website design plan; the design must meet HIPAA’s minimum security and privacy standards to ensure the confidentiality, integrity, and availability of PHI.
- Access controls to prevent unauthorized access to PHI
- Access controls to the WordPress administration control panel
> **Need help? **
>
> Check out the “[*Advanced Access Manager*](https://en-gb.wordpress.org/plugins/advanced-access-manager/)” plugin by Vasyl Martyniuk.
- Audit controls to log all access to the site
- Audit controls to log any activity on the site that involves ePHI
> **Need help? **
>
> Check out the “[*WP Activity Log*](https://en-gb.wordpress.org/plugins/wp-security-audit-log/)” plugin by WP White Security.
- Integrity controls to prevent PHI from being altered by unauthorized users
- Transmission security controls to protect PHI uploads (encrypted in transit)
- Encrypt the webserver data
## Server Hardening
Here are some practical ways to protect your WordPress server from common vulnerabilities and threats:
- Update WordPress and PHP regularly
- Update the operating system monthly
- Only use very strong passwords and never reuse passwords
- Only use sFTP encryption to transfer files to and from the webserver
- Update file permissions so that no user can change or modify files
- Ensure no system services or applications run as the root user
> **Did you know?**
>
> Only the*.htaccess* file should have root permissions.
- Restrict database user privileges and set IP restrictions to access the DB
- Secure WP-Admin with multi-factor authentication (MFA)
> **Need Help?**
>
> Here are two great MFA plugins: “[*Duo Two-Factor Authentication*](https://wordpress.org/plugins/duo-wordpress/)” and “*[Google Authenticator](https://wordpress.org/plugins/google-authenticator/)*.”
## HIPAA-Compliant WordPress Hosting
A hosting company that is HIPAA compliant will provide you with an infrastructure that is built around the fundamental safeguards needed for compliance. Make sure you choose a hosting provider that can:
- Implement physical security controls to prevent unauthorized physical access to the webserver
- Offer a Fully Managed Firewall or Web Application Firewall (WAF)
- Provide an encrypted VPN
- Provide an encrypted Data Backup plan to protect PHI securely
- Provide a Disaster Recovery solution to ensure that PHI is continuously available
- Provide forensic level logging of all activity of the host server (this is in addition to WordPress layer logging)
- Monitoring and alerting logging
- Monitoring file changes using an Intrusion Prevention Service
> **Did you know?**
>
> Atlantic.Net offers [HIPAA Compliant WordPress Hosting](https://www.atlantic.net/hipaa-compliant-hosting/) and [HIPAA Compliant Cloud Storage](https://www.atlantic.net/hipaa-compliant-hosting/hipaa-compliant-cloud-storage/) services to support IT Solutions for Healthcare.
Ready to get started with setting up a HIPAA-Compliant WordPress Site? Choose Atlantic.Net for a one-click WordPress installation that will set you well on your way to a [HIPAA-Compliant WordPress Website](https://www.atlantic.net/hipaa-compliant-wordpress-hosting/) – get started today!
---
#### Read More About HIPAA Compliant Hosting
- [HIPAA Compliant Hosting](https://www.atlantic.net/hipaa-compliant-hosting/)
- How to Make a [HIPAA-Compliant Website](https://www.atlantic.net/hipaa-compliant-hosting/how-to-make-website-hipaa-compliant/)
- [HIPAA Compliant Server](https://www.atlantic.net/hipaa-compliant-hosting/hipaa-compliant-server-for-a-client-portal-solution/) Case Study
- [HIPAA Compliant Data Center](https://www.atlantic.net/hipaa-data-centers/)
- [Is WordPress HIPAA Compliant?](https://www.atlantic.net/hipaa-compliant-wordpress-hosting/a-sample-hipaa-wordpress-setup/)
- [HIPAA Compliant WordPress Hosting](https://www.atlantic.net/hipaa-compliant-wordpress-hosting/)
---
# How to Backup and Restore a WordPress Website
> URL: https://www.atlantic.net/vps-hosting/how-to-backup-and-restore-a-wordpress-website/ | Published: 2020-10-07 | Updated: 2026-03-02 | Author: Hitesh Jethva
Backing up your website regularly is a very important task for any webmaster. You should always have a recent backup of your website to prevent data loss in case something goes wrong, but backing up and restoring the WordPress website manually can be difficult for a beginner user.
There are several ways to back up and restore a WordPress website. However, a simple and easy way is to use the UpdraftPlus backup plugin to backup and restore a WordPress website. UpdraftPlus can automate the backup and copy it to a cloud-based drive, such as Google Drive, Dropbox, and more.
In this tutorial, we will show you how to back up and restore a WordPress website with the UpdraftPlus WordPress plugin.
## Prerequisites
- A Linux [VPS](https://www.atlantic.net/vps-hosting/) with WordPress installed on the Atlantic.Net Cloud Platform
## Step 1 – Install UpdraftPlus Plugin
UpdraftPlus is the world’s highest-ranking and most popular scheduled backup plugin; it allows you to back up your files and database backups into the local or cloud storage and restore with a single click!. This free plugin supports various remote cloud storage options including Dropbox, Google Drive, Amazon S3, UpdraftVault, Rackspace Cloud, FTP, DreamObjects, and Openstack Swift.
Follow the below steps to install the UpdraftPlus plugin:
**1 –**Go to the WordPress admin dashboard => **Plugins** => **Add New** and type **UpdraftPlus** in search bar. You should see the following screen:
**2 –**Select the **UpdraftPlus** WordPress Backup Plugin and click on the **Install** Now button to install the plugin. Once the plugin has been installed, you should see the following screen:
**3 –**Click on the **Activate** button to activate the plugin.
## Step 2 – Create a WordPress Backup with UpdraftPlus
At this point, the UpdraftPlus backup and restore plugin is installed. Next, you will need to configure UpdraftPlus plugin settings.
On the WordPress admin dashboard, click on the UpdraftPlus Backups in the left pane. You should see the following screen:
Next, click on the **Settings**tab. You should see the following screen:
Here, select your database and file backup schedule, choose your remote storage, select include and exclude a directory, check the email checkbox and click on the **Save Changes** button to save the configuration. You should see the Dropbox storage authentication screen:
Click on the **link**. You will be redirected to the Dropbox authentication screen:
Provide your Dropbox username, password, and click on the **Sign-in** button. You should see the UpdraftPlus website where you need to click on the ‘Complete Setup’ button to finish the setup.
Click on the **Complete Setup** button to finish the setup.
Now, click on the **Backup / Restore** tab to create a backup of your WordPress website. You should see the following screen:
Click on the **Backup Now** button to start the backup process. You should see the following screen:
Check the required box and click on the **Backup Now** button. Once the backup is generated, you should see the following screen:
From here, you can also download your generated backup to your local system.
## Step 3 – Restore a WordPress Backup with UpdraftPlus
Now that you have up your website, being able to restore it with UpdraftPlus is just as important. UpdraftPlus provides an easy way to restore your website from a backup.
If your website or system has crashed, then you may need to install WordPress and the UpdraftPlus plugin again before proceeding.
You can perform the restoration process using the following steps:
**1 –**Go to the **WordPress** admin dashboard and click on the **UpdraftPlus** **Backups**in the left pane. You should see the following screen:
You should see your generated backup file in the above screen. If you don’t find it, you can also upload it from your local system or Dropbox.
**2 –**Click on the **Restore** button to start the restoration process. You should see the following screen:
**3 –**Select the components that you want to restore from the backup and click on the **Next** button. You should see the following screen:
**4 –**Click on the **Restore** button to start the process. Once the restoration process has completed successfully, you should see the following screen:
## Conclusion
In the above guide, you learned how to backup and restore a WordPress website easily with the UpdraftPlus backup plugin. You can now schedule the backup process to save yourself time – test it out on your WordPress installation on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net today!
---
# How To Set Up Apache with MPM Event and PHP-FPM on Ubuntu
> URL: https://www.atlantic.net/vps-hosting/how-to-set-up-apache-with-mpm-event-and-php-fpm-on-ubuntu/ | Published: 2020-10-08 | Updated: 2024-09-25 | Author: Hitesh Jethva
Apache is free, open-source, and the most widely used web server, largely because it is capable of working in different environments. Apache has the ability to manage different processes to serve an HTTP protocol request including processing the request, opening a socket, and handling new events.
These tasks are performed by the Apache Multi-Processing Module (MPM).
## What Is Apache MPM?
Apache MPM (Multi-Processing Modules) are Apache modules used for creating child processes in Apache. They allow more requests to be served simultaneously by passing off some processing work to listener threads, freeing up worker threads to serve new requests. Using PHP-FPM with MPM Event in an Apache webserver decreases the website page loading time and allows the webserver to handle more concurrent connections.
In this tutorial, we will learn how to configure Apache with MPM Event and PHP-FPM on Ubuntu 20.04.
## Step 1 – Install LAMP Server
First, install the Apache web server, and MariaDB with the following command:
```
apt-get install apache2 mariadb-server -y
```
Next, add the PHP repository using the following command.
```
apt install software-properties-common
add-apt-repository ppa:ondrej/php -y
```
Next, install PHP with other required dependencies using the following command.
```
apt install php7.4 libapache2-mod-php7.4 php7.4-mysql php7.4-gd php7.4-curl php7.4-xml
```
Once the LAMP server is installed, you can proceed to the next step.
## Step 2 – Change the Multi-Processing Module
Before starting, you will need to switch the MPM from pre-fork to event and remove the php7.4 module connection between PHP and Apache.
First, stop the Apache service and disable the php7.4 module with the following command:
```
systemctl stop apache2
a2dismod php7.4
```
Next, disable the Pre-fork MPM module with the following command:
```
a2dismod mpm_prefork
```
Next, enable the Event MPM module with the following command:
```
a2enmod mpm_event
```
Once you are finished, you can proceed to the next step.
## Step 3 – Configure Apache to Use the FastCGI Process Manager
In this section, we will install the PHP-FPM processor and proxy modules so Apache can communicate with PHP.
First, install the PHP-FPM with the following command:
```
apt-get install php7.4-fpm -y
```
Once installed, you will need to install libapache2-mod-fcgid library in order to communicate Apache and PHP.
You can install it with the following command:
```
apt-get install libapache2-mod-fcgid -y
```
Once installed, you will need to enable the PHP-FPM, Proxy and FastCGI Proxy module in Apache webserver.
You can enable them with the following command:
```
a2enconf php7.4-fpm
a2enmod proxy
a2enmod proxy_fcgi
```
Next, restart the Apache service to apply the changes:
```
systemctl restart apache2
```
Now, verify the MPM module with the following command:
```
apachectl -M | grep 'mpm'
```
You should get the following output:
```
mpm_event_module (shared)
```
Next, verify the Proxy and FastCGI Proxy module with the following command:
```
apachectl -M | grep 'proxy'
```
You should get the following output:
```
proxy_module (shared)
proxy_fcgi_module (shared)
```
## Step 4 – Verify FastCGI Process Manager
At this point, Apache web server is configured to use the FastCGI Process Manager. It’s time to verify if PHP is using the FastCGI Process Manager.
First, create an info.php file inside the Apache document root directory:
```
nano /var/www/html/info.php
```
Add the following lines:
```
```
Save and close the file when you are finished.
Next, open your web browser and type the URL http://your-server-ip/info.php. You should see the following screen:
In the above page, you should see that Apache web server is using FPM/FastCGI.
## Conclusion
In the above guide, we learned how to configure Apache with MPM Event and PHP-FPM on Ubuntu 20.04. Now, PHP-FPM will handle the PHP code and improve overall resource utilization. Give it a shot on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# How to Adopt a DevOps Development Model When You Don’t Know Where to Start
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-adopt-a-devops-development-model-when-you-dont-know-where-to-start/ | Published: 2020-10-09 | Updated: 2025-09-19 | Author: Brandon Schroth
The ongoing pandemic has forced business owners to make significant shifts in their operating strategies, including swapping centralized databases with distributed databases and adopting remote work culture.
They have also figured out that the best way to stay ahead of their competition is by implementing DevOps practices that can significantly accelerate product launches and upgrades.
But a problem sometimes arises when they are unsure about where to start with new DevOps processes. Leaping into DevOps can be intimidating due to the absence of any relevant cookie-cutter approach. You have to customize a model based on your organization’s needs to make your team more agile and competitive while [simultaneously improving business security](https://www.atlantic.net/hipaa-compliant-hosting/how-to-protect-business-data-when-employees-are-working-from-home/), cutting costs, and boosting revenue.
If you are considering adopting a DevOps model, keep reading. We will discuss different approaches to help make the transformation successful.
## What Do You Mean by DevOps?
Before discussing strategies, it‘s crucial to understand what the term “DevOps“ means.
The concept of DevOps [refers to a change in IT culture](https://medium.com/@copyconstruct/what-is-devops-5b0181fdb953) that focuses on rapid IT service delivery through the adoption of agile practices. These practices are aimed at creating a system-oriented approach to IT services and development. The priority here is to improve the collaboration between software development (Dev) and IT operations (Ops).
In essence, DevOps focuses on automating manual processes such as making payments, measuring performances, processing data, and so on. The idea here is to combine the efforts and functions of both the teams and make them share responsibilities. This can be done through automating infrastructure, automating code testing and workflows, and continuously measuring performance.
You can think of implementing a DevOps model into your business as a means of digitally transforming your IT and development teams for the better. This is something you would be wise to do quickly if you are not already doing so, since [74% of all organizations](https://brainstation.io/research/digital-skills-survey-2020-results) are actively involved in digitally transforming their business processes.
In some models, quality assurance and security teams also merge with the developers and operations teams to make up for the lack of security practices around it. In such cases, the name gets modified to DevSecOps.
## The Best Practice is to Adopt a DevOps Model
The following are a few approaches that can be critical for [ensuring a successful DevOps adoption](https://www.cigniti.com/blog/10-best-practices-for-successful-devops-implementation/) within an organization:
#### Embracing the Integration Mindset
Combining development and operations efforts can be a rather complicated task in the absence of open communication and transparency. The only way to overcome disunity is to share common goals among teams.
Any DevOps strategy has two main components: continuous integration and continuous delivery. Before implementing a new DevOps strategy, you have to identify areas where the current delivery process is inefficient, along with an open mindset to experiment.
Try to understand that short-term failure is acceptable as long as your organization [Comparing Three Approaches to Multi-Cloud Security Management Sees](https://devops.com/comparing-three-approaches-to-multi-cloud-security-management/) it as an opportunity to learn and improve. At the same time, implementing DevOps [shouldn’t put confidential data at risk](https://devops.com/comparing-three-approaches-to-multi-cloud-security-management/), so make sure to take necessary measures to protect data integrity and ensure uniformity.
#### Launching Pilot Projects that Use a DevOps Methodology
Step-by-step implementation can be an excellent way to get on the DevOps bandwagon. You can start with a pilot project based on DevOps methodology. Doing this will help you understand vital elements, check the response and readiness of teams, and evaluate the overall effectiveness of the DevOps program.
But make sure that it doesn’t affect the quality of other projects or jeopardize your business operations.
#### Setting Up Metrics for Giving Feedback
Selecting the right metrics to record and track progress [is the most overlooked aspect](https://techbeacon.com/devops/6-proven-metrics-devops-success) of DevOps adoption.
Consider this: how could you possibly give feedback at every stage if you cannot identify your weaknesses and the areas that need more improvement?
Here are some of the most useful DevOps metrics for you to consider:
- **Deployment speed:** how long does it take you to deploy an upgraded version of an application to a particular environment?
- **Production failure rate:** how often does the software fail in the production stage during a fixed period of time?
- **Average lead time:** how long does it take for a new requirement to be built, tested, delivered, and deployed?
- **Mean time to production:** how long does it take for a new code to be committed into a code repository for it to be deployed into production?
- **Deployment frequency:** how often do you deploy new release candidates to test, staging, pre-production, and production environments?
You need a balanced approach in the implementation of DevOps, so giving feedback on every work process, from design and testing to release, is necessary. You can consider designing a quick feedback process to [boost the effectiveness of workflow automation](https://www.cloudwards.net/17-pro-tips-for-workflow-automation/) for this purpose as well.
#### Focus Automation Efforts on the Part of the IT Process that Needs It Most
Now that you have a pilot project and a feedback system in place, you should start by automating one process. We would recommend automating the most key processes in order to best evaluate the results. Also, be prepared for errors and setbacks that may occur in the process.
Another way to approach this would be to start implementing DevOps with a process that runs parallel to the key. The benefit of this approach is you get an opportunity to learn and understand advances in the framework of the real process without disturbing the entire project.
#### Lay Emphasis on Standardization
While it‘s true that [automation has several business advantages](https://blog.clicky.com/4-ways-to-automate-business-operations/), you won’t be able to mitigate communication gaps, performance bottlenecks, and silos between teams if you don’t have standardized workflows, technologies, protocols, processes, and metrics in place.
Hence, DevOps standardization is crucial in automation for ensuring developers, operations, QA, and everyone associated with these teams have a common frame of reference, along with a common language.
#### Revising Your Agile and DevOps Culture
Adopting DevOps [is a huge cultural shift](https://www.mckinsey.com/business-functions/mckinsey-digital/our-insights/digital-blog/five-cultural-changes-you-need-for-devops-to-work#) since it consists of intermingling workgroups and overcoming the traditional disunity of teams. It makes sense to make certain adjustments to boost the overall efficiency of an organization.
DevOps isn’t only limited to using new tools and re-drawing processes. It’s equally important to change the corporate culture itself, which is heavily dependent on uninterrupted and secure data access and transparent communication between employees.
## Understanding the Benefits of DevOps Culture
Now that we have spoken about the ways of [implementing a successful DevOps strategy](https://www.cio.com/article/3234105/6-steps-to-devops-success.html), you should also know the advantages that you can expect from this.
DevOps helps you foster transparency through the processes, especially for version control. You will be able to ensure continuous software delivery and improve the speed of resolution and turnaround time. Not only will this help you deliver value to customers, but you will also enjoy a better position in the market.
A successful DevOps strategy can even pave the way for adopting DevSecOps in the future, a strategy that will protect sensitive data and maximize privacy on the web. By adopting DevSecOps into your business, security will ideally be implemented at the same speed and scale as the development of business operations.
The best DevSecOps strategy will be to automate as many things as possible to keep up with your operations. This can be best accomplished if you [use open source security tools](https://privacyaustralia.net/privacy-tools/) to mitigate common security threats such as SQL injections and cross-site scripting.
Concerning automation, DevOps can help stabilize operating environments and also give more time to teams for innovation through automated processes. Any manual implementation of tasks will, in turn, be limited.
Another huge advantage is the introduction of a more production-oriented concept that will reduce time wastage. This will ultimately cut down software costs. Interestingly,63% of organizations have reported seeing improvements in software deployment quality, and frequency. This is made possible because teams can engage more through collaboration that helps them handle management challenges.
To put things to a perspective, DevOps can be a challenge, yes. But it can also be very beneficial for the overall growth of an organization.
## Conclusion
In addition to the efficiency benefits your organization could enjoy from implementing DevOps, successful implementation may even improve your organization‘s chances to [mitigate the adverse impact of coronavirus](https://www.atlantic.net/vps-hosting/how-can-remote-working-and-business-continuity-planning-mitigate-the-impact-of-the-covid-19-coronavirus/) by following standardized processes and protocols, sharing common interests, and having team unity. Learn how Atlantic.Net’s [Dedicated Server Hosting](https://www.atlantic.net/dedicated-server-hosting/) could help you implement DevOps!
If your organization is just beginning to embrace a DevOps culture, keep yourself and your team’s mindsets prepared for the challenges. After all, DevOps cannot be bought or declared, and it can only be attained through hard work and discipline.
---
# How to Benchmark Web Server Performance with Apache Bench
> URL: https://www.atlantic.net/vps-hosting/how-to-benchmark-web-server-performance-with-apache-bench/ | Published: 2020-10-12 | Updated: 2024-09-25 | Author: Hitesh Jethva
If you are a webmaster, you may often be concerned with the performance of your web applications. You might ask questions like, “how do I perform load testing of my application?” or “will my application be able to handle a lot of users?” In these cases, Apache Bench can be a great help. Apache Bench is a free and open-source tool to measure the performance of a web server with a simple, easy-to-use command-line interface; it can help you understand how your current Apache installation performs.
In this tutorial, we will show you how to install and use Apache Bench on Linux.
## Step 1 – Install Apache Bench
Apache Bench is a part of the Apache webserver package, so you don’t need to install the Apache Bench if the Apache Web Server is installed on your system.
For Ubuntu/Debian operating system, install the Apache Bench tool with the following command:
```
apt-get install apache2-utils -y
```
For RHEL/CentOS operating system, install the Apache Bench tool with the following command:
```
yum install httpd-tools -y
```
You can display all options available with Apache Bench tool using the following command:
```
ab
```
You should see the following screen:
A brief explanation of the most commonly used options is shown below:
- **-n:** Specify the number of connection requests sent to the webserver.
- **-c:** Specify the number of concurrent connection requests sent to the webserver.
- **-t:** Specify the number of seconds the ab command should continue sending requests.
**Note:** Sometimes you may get a “connection timed out” error. The reason for this is your connection request blocked by a firewall or the Apache webserver wasn’t able to handle further requests.
## Step 2 – Running a Stress Test
At this point, the Apache Bench tool is installed. Now,you can perform a stress test against your webserver locally or using the domain name.
Let’s perform a stress test against your Apache web server by sending 800 requests over 300 concurrent connections.
```
ab -n 800 -c 300 http://your-domain-name/
```
This will perform for 800 requests with a concurrency of 300 as shown below:
```
This is ApacheBench, Version 2.3 <$Revision: 1807734 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking localhost (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Finished 800 requests
Server Software: Apache/2.4.29
Server Hostname: localhost
Server Port: 80
Document Path: /
Document Length: 10918 bytes
Concurrency Level: 300
Time taken for tests: 0.459 seconds
Complete requests: 800
Failed requests: 0
Total transferred: 8953600 bytes
HTML transferred: 8734400 bytes
Requests per second: 1743.53 [#/sec] (mean)
Time per request: 172.064 [ms] (mean)
Time per request: 0.574 [ms] (mean, across all concurrent requests)
Transfer rate: 19056.29 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 6 7.8 0 20
Processing: 8 92 124.3 44 437
Waiting: 4 92 124.4 43 437
Total: 22 98 128.9 44 453
Percentage of the requests served within a certain time (ms)
50% 44
66% 50
75% 53
80% 56
90% 435
95% 445
98% 450
99% 452
100% 453 (longest request)
```
In the above output, you can see Apache has handled 1743.53 requests per second, and it took a total 0.459 seconds to serve the total requests.
Let’s perform another stress test against your Nginx web server and compare it with Apache result by sending 800 requests over 300 concurrent connections.
```
ab -n 800 -c 300 http://your-domain-name/
```
You should see the following output:
```
This is ApacheBench, Version 2.3 <$Revision: 1807734 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking localhost (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Finished 800 requests
Server Software: nginx/1.14.0
Server Hostname: localhost
Server Port: 80
Document Path: /
Document Length: 10918 bytes
Concurrency Level: 300
Time taken for tests: 0.184 seconds
Complete requests: 800
Failed requests: 0
Total transferred: 8930400 bytes
HTML transferred: 8734400 bytes
Requests per second: 4354.95 [#/sec] (mean)
Time per request: 68.887 [ms] (mean)
Time per request: 0.230 [ms] (mean, across all concurrent requests)
Transfer rate: 47474.91 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 1 12 7.5 9 32
Processing: 5 33 12.8 30 56
Waiting: 4 26 12.9 22 49
Total: 15 46 13.6 46 70
Percentage of the requests served within a certain time (ms)
50% 46
66% 56
75% 58
80% 60
90% 64
95% 66
98% 70
99% 70
100% 70 (longest request)
```
In the above output, you can see Apache has handled 4354.95 requests per second, and it took a total 0.184 seconds to serve the total requests.
You can see that Nginx can handle more requests than Apache. After comparing the result of both servers, you will get an idea of which one to choose for your web application.
## Conclusion
In the above guide, we learned how to test web server performance with Apache Bench. You can now explore the Apache Bench tool and run it with different options to measure the performance of your webserver; try it today on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How To Install and Configure Elasticsearch on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-configure-elasticsearch-on-ubuntu-20-04/ | Published: 2020-10-17 | Updated: 2023-11-22 | Author: Hitesh Jethva
Elasticsearch is a free and open-source NoSQL database used to store, search, and analyze big volumes of data in real-time. It is written in the Java language so it can run on different platforms. Elasticsearch is built on Lucene indexing technology and supports database queries through REST APIs. You can also integrate Elasticsearch with other tools, such as Kibana, Logstash, X-Pack, and other. Generally, it is used in applications that have complex search features and requirements.
In this tutorial, we will learn how to install Elasticsearch on Ubuntu 20.04.
## Step 1 – Install Java
Elasticsearch is written in the Java language, so Java must be installed in your system. If not installed, you can install it with the following command:
```
apt-get install default-jdk -y
```
Once the Java is installed, verify the installed version of Java using the following command:
```
java -version
```
You should see the following output:
## Step 2 – Install Elasticsearch
By default, the Elasticsearch package is not available in the Ubuntu default repository, so you will need to add the repository in your system.
First, you need to install an APT transport package to allow access to your repositories via HTTPS:
```
apt-get install apt-transport-https gnupg2 -y
```
Next, download and add the GPG key for the Elasticsearch repository with the following command:
```
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
```
Next, run the following command to add the repository to your system:
```
echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | tee -a
/etc/apt/sources.list.d/elastic-7.x.list
```
Next, update the repository and install the Elasticsearch with the following command:
```
apt-get update -y
apt-get install elasticsearch -y
```
Once installed, start the Elasticsearch service and enable it to start at boot with the following command:
```
systemctl start elasticsearch
systemctl enable elasticsearch
```
You can also verify the status of Elasticsearch service with the following command:
```
systemctl status elasticsearch
```
You should get the following output:
## Step 3 – Configure Elasticsearch for Remote Access
The default Elasticsearch configuration is located at /etc/elasticsearch/elasticsearch.yml and it comes preconfigured for basic usage, so you don’t need to configure it if you use only one node in your setup.
In some cases, you need to configure Elasticsearch to be accessed by other hosts. You can allow remote access by editing elasticsearch.yml file:
```
nano /etc/elasticsearch/elasticsearch.yml
```
Add the following lines below “Network” section:
```
transport.host: localhost
transport.tcp.port: 9300
http.port: 9200
network.host: 0.0.0.0
```
Save and close the file, then restart Elasticsearch service to apply the changes:
```
systemctl restart elasticsearch
```
## Step 4 – Verify Elasticsearch
At this point, Elasticsearch is installed, configured, and listening on port 9200. Now it’s time to test whether it is working or not.
To test it, go to the remote system and run the following command:
```
curl http://your-server-ip:9200
```
You should see the version, date, and hash information in the following output:
```
{
"name" : "ubuntu2004",
"cluster_name" : "elasticsearch",
"cluster_uuid" : "CqfMwJSsRH-ucofVQxI9cA",
"version" : {
"number" : "7.7.1",
"build_flavor" : "default",
"build_type" : "deb",
"build_hash" : "ad56dce891c901a492bb1ee393f12dfff473a423",
"build_date" : "2020-05-28T16:30:01.040088Z",
"build_snapshot" : false,
"lucene_version" : "8.5.1",
"minimum_wire_compatibility_version" : "6.8.0",
"minimum_index_compatibility_version" : "6.0.0-beta1"
},
"tagline" : "You Know, for Search"
}
```
## Conclusion
Congratulations! You have successfully installed Elasticsearch in Ubuntu 20.04. You can now explore Elasticsearch for more functionality. For more information, visit the Elasticsearch [documentation](https://www.elastic.co/guide/en/elasticsearch/reference/7.6/index.html). Install Elasticsearch on your [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Install and Use WP-CLI to Manage WordPress
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-use-wp-cli-to-manage-wordpress/ | Published: 2020-10-18 | Updated: 2023-11-22 | Author: Hitesh Jethva
WP-CLI is the official command-line tool used for managing WordPress. WP-CLI allows you to install and update themes, plugins and configure multisite installations without using a web browser. It can boost productivity and speed up the development process, since performing certain tasks using the command-line is much easier than using a graphical interface.
WP-CLI allows you to perform commands that are not supported through the standard WordPress back-end. One of the most important benefits of WP-CLI is its efficiency; for a multi-site environment, you don’t need to log in to each account to take care of basic tasks.
In this tutorial, we will show you how to install and use WP-CLI to manage WordPress.
## Install WP-CLI
By default, WP-CLI is not available in the Ubuntu default repository, so you will need to download it from their website. You can download it with the following command:
```
wget https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar
```
Once the download is completed, move the downloaded file to the /usr/bin directory:
```
mv wp-cli.phar /usr/bin/wpcli
```
Next, provide execution permission with the following command:
```
chmod +x /usr/bin/wpcli
```
Next, verify the WP-CLI installation using the following command:
```
wpcli --info
```
You should get the following output:
## Manage Plugins with WP-CLI
WP-CLI allows you to search, install, and activate the WordPress plugins as per your need.
To list the installed WordPress plugins, run the wp-cli command as a www-data user inside the WordPress document root directory:
```
cd /var/www/html/
sudo -u www-data wpcli plugin list
```
You should get something similar to the following output:
If you want to install caching plugin, first search for the plugin with the following command:
```
sudo -u www-data wpcli plugin search w3-total-cache
```
You should see the following list:
Now, install the w3-total-cache plugin from the above list using the following command:
```
sudo -u www-data wpcli plugin install w3-total-cache
```
WP-CLI downloads and unpacks the plugin, then confirms the install with `Success: Installed 1 of 1 plugins.`
Next, activate the installed plugin with the following command:
```
sudo -u www-data wpcli plugin activate w3-total-cache
```
You should see the following output:
Now, verify the installed plugins with the following command:
```
sudo -u www-data wpcli plugin list
```
You should get the following list:
## Manage Themes with WP-CLI
You can also search for, install, and activate a WordPress theme using the WP-CLI.
First, list the installed WordPress themes in your system using the following command:
```
sudo -u www-data wpcli theme list
```
You should get the following output:
Next, search your for desired theme with the following command:
```
sudo -u www-data wpcli theme search astra
```
You should get the following list:
Now, install the theme from the above list using the following command:
```
sudo -u www-data wpcli theme install astra
```
Once installed, you should get the following output:
```
Installing Astra (2.4.5)
Downloading installation package from https://downloads.wordpress.org/theme/astra.2.4.5.zip...
Unpacking the package...
Installing the theme...
Theme installed successfully.
Success: Installed 1 of 1 themes.
```
Now, activate the installed theme using the following command:
```
sudo -u www-data wpcli theme activate astra
```
You should see the following output:
```
Success: Switched to 'Astra' theme.
```
## Manage Post With WP-CLI
You can also create, edit and manage WordPress posts with WP-CLI.
List all posts in your system using the following command:
```
sudo -u www-data wpcli post list
```
You should see the following list:
```
+----+--------------+-------------+---------------------+-------------+
| ID | post_title | post_name | post_date | post_status |
+----+--------------+-------------+---------------------+-------------+
| 1 | Hello world! | hello-world | 2020-06-21 05:01:58 | publish |
+----+--------------+-------------+---------------------+-------------+
```
Next, create and publish a new post with title “Install Django Ubuntu 20.04” using the following command:
```
sudo -u www-data wpcli post create --post_status=publish --post_title="Install Django Ubuntu
20.04" --edit
```
This will open the vim editor. Add the following contents:
```
In this tutorial, we will learn how to install Django on an Ubuntu 20.04 server.
```
Save and close the vim editor when you are finished.
You can now verify your newly created post using the following command:
```
sudo -u www-data wpcli post list
```
You should get the following output:
```
+----+-----------------------------+-----------------------------+---------------------+-------------+
| ID | post_title | post_name | post_date | post_status |
+----+-----------------------------+-----------------------------+---------------------+-------------+
| 5 | Install Django Ubuntu 20.04 | install-django-ubuntu-20-04 | 2020-06-21 05:31:36 | publish |
| 1 | Hello world! | hello-world | 2020-06-21 05:01:58 | publish |
+----+-----------------------------+-----------------------------+---------------------+-------------+
```
## Manage Database with WP-CLI
You can also manage the WordPress database with WP-CLI.
You can connect to the WordPress database using the following command:
```
sudo -u www-data wpcli db cli
```
You should see the following output:
Now, exit from the database with the following command:
```
MariaDB [wordpress]> EXIT
```
You can also query about your users using the following command:
```
sudo -u www-data wpcli db query "SELECT user_login,ID FROM wp_users;"
```
You should get the following output:
```
+------------+----+
| user_login | ID |
+------------+----+
| admin | 1 |
+------------+----+
```
## Update WordPress with WP-CLI
If you want to update your WordPress installation, run the following command:
```
sudo -u www-data wpcli core update
```
You should see the following output:
To update your WordPress database, run the following command:
```
sudo -u www-data wpcli core update-db
```
You should see the following output:
To update all plugins, run the following command:
```
sudo -u www-data wpcli plugin update --all
```
You should see the following output:
## Conclusion
In this guide, you learned how to manage WordPress with WP-CLI. WP-CLI is a very useful tool that makes WordPress administration much easier. See if it helps you to perform your day-to-day WordPress administration tasks on your [VPS Hosted](https://www.atlantic.net/vps-hosting/) WordPress installation from Atlantic.Net.
---
# How to Install and Configure Akaunting Software on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-configure-akaunting-software-on-ubuntu-20-04/ | Published: 2020-10-20 | Updated: 2023-11-22 | Author: Hitesh Jethva
Akaunting is free and open-source online accounting software that can be used to manage your invoices, quotes, and finances. It is built with modern technology frameworks, such as Laravel, VueJS, Bootstrap 4, and RESTful API, and was designed for small businesses and freelancers. Akaunting allows you to manage and track all your payments, invoices, expenses, and more from a central location.
In this tutorial, we will show you how to install Akaunting Software on Ubuntu 20.04.
## Step 1 – Install Apache, MariaDB, and PHP
Akaunting requires an Apache webserver, MariaDB database, and PHP to be installed on your server. You can install all of them by running the following command:
```
apt-get install apache2 mariadb-server php7.4 libapache2-mod-php7.4 php7.4-common php7.4-
imap php7.4-mbstring php7.4-xmlrpc php7.4-soap php7.4-gd php7.4-xml php7.4-intl php7.4-mysql
php7.4-cli php7.4-bcmath php7.4-ldap php7.4-zip php7.4-curl unzip curl -y
```
Once all the packages are installed, edit the php.ini file and change some desired settings.
```
nano /etc/php/7.4/apache2/php.ini
```
Change the following lines:
```
memory_limit = 256M
upload_max_filesize = 20M
post_max_size = 20M
max_execution_time = 300
date.timezone = America/Chicago
```
Save and close the file, then restart the Apache service to apply the changes.
```
systemctl restart apache2
```
## Step 2 – Configure Database for Akaunting
Next, you will need to create a database for Akaunting. First, log in to the MariaDB shell with the following command:
```
mysql
```
Once logged in, create a database and user for Akaunting with the following command:
```
CREATE DATABASE akaunting;
CREATE USER 'akaunting'@'localhost' IDENTIFIED BY 'your-password';
```
Next, grant all privileges to the Akaunting database with the following command:
```
GRANT ALL ON akaunting.* TO 'akaunting'@'localhost' IDENTIFIED BY 'your-password'
WITH GRANT OPTION;
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Download Akaunting
First, you will need to download the latest version of Akaunting from its official website. You can download it using the curl command as shown below:
```
curl -O -J -L https://akaunting.com/download.php?version=latest
```
Once the download is completed, create a directory for Akaunting inside the Apache web root directory:
```
mkdir -p /var/www/html/akaunting
```
Next, extract the downloaded file to the akaunting directory with the following command:
```
unzip Akaunting_*.zip -d /var/www/html/akaunting/
```
Next, change the ownership of the akaunting directory and set proper permission with the following command:
```
chown -R www-data:www-data /var/www/html/akaunting/
chmod -R 755 /var/www/html/akaunting/
```
## Step 4 – Configure Apache for Akaunting
Next, you will need to create an Apache virtual host configuration file for Akaunting. You can create it with the following command:
```
nano /etc/apache2/sites-available/akaunting.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
DocumentRoot /var/www/html/akaunting
ServerName example.com
DirectoryIndex index.html index.php
Options +FollowSymlinks
AllowOverride All
Require all granted
ErrorLog ${APACHE_LOG_DIR}/akaunting_error.log
CustomLog ${APACHE_LOG_DIR}/akaunting_access.log combined
```
Save and close the file, then enable the Apache virtual host file and rewrite module with the following command:
```
a2ensite akaunting
a2enmod rewrite
```
Next, restart the Apache service to apply the changes:
```
systemctl restart apache2
```
## Step 5 – Access Akaunting Web Interface
Now, open your web browser and access the Akaunting web installation wizard using the URL **http://example.com**. You should see the following screen:
Select your desired language and click on the **Next** button. You should see the following screen:
Provide your database details and click on the **Next** button. You should see the following screen:
Provide your company name, email address, admin email address, and click on the **Next** button. You should see the following screen:
Provide your admin email and password and click on the **Login** button. You should see the following screen:
Click on the **Skip** button. You should see the following screen:
Click on the **Next** button. You should see the following screen:
Click on the **Next** button. You should see the following screen:
Now, click on the **Go** **to** **dashboard** button. You should see the Akaunting dashboard in the following screen:
## Conclusion
In the above guide, you learned how to install Akaunting software on Ubuntu 20.04. You can now easily manage your finance, invoice, and account online from the central location. Try out Akaunting on your [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install and Configure Code-Server Cloud IDE Platform on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-configure-code-server-cloud-ide-platform-on-ubuntu-20-04/ | Published: 2020-10-20 | Updated: 2024-06-30 | Author: Hitesh Jethva
Cloud IDE is a web-based integrated development platform (IDE). It is a programming environment designed for developers and comes with a code editor, a compiler, a debugger, and a graphical user interface. The main benefit of Cloud IDE is that you can access it from anywhere, from any compatible device, enabling easy installation and real-time collaboration between developer teams.
code-server is an open-source project that allows you to run Visual Studio Code on a remote server accessible directly from your browser. Visual Studio Code provides a code editor with integrated Git support, a code debugger, and smart autocompletion.
In this tutorial, we will learn how to install a code-server Cloud IDE platform on Ubuntu 20.04.
## Step 1 – Install code-server IDE
First, you will need to download the latest version of the code-server from the Git Hub repository. At the time of writing this tutorial, the latest version of the code-server is v3.4.0. You can download it with the following command:
```
apt-get update -y
```
```
wget https://github.com/cdr/code-server/releases/download/v3.4.0/code-server-3.4.0-linux
-amd64.tar.gz
```
Once the download is completed, extract the downloaded file with the following command:
```
tar -xvzf code-server-3.4.0-linux-amd64.tar.gz
```
Next, move the extracted directory to the /usr/lib directory:
```
cp -r code-server-3.4.0-linux-amd64 /usr/lib/code-server
```
Next, create a symbolic link of code-server binary to the /usr/bin/ directory:
```
ln -s /usr/lib/code-server/bin/code-server /usr/bin/code-server
```
Next, create a directory to store user’s data:
```
mkdir /var/lib/code-server
```
Once you are finished, you can proceed to the next step.
## Step 2 – Create a Systemd Unit File for code-server
Next, you will need to create a systemd service file to manage the code-server service. You can create it with the following command:
```
nano /lib/systemd/system/code-server.service
```
Add the following lines:
```
[Unit]
Description=code-server
After=nginx.service
[Service]
Type=simple
Environment=PASSWORD=secure-password
ExecStart=/usr/bin/code-server --bind-addr 127.0.0.1:8080 --user-data-dir /var/lib/code-server --
auth password
Restart=always
[Install]
WantedBy=multi-user.target
```
Save and close the file when you are finished. Then, reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the code-server service and enable it to start at boot with the following command:
```
systemctl start code-server
systemctl enable code-server
```
You can now verify the status of the code-server service with the following command:
```
systemctl status code-server
```
You should see the following output:
At this point, code-server is started and listening on port 8080. You can now proceed to the next step.
## Step 3 – Configure Nginx as a Reverse Proxy
It is a good idea to configure Nginx as a reverse proxy to access the code-server without specifying the port 8080.
First, install the Nginx server with the following command:
```
apt-get install nginx -y
```
Once Nginx has been installed, create a new virtual host configuration file for code-server:
```
nano /etc/nginx/sites-available/code-cloud.conf
```
Add the following lines:
```
server_names_hash_bucket_size 64;
server {
listen 80;
server_name code.example.com;
location / {
proxy_pass http://localhost:8080/;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection upgrade;
proxy_set_header Accept-Encoding gzip;
}
}
```
Save and close the file then, activate the Nginx virtual host with the following command:
```
ln -s /etc/nginx/sites-available/code-cloud.conf /etc/nginx/sites-enabled/
```
Next, check Nginx for any syntax errors with the following command:
```
nginx -t
```
You should get the following output:
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Finally, restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 4 – Access code-server IDE
Now, open your web browser and type the URL http://code.example.com. You will be redirected to the code-server IDE login page:
Provide your password which you set in the previous steps and click on the **SUBMIT** button. You should see the code-server GUI interface in the following screen:
## Conclusion
Congratulations! You have successfully installed and configured code-server IDE on Ubuntu 20.04.
You can now start coding directly in Cloud IDE on your [virtual private server](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Install Ganglia Monitoring Server on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-ganglia-monitoring-server-on-ubuntu-18-04/ | Published: 2020-10-20 | Updated: 2023-11-17 | Author: Hitesh Jethva
Ganglia is a free, open-source, scalable distributed monitoring tool designed for high-performance computing systems. It runs on all major operating systems and can handle clusters with 2000 nodes. Ganglia uses RRDtool for data storage and visualization, XML for data representation and XDR for compact, portable data transport. It comes with a simple and easy to use web interface that can be used to display live statistics and metrics, such as average CPU load and network utilization for multiple systems.
In this tutorial, we will explain how to install Ganglia monitoring server and client on Ubuntu 18.04.
## Step 1 – Install Apache, MariaDB and PHP
Before starting, LAMP server must be installed in your system. If not installed, you can install it with the following command:
```
apt-get install apache2 mariadb-server php libapache2-mod-php php-mbstring php-curl php-zip
php-gd php-mysql php-curl unzip wget -y
```
Once installed, edit the php.ini file and tweak some settings:
```
nano /etc/php/7.2/apache2/php.ini
```
Change the following lines:
```
memory_limit = 256M
upload_max_filesize = 100M
max_execution_time = 360
max_input_vars = 1500
date.timezone = America/Chicago
```
Save and close the file, then restart the Apache service to apply the changes.
```
systemctl restart apache2
```
## Step 2 – Install Ganglia Server
By default, Ganglia is available in the Ubuntu 18.04 default repository. You can install it with other required packages using the following command:
```
apt-get install ganglia-monitor rrdtool gmetad ganglia-webfrontend -y
```
Note: You will be asked to automatically restart apache2 – select YES.
Once all the packages are installed, start the Ganglia service and enable it to start at boot with the following command:
```
systemctl start ganglia-monitor
systemctl start gmetad
systemctl enable ganglia-monitor
systemctl enable gmetad
```
## Step 3 – Configure Ganglia Server
First, you will need to edit the /etc/ganglia/gmetad.conf file and define your master server.
```
nano /etc/ganglia/gmetad.conf
```
Find the following line:
```
data_source "my cluster" localhost
```
Replace it with the following line:
```
data_source "mycluster" 50 localhost your-server-ip:8649
```
Save and close the file.
Next, edit the /etc/ganglia/gmond.conf file as shown below:
```
nano /etc/ganglia/gmond.conf
```
Change the following section:
```
cluster {
name = "mycluster"
owner = "unspecified"
latlong = "unspecified"
url = "unspecified"
}
```
```
udp_send_channel {
/* mcast_join = 239.2.11.71*/
host = your-server-ip
port = 8649
ttl = 1
}
```
```
udp_recv_channel {
/* mcast_join = 239.2.11.71 */
port = 8649
/*bind = 239.2.11.71 */
}
```
Save and close the file when you are finished.
Next, you will need to copy the Ganglia configuration file to the Apache virtual host directory.
You can copy it with the following command:
```
cp /etc/ganglia-webfrontend/apache.conf /etc/apache2/sites-enabled/ganglia.conf
```
Next, restart the Ganglia and Apache services to apply the changes:
```
systemctl restart ganglia-monitor
systemctl restart gmetad
systemctl restart apache2
```
## Step 4 – Install and Configure Ganglia Client
Next, you will need to install and configure the Ganglia client on the client system so that you can monitor it from the Ganglia server.
On the Ganglia client system, install the Ganglia client package with the following command:
```
apt-get install ganglia-monitor -y
```
Once installed, edit the /etc/ganglia/gmond.conf file and define the Ganglia server details:
```
nano /etc/ganglia/gmond.conf
```
Change the following section by adding your server IP:
```
udp_send_channel {
/* mcast_join = 239.2.11.71*/
host = your-server-ip
port = 8649
ttl = 1
}
```
Save and close the file, then restart the Ganglia service to apply the changes:
```
systemctl restart ganglia-monitor
```
## Step 5 – Access Ganglia Dashboard
Now, open your web browser and access the Ganglia dashboard using the URL http://your-server-ip/ganglia
You should see the following screen:
Now, click on the “**Choose a Node**” and select your server. You should see detailed information about your server in the following screen:
Next, click on the “**Choose a Node**” and select your client. You should see detailed information about your client in the following screen:
## Conclusion
Congratulations! You have successfully installed Ganglia monitoring server and client on Ubuntu 18.04. You can now add more clients and start monitoring from the Ganglia dashboard. This process can also be completed on a [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# How to Install Foreman Configuration Management and Provisioning Tool on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-foreman-configuration-management-and-provisioning-tool-on-centos-8/ | Published: 2020-10-21 | Updated: 2023-11-17 | Author: Hitesh Jethva
Foreman is a free and open-source tool used for provisioning, configuring, and monitoring servers. It uses configuration management tools including Salt, Chef and Puppet to automate repetitive tasks and deploy applications. Foreman comes with a CLI tool and web-based interface to manage servers in public and private clouds. It supports all major operating systems including, CentOS, Ubuntu, Fedora, CoreOS, Debian, RHEL and many more.
In this tutorial, we will show you how to install Foreman on CentOS 8.
## Step 1 – Setup Hostname
First, you will need to set up a hostname to resolve an IP address. You can set up it with the following command:
```
hostnamectl set-hostname foreman.example.com
```
Next, you will need to edit the file /etc/hosts and define your IP address.
```
nano /etc/hosts
```
Add the following lines:
```
your-server-ip foreman.example.com
```
Save and close the file when you are finished.
## Step 2 – Install Foreman Installer
By default, Foreman installer is not available in the CentOS default repository, so you will need to add the Puppet and Foreman repositories to your system. You can install them with the following command:
```
dnf install https://yum.puppet.com/puppet6-release-el-8.noarch.rpm -y
dnf install https://yum.theforeman.org/releases/2.1/el8/x86_64/foreman-release.rpm -y
```
Once both repositories are installed, install the Foreman installer with the following command:
```
dnf install foreman-installer -y
```
After installing the Foreman installer, you can proceed to the next step.
## Step 3 – Run Foreman Installer
Foreman installer installs everything including Apache, Puppet, Smart Proxy and TFTP. You can run the Foreman installer using the following command:
```
foreman-installer
```
Once the installation has been completed successfully, you should get the following output:
**Note:** Please note down the admin credentials as shown in the above output.
You can also check the status of the Foreman service with the following command:
```
systemctl status foreman
```
You should get the following output:
## Step 4 – Configure Firewall
If FirewallD is installed in your server, then you will also need to allow all required ports for external access. You can allow them with the following command:
```
firewall-cmd --add-port={22,53,80,443,3000,8140,3306,5432,8443,5910-5930}/tcp --permanent
firewall-cmd --add-port=67-69/udp --permanent
```
Next, reload the FirewallD to apply the configuration changes.
```
firewall-cmd --reload
```
## Step 5 – Access Foreman Web UI
Now, open your web browser and access the Foreman web interface using the URL **https://foreman.example.com**. You should see the Foreman login page as shown below:
Provide your admin username and password and click on the **Log** **In** button. You should see the Foreman dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed and configured Foreman on CentOS 8. You can now add any remote hosts and start managing through the Foreman dashboard on your [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Install Flectra on Debian 10
> URL: https://www.atlantic.net/vps-hosting/how-to-install-flectra-on-debian-10/ | Published: 2020-10-22 | Updated: 2024-09-25 | Author: Hitesh Jethva
Flectra is free and open-source ERP and CRM software ideal for small to large size companies. Flectra combines the capabilities of both CRM and ERP systems into a single and powerful package. It is a fork of Odoo Community Edition, and it aims replicate many of the features in Odoo Enterprise. This simple, feature-rich, and cost-effective ERP system will likely fulfill all your business needs.
**Features**
- CRM, HR and & Payroll
- Accounting and Financial Management
- Business Intelligence
- eCommerce – Online Store
- Inventory and Production Management
- BoM and Vendor Management
In this tutorial, we will explain how to install Flectra community edition on Debian 10.
## Step 1 – Install PostgreSQL
Flectra uses PostgreSQL as a database backend, so you will need to install it in your server. You can install it with the following command:
```
apt-get install postgresql -y
```
After installing Flectra, you will need to create a new user for Flectra. You can create it with the following command:
```
su - postgres -c "createuser -s flectra"
```
## Step 2 – Install Flectra Dependencies
Next, you will need to install all dependencies required for Flectra. You can install them with the following command:
```
apt-get install node-less gcc python3-venv build-essential python3-pillow python3-wheel python3-lxml python3-dev python3-pip python3-setuptools npm nodejs git gdebi libldap2-dev libsasl2-dev libxml2-dev libxslt1-dev libjpeg-dev libpq-dev -y
```
Once all the dependencies are installed, you will need to install the wkhtmltopdf tool in your system. The wkhtmltopdf is a command line toolset to render HTML into PDFs and various image formats. You can install it with the following command:
```
wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6-1/wkhtmltox_0.12.6-1.buster_amd64.deb
dpkg -i wkhtmltox_0.12.6-1.buster_amd64.deb
apt-get install -f
```
## Step 3 – Install Flectra
First, you will need to create a new system user to run Flectra. You can create it with the following command:
```
useradd -m -U -r -d /opt/flectra -s /bin/bash flectra
```
**Note**: The name of this user should be the same as your PostgreSQL user.
After creating Flectra user, switch user to flectra and download the latest version of Flectra with the following command:
```
su - flectra
git clone --depth=1 --branch=1.0 https://gitlab.com/flectra-hq/flectra.git flectra
```
Next, create a Python virtual environment for Flectra using the following command:
```
python3 -m venv flectra-venv
```
Next, run the following command to activate the virtual environment.
```
source flectra-venv/bin/activate
```
Next, you will need to edit the file requirements.txt and make some changes.
```
nano flectra/requirements.txt
```
Find the following lines:
```
psycopg2==2.7.3.1; sys_platform != 'win32'
psycopg2==2.8.3; sys_platform == 'win32'
```
And replace them with the following lines:
```
psycopg2==2.8.5; sys_platform != 'win32'
psycopg2==2.8.5; sys_platform == 'win32'
```
Save the file then install the required modules with the following command:
```
pip3 install -r flectra/requirements.txt
```
After installing all modules, deactivate from the virtual environment and exit from the flectra user with the following command:
```
deactivate
exit
```
## Step 4 – Configure Flectra
First, you will need to create some directories to store Flectra files, logs and addons. You can create them with the following command:
```
mkdir -p /opt/flectra/flectra-custom-addons /var/log/flectra /etc/flectra
touch /var/log/flectra/flectra.log
```
Next, provide proper ownership to the above directories with the following command:
```
chown -R flectra:flectra /opt/flectra/flectra-custom-addons /var/log/flectra /etc/flectra
```
Next, create a Flectra main configuration file using the following command:
```
nano /etc/flectra/flectra.conf
```
Add the following lines:
```
[options]
admin_passwd = flectra-master-password
db_host = False
db_port = False
db_user = flectra
db_password = False
logfile = /var/log/flectra/flectra.log
logrotate = True
proxy_mode = True
addons_path = /opt/flectra/flectra/addons, /opt/flectra/flectra-custom-addons
```
Save and close the file.
## Step 5 – Create a Systemd Service File for Flectra
Next, you will need to create a Flectra service file to manage the Flectra service. You can create it with the following command:
```
nano /etc/systemd/system/flectra.service
```
Add the following lines:
```
[Unit]
Description=flectra
[Service]
Type=simple
SyslogIdentifier=flectra
PermissionsStartOnly=true
User=flectra
Group=flectra
ExecStart=/opt/flectra/flectra-venv/bin/python3 /opt/flectra/flectra/flectra-bin -c /etc/flectra/flectra.conf
StandardOutput=journal+console
[Install]
WantedBy=multi-user.target
```
Save the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the Flectra service and enable it to start at system reboot with the following command:
```
systemctl start flectra
systemctl enable flectra
```
At this point, Flectra is started and listening on port 7073.
## Step 6 – Access the Flectra Dashboard
Now, open your web browser and access the Flectra dashboard using the URL **http://your-server-ip:7073**. You should get the following screen:
Provide your Flectra master password that you previously defined in Flectra configuration file, database, email, password, and click on the **Create** **database** button. You should see the Flectra dashboard in the following screen:
## Conclusion
In the above guide, you learned how to install Flectra in Python virtual environment on Debian 10. You can now use Flectra as an ERP or CRM system for your business needs; use Flectra on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# How to Setup HAProxy on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-setup-haproxy-on-centos-8/ | Published: 2020-10-22 | Updated: 2024-07-02 | Author: Hitesh Jethva
HAProxy stands for High Availability Proxy. Written in C, it is a free and open-source TCP/HTTP Load Balancer and proxying solution for TCP and HTTP-based applications. HAProxy is used to improve the performance of a server environment by distributing the workload across multiple servers.
HAProxy allows an application to restart automatically or reroute work to another server in the event of a failure. This powerful, high performance, reliable, and secure load balancer is the most widely used and was specially designed for very high traffic web sites.
In this tutorial, we will show you how to set up a high availability load balancer with HAProxy on CentOS 8.
## Prerequisites
**For this tutorial, we will use the following setup:**
**HAProxy Server:** – hostname : haproxy IP: 192.168.0.10
**Web Server 1:-** hostname : web1 IP: 192.168.0.11
**Web Server 2:-** hostname : web2 IP: 192.168.0.12
## Step 1 – Create an Atlantic.Net Cloud Server
First, log in to your [Atlantic.Net Cloud Server](https://cloud.atlantic.net/?page=userlogin). Create a new [server](https://www.atlantic.net/vps-hosting/how-to-create-new-atlantic-net-cloud-server/), choosing CentOS 8 as the operating system with at least 1GB RAM. Connect to your Cloud Server via SSH and log in using the credentials highlighted at the top of the page.
Once you are logged in to your CentOS 8 server, run the following command to update your base system with the latest available packages.
```
dnf update -y
```
## Step 2 – Install and Configure Nginx
***Note: Complete this step on WebServer 1 and WebServer2***
First, you will need to install the Nginx web server on web1 and web2 instances.
You can install Nginx by running the following command:
```
dnf install nginx -y
```
Once Nginx has been installed, start the Nginx service and enable it to start at boot on both instances:
```
systemctl start nginx
systemctl enable nginx
```
Next, modify the **index.html** file on each instance.
Modify **index.html** file on **web1** instance with the following command:
```
echo "This is My First Nginx Web Server" > /usr/share/nginx/html/index.html
```
Modify **index.html** file on **web2** instance with the following command:
```
echo "This is My Second Nginx Web Server" > /usr/share/nginx/html/index.html
```
Save and close the file when you are finished.
## Step 3 – Install and Configure HAProxy
***Note: Complete this step on HAProxy Server***
First, install HAProxy on the haproxy server instance with the following command:
```
dnf install haproxy -y
```
Once the installation is completed, backup the haproxy default configuration file:
```
mv /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg-bak
```
The configuration file is divided into four major sections.
1. **global settings:** Used to set process-wide parameters.
2. **defaults:** Used to set default parameters for all other sections.
3. **frontend:** Used to define how HAProxy is externally accessed to enable access to the backend.
4. **backend:** Used to define a set of servers to which the proxy will connect to forward incoming connections.
Next, create a new haproxy configuration file using the following command:
```
nano /etc/haproxy/haproxy.cfg
```
Add the following lines that match with your infrastructure:
#———————————————————————
```
global
log 127.0.0.1 local2
chroot /var/lib/haproxy
pidfile /var/run/haproxy.pid
maxconn 4000
user haproxy
group haproxy
daemon
```
# turn on stats unix socket
```
stats socket /var/lib/haproxy/stats
```
# utilize system-wide crypto-policies
```
ssl-default-bind-ciphers PROFILE=SYSTEM
ssl-default-server-ciphers PROFILE=SYSTEM
```
#———————————————————————
```
defaults
mode http
log global
option httplog
option dontlognull
option http-server-close
option forwardfor except 127.0.0.0/8
option redispatch
retries 3
timeout http-request 10s
timeout queue 1m
timeout connect 10s
timeout client 1m
timeout server 1m
timeout http-keep-alive 10s
timeout check 10s
maxconn 3000
```
#———————————————————————
# main frontend which proxys to the backends
#———————————————————————
```
frontend haproxy_balancer # define the name of the frontend.
bind 192.168.0.10:80 # IP address of HAProxy server
option http-server-close
option forwardfor
stats uri /haproxy?stats # Specify the HAProxy status page.
default_backend webservers
```
#———————————————————————
# round robin balancing between the various backends
#———————————————————————
backend webservers # Specify a name for identifying an application
```
mode http
balance roundrobin # defines the roundrobin load balancer scheduling algorithm
option httpchk HEAD / HTTP/1.1\r\nHost:\ localhost
server nginx-web1 192.168.0.11:80 check # IP address of the first backend server
server nginx-web2 192.168.0.12:80 check # IP address of the second backend server
```
**Note: Ensure you amend the IP address above with the IP relevant to your server setup**
Save and close the file when you are finished. Then, check the haproxy configuration file for any errors with the following command:
```
haproxy -c -f /etc/haproxy/haproxy.cfg
```
You should get the following output:
```
Configuration file is valid
```
Finally, start the haproxy service and enable it to start at boot with the following command:
```
systemctl start haproxy
systemctl enable haproxy
```
You can also verify haproxy with the following command:
```
systemctl status haproxy
```
You should get the following output:
- ```
haproxy.service - HAProxy Load Balancer
```
```
Loaded: loaded (/usr/lib/systemd/system/haproxy.service; disabled; vendor preset: disabled)
Active: active (running) since Fri 2020-04-24 02:14:55 EDT; 5min ago
Process: 1371 ExecStartPre=/usr/sbin/haproxy -f $CONFIG -c -q (code=exited, status=0/SUCCESS)
Main PID: 1373 (haproxy)
Tasks: 2 (limit: 6087)
Memory: 2.8M
CGroup: /system.slice/haproxy.service
├─1373 /usr/sbin/haproxy -Ws -f /etc/haproxy/haproxy.cfg -p /run/haproxy.pid
└─1374 /usr/sbin/haproxy -Ws -f /etc/haproxy/haproxy.cfg -p /run/haproxy.pid
Apr 24 02:14:55 haproxy systemd[1]: Starting HAProxy Load Balancer...
Apr 24 02:14:55 haproxy systemd[1]: Started HAProxy Load Balancer.
```
## Step 4 – Configure HAProxy Logging
HAProxy logging allows you to see statistics of each connection to your backend web servers.
You can configure rsyslog by editing the file /etc/rsyslog.conf:
```
nano /etc/rsyslog.conf
```
Uncomment the following line:
```
module(load="imudp")
input(type="imudp" port="514")
```
Save and close the file when you are finished. Next, you will need to configure a rsyslog server to receive and process HAProxy log messages.
To do so, create a new haproxy.conf configuration file:
```
nano /etc/rsyslog.d/haproxy.conf
```
Add the following lines:
```
local2.=info /var/log/haproxy-access.log
local2.notice /var/log/haproxy-info.log
```
Save and close the file when you are finished. Then, restart rsyslog service and enable it to start at boot with the following command:
```
systemctl restart rsyslog
systemctl enable rsyslog
```
## Step 5 – Test HAProxy Load Balancing
At this point, HAProxy is installed and configured. It’s time to test whether the load balancing is working or not.
Open your web browser and type your HAProxy IP http://192.168.0.10. You should see the content of your first Nginx web server in the following screen:
Next, refresh the webpage. You should see the content of your second Nginx web server in the following screen:
You can view the status of haproxy using the URL http://192.168.0.10/haproxy?stats. You should see the health of your servers, current request rates, response times and other metrics in the following screen:
## Conclusion
In the above guide, we learned how to set up a high availability load balancer with HAProxy on CentOS 8. You can now easily design and configure load balancing to suit your IT infrastructure and application’s requirements; try it out on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How To Install Jitsi Meet Video Conferencing Application on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-jitsi-meet-video-conferencing-application-on-ubuntu-20-04/ | Published: 2020-10-23 | Updated: 2024-06-30 | Author: Hitesh Jethva
Jitsi is a free, open-source, multiplatform video conferencing and instant messaging application for web & mobile. It works on Linux, macOS, Windows, iOS and Android, and you can use it as a standalone app or embed it in your web application. Jitsi Meet Audio/Video Chat is fully encrypted and supports several protocols including SIP, XMPP/Jabber, ICQ/AIM, Yahoo!, GTalk/Hangouts extensions, and ZRTP.
With Jitsi Meet, you can share your desktop & presentations, invite users to a conference via a simple URL, edit documents with Etherpad, and pick fun meeting URLs for every meeting.
In this tutorial, we will explain how to install Jitsi Meet Video Conferencing Server on Ubuntu 20.04.
## Step 1 – Install Jitsi Meet
Before starting, you will need to install the required dependencies in your server. You can install them by running the following command:
```
apt-get update -y
apt-get install apt-transport-https software-properties-common -y
```
Once installed, download and add the Jitsi GPG key with the following command:
```
wget -qO - https://download.jitsi.org/jitsi-key.gpg.key | apt-key add -
```
Next, add the Jitsi repository using the following command:
```
echo 'deb https://download.jitsi.org stable/' | tee /etc/apt/sources.list.d/jitsi-stable.list
```
Next, update the repository and install the Jitsi Meet with the following command:
```
apt-get update -y
apt-get install jitsi-meet
```
During the installation, you will need to provide a valid domain name as shown below:
Provide your domain name and click on the **Ok** button. You will be asked to generate a new self-signed TLS certificate so that later you can obtain and install a trusted Let’s Encrypt certificate, as shown below:
Select the first option and hit **Enter** to start the installation. Once the installation has been completed successfully, you can verify the status of Jitsi service with the following command:
```
systemctl status jitsi-videobridge2
```
You should get the following output:
## Step 2 – Secure Jitsi Meet with a Let’s Encrypt Certificate
Before starting, you will need to install the Certbot client in your server to install and manage the Let’s Encrypt Certificate.
First, add the Certbot repository with the following command:
```
add-apt-repository ppa:ahasenack/certbot-tlssni01-1875471
sudo add-apt-repository ppa:certbot/certbot
```
Next, update the repository and install the Certbot client with the following command:
```
apt-get update -y
apt-get install certbot python3-certbot-nginx -y
```
The Jitsi Let’s Encrypt installation script expects certbot in /usr/local/sbin directory while Ubuntu installs it in /usr/bin, so create a symbolic link of the script with the following command:
```
ln -s /usr/bin/certbot /usr/local/sbin/certbot
```
Next, update install-letsencrypt-cert.sh to use certbot instead of certbot-auto.
```
sed -i 's/\.\/certbot-auto/certbot/g' /usr/share/jitsi-meet/scripts/install-letsencrypt-cert.sh
```
Next, run the install-letsencrypt-cert.sh script to secure Jitsi Meet with Let’s Encrypt SSL:
```
/usr/share/jitsi-meet/scripts/install-letsencrypt-cert.sh
```
You will be asked to provide your email address and accept the terms of service as shown below:
————————————————————————-
```
This script will:
- Need a working DNS record pointing to this machine(for domain jitsi.example.com)
- Download certbot-auto from https://dl.eff.org to /usr/local/sbin
- Install additional dependencies in order to request Let’s Encrypt certificate
- If running with jetty serving web content, will stop Jitsi Videobridge
- Configure and reload nginx or apache2, whichever is used
- Configure the coturn server to use Let's Encrypt certificate and add required deploy hooks
- Add command in weekly cron job to renew certificates regularly
You need to agree to the ACME server's Subscriber Agreement (https://letsencrypt.org/documents/LE-SA-v1.1.1-August-1-2016.pdf)
by providing an email address for important account notifications
Enter your email and press [ENTER]: admin@example.com
```
Provide your valid email address and hit **Enter**. Once the installation is finished, you should see the following output:
```
Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator webroot, Installer None
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for jitsi.example.com
Using the webroot path /usr/share/jitsi-meet for all unmatched domains.
Waiting for verification...
Cleaning up challenges
Running deploy-hook command: /etc/letsencrypt/renewal-hooks/deploy/0000-coturn-certbot-deploy.sh
Output from deploy-hook command 0000-coturn-certbot-deploy.sh:
Configuring turnserver
```
```
IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at:
/etc/letsencrypt/live/jitsi.example.com/fullchain.pem
Your key file has been saved at:
/etc/letsencrypt/live/jitsi.example.com/privkey.pem
Your cert will expire on 2020-08-31. To obtain a new or tweaked
version of this certificate in the future, simply run certbot
again. To non-interactively renew *all* of your certificates, run
"certbot renew"
- Your account credentials have been saved in your Certbot
configuration directory at /etc/letsencrypt. You should make a
secure backup of this folder now. This configuration directory will
also contain certificates and private keys obtained by Certbot so
making regular backups of this folder is ideal.
- If you like Certbot, please consider supporting our work by:
Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate
Donating to EFF: https://eff.org/donate-le
```
## Step 3 – Access Jitsi Meet
Now, open your web browser and type the URL https://jitsi.example.com. You will be redirected to the following page:
Type your meeting a name and click the **Go** button. Once the meeting is started, you should see the following screen:
## Conclusion
Congratulations! you have successfully deployed a Jitsi Meet Video Conferencing server on Ubuntu 20.04. You can now install the Jitsi client app in your mobile device and start exploring Jitsi. Try out Jitsi on VPS [Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net and visit the [Jitsi documentation](https://github.com/jitsi/jitsi-meet/wiki) for more information.
---
# How to Set Up Firewall with Firewalld on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-set-up-firewall-with-firewalld-on-centos-8/ | Published: 2020-10-23 | Updated: 2023-11-27 | Author: Hitesh Jethva
A firewall is a way to protect your system from unwanted traffic from outside networks. Free and commercial firewall tools are plentiful; some of them include Iptables, UFW, Juniper, pfSense, SonicWall, and more.
Among them, FirewallD is a free firewall software tool for CentOS/RHEL/Fedora operating system. It is a frontend controller for iptables and provides a command-line interface to implement firewall rules. Compared to Iptables, FirewallD uses zones and services instead of chains and rules and manages rulesets dynamically. FirewallD provides the firewall-cmd command line tool to manage runtime and permanent configuration.
## Step 1: Install Firewalld
By default, FirewallD comes pre-installed in the CentOS operating system. If not installed, you can install it by running the following command:
```
dnf install firewalld -y
```
Once installed, start the FirewallD service and enable it to start at system reboot with the following command:
```
systemctl start firewalld
systemctl enable firewalld
```
You can also verify FirewallD’s status using the following command:
```
firewall-cmd --state
```
Output:
```
running
```
## Step 2: Basic FirewallD Usage
FirewallD manages a set of rules using zones. Each zone has its own configuration to accept or deny packets depending on the level of trust you have in the networks your computer is connected to.
You can list all available zones using the following command:
```
firewall-cmd --get-zones
```
You should see the following list:
```
block dmz drop external home internal public trusted work
```
To get a list of all active zones, run the following command:
```
firewall-cmd --get-active-zones
```
You should see the following list:
```
public
interfaces: eth0 eth1
```
You can list the default zone set for network connections using the following command:
```
firewall-cmd --get-default-zone
```
Output:
```
public
```
To change the default zone from public to home using the following command:
```
firewall-cmd --set-default-zone=home --permanent
```
To display more information about any zone using the following command:
```
firewall-cmd --info-zone public
```
You should get the following output:
```
public (active)
target: default
icmp-block-inversion: no
interfaces: eth0 eth1
sources:
services: cockpit dhcpv6-client ssh
ports:
protocols:
masquerade: no
forward-ports:
source-ports:
icmp-blocks:
rich rules:
```
You can also list all available services by running the following command:
```
firewall-cmd --get-services
```
You should get the following output:
```
RH-Satellite-6 amanda-client amanda-k5-client amqp amqps apcupsd audit bacula bacula-client bb bgp bitcoin bitcoin-rpc bitcoin-testnet bitcoin-testnet-rpc bittorrent-lsd ceph ceph-mon cfengine cockpit condor-collector ctdb dhcp dhcpv6 dhcpv6-client distcc dns dns-over-tls docker-registry docker-swarm dropbox-lansync elasticsearch etcd-client etcd-server finger freeipa-4 freeipa-ldap freeipa-ldaps freeipa-replication freeipa-trust ftp ganglia-client ganglia-master git grafana gre high-availability http https imap imaps ipp ipp-client ipsec irc ircs iscsi-target isns jenkins kadmin kdeconnect kerberos kibana klogin kpasswd kprop kshell kube-apiserver ldap ldaps libvirt libvirt-tls lightning-network llmnr managesieve matrix mdns memcache minidlna mongodb mosh mountd mqtt mqtt-tls ms-wbt mssql murmur mysql nfs nfs3 nmea-0183 nrpe ntp nut openvpn ovirt-imageio ovirt-storageconsole ovirt-vmconsole plex pmcd pmproxy pmwebapi pmwebapis pop3 pop3s postgresql privoxy prometheus proxy-dhcp ptp pulseaudio puppetmaster quassel radius rdp redis redis-sentinel rpc-bind rsh rsyncd rtsp salt-master samba samba-client samba-dc sane sip sips slp smtp smtp-submission smtps snmp snmptrap spideroak-lansync spotify-sync squid ssdp ssh steam-streaming svdrp svn syncthing syncthing-gui synergy syslog syslog-tls telnet tentacle tftp tftp-client tile38 tinc tor-socks transmission-client upnp-client vdsm vnc-server wbem-http wbem-https wsman wsmans xdmcp xmpp-bosh xmpp-client xmpp-local xmpp-server zabbix-agent zabbix-server
```
## Step 3: Allow and Deny Ports with Firewalld
Firewalld provides firewall-cmd command line tool to add and remove ports in your system.
For example, to allow TCP port 80 and 22 in the public zone, run the following command:
```
firewall-cmd --zone=public --permanent --add-port=80/tcp --add-port=22/tcp
```
Next, reload the FirewallD daemon to save the configuration:
```
firewall-cmd --reload
```
Now, list the added port with the following command:
```
firewall-cmd --info-zone public
```
You should see the following output:
```
public (active)
target: default
icmp-block-inversion: no
interfaces: eth0 eth1
sources:
services: cockpit dhcpv6-client ssh
ports: 80/tcp 22/tcp
protocols:
masquerade: no
forward-ports:
source-ports:
icmp-blocks:
rich rules:
```
You can also deny or remove the port from the zone easily using the option –remove-port.
For example, to deny or remove the port 80 from the public zone, run the following command:
```
firewall-cmd --zone=public --permanent --remove-port=80/tcp
```
## Step 4: Allow and Deny Services with FirewallD
You can also allow and deny by service name instead of using a port with the FirewallD.
For example, allow FTP service in the public zone by running the following command:
```
firewall-cmd --zone=public --permanent --add-service=ftp
firewall-cmd --reload
```
You can deny or remove the FTP service from the public zone using the following command:
:
```
firewall-cmd --zone=public --permanent --remove-service=ftp
firewall-cmd --reload
```
## Step 5: Setup IP Masquerading with FirewallD
IP masquerading is a process or method that allows your computers in a network with private IP addresses to communicate with the Internet using your server’s address. It is very useful when you want another computer to communicate to the Internet without buying additional IPs from your ISP.
Before setting up IP masquerading, check if masquerading is active or not with the following command:
```
firewall-cmd --zone=public --query-masquerade
```
You should see that IP masquerading is disabled in the public zone as shown below:
```
no
```
Now, set the IP masquerading using the following command:
```
firewall-cmd --zone=public --add-masquerade
firewall-cmd --reload
```
You can also disable the IP masquerading using the option –remove-masquerade:
```
firewall-cmd --zone=public --remove-masquerade
firewall-cmd --reload
```
## Conclusion
In the above guide, you learned how to use FirewallD to block unwanted traffic in your system. You should now be able to limit all unnecessary connections and protect your server from attackers. Try FirewallD on an Atlantic.Net [VPS](https://www.atlantic.net/vps-hosting/)!
---
# Install Graylog Monitoring Server on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/install-graylog-monitoring-server-on-centos-8/ | Published: 2020-10-23 | Updated: 2023-11-18 | Author: Hitesh Jethva
Graylog is a powerful platform for simplified log management of structured or unstructured data. Additionally, it is useful for debugging applications.
Graylog is broadly based upon Scala, MongoDB, and Elasticsearch. It has a main server to receive data from the clients that may be installed over different servers. Similarly, Graylog features a web interface for the visualization of data. It facilitates work over the logs that the main server aggregates.
Graylog is primarily used as a stash for logs for any web application in use. Alternately, Graylog is also effective when working with raw strings, such as Syslog.
In this tutorial, we will show you how to install the Graylog Monitoring server on CentOS 8.
## Step 1 – Install Required Dependencies
Before starting, you will need to install Java and other required dependencies on your server.
First, install the EPEL repository with the following command:
```
dnf install epel-release -y
```
Next, install the Java using the following command:
```
dnf install -y java-1.8.0-openjdk-headless -y
```
Once Java is installed, you can verify it with the following command:
```
java -version
```
You should get the following output:
```
openjdk version "1.8.0_265"
OpenJDK Runtime Environment (build 1.8.0_265-b01)
OpenJDK 64-Bit Server VM (build 25.265-b01, mixed mode)
```
Next, install other required packages with the following command:
```
dnf install wget pwgen perl-Digest-SHA -y
```
## Step 2 – Install Elasticsearch
Graylog uses Elasticsearch to store log messages and its search function. By default, the latest version of Elasticsearch is not available in the CentOS 8 default repository, so you will need to add the Elasticsearch repo to your system.
First, import the GPG key with the following command:
```
rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
```
Next, create Elasticsearch repo with the following command:
```
nano /etc/yum.repos.d/elasticsearch.repo
```
Add the following lines:
```
[elasticsearch-6.x]
name=Elasticsearch repository for 6.x packages
baseurl=https://artifacts.elastic.co/packages/oss-6.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
```
Save and close the file then install the Elasticsearch with the following command:
```
dnf install elasticsearch-oss -y
```
Once the Elasticsearch is installed, edit the Elasticsearch main configuration file:
```
nano /etc/elasticsearch/elasticsearch.yml
```
Define your cluster name and add another line as shown below:
```
cluster.name: my-graylog
action.auto_create_index: false
```
Save the file, then reload the systemd daemon and enable Elasticsearch to start at system reboot with the following command:
```
systemctl daemon-reload
systemctl enable elasticsearch
```
Next, restart the Elasticsearch service with the following command:
```
systemctl restart elasticsearch
```
You can now check the Elasticsearch response using the following command:
```
curl -X GET http://localhost:9200
```
If everything is correct, you should get the following output:
```
{
"name" : "7FL0524",
"cluster_name" : "my-graylog",
"cluster_uuid" : "C4OvK0Y_TjCiVzBiHbz0pA",
"version" : {
"number" : "6.8.12",
"build_flavor" : "oss",
"build_type" : "rpm",
"build_hash" : "7a15d2a",
"build_date" : "2020-08-12T07:27:20.804867Z",
"build_snapshot" : false,
"lucene_version" : "7.7.3",
"minimum_wire_compatibility_version" : "5.6.0",
"minimum_index_compatibility_version" : "5.0.0"
},
"tagline" : "You Know, for Search"
}
```
## Step 3 – Install MongoDB Server
Graylog uses MongoDB to store configurations and meta information. By default, MongoDB is not available in the CentOS 8 standard repository, so you will need to create a repository for MongoDB.
You can create it with the following command:
```
nano /etc/yum.repos.d/mongodb-org-4.0.repo
```
Add the following lines:
```
[mongodb-org-4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/8/mongodb-org/4.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.2.asc
```
Save and close the file, then update the repository with the following command:
```
dnf update -y
```
Next, install the MongoDB server with the following command:
```
dnf install mongodb-org -y
```
Once MongoDB is installed, start the MongoDB service and enable it to start at system reboot:
```
systemctl start mongod
systemctl enable mongod
```
## Step 4 – Install and Configure Graylog Server
By default, the Graylog server package is not available in the CentOS 8 standard repository, so you will need to create a repo for Graylog.
You can install the Graylog repo using the following command:
```
dnf install https://packages.graylog2.org/repo/packages/graylog-3.2-repository_latest.rpm -y
```
Once the repository is created, you can install the Graylog server with the following command:
```
dnf install graylog-server -y
```
After installing Graylog server, you will need to generate a secret key for Graylog. You can generate it with the following command:
```
pwgen -N 1 -s 96
```
Output:
```
un5R8H7vmoq1japNYvHD2pEkawKyBzZpWeFsfVEk4Ustl5sWPtcdMbgTV18mHyqBnBK0sk83fcEmceTtyNzxntWqWhNPYe9N
```
You will also need to generate a secure password for Graylog. You can generate it with the following command:
```
echo -n your-password | shasum -a 256
```
You should get the following output:
```
616384da8ed2fb86db3462ec827bc433256324e323a2438f48ae32930e707065 -
```
**Note**: You can use this password “your-password” to log in to the Graylog web interface.
Next, edit the Graylog main configuration file and define your secret key, password, and other settings:
```
nano /etc/graylog/server/server.conf
```
Change the following lines:
```
password_secret = un5R8H7vmoq1japNYvHD2pEkawKyBzZpWeFsfVEk4Ustl5sWPtcdMbgTV18mHyqBnBK0sk83
fcEmceTtyNzxntWqWhNPYe9N
root_username = admin
root_password_sha2 = 616384da8ed2fb86db3462ec827bc433256324e323a2438f48ae32930e707065
root_timezone = UTC
http_bind_address = your-server-ip:9000
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the Graylog service and enable it to start at system reboot with the following command:
```
systemctl start graylog-server
systemctl enable graylog-server
```
You can check the Graylog server log to verify whether the Graylog server is started or not:
```
tail -f /var/log/graylog-server/server.log
```
If the Graylog server is started successfully, you should get the following output:
```
2020-10-02T11:46:15.649-04:00 INFO [InputSetupService] Triggering launching persisted inputs,
node transitioned from Uninitialized [LB:DEAD] to Running [LB:ALIVE]
2020-10-02T11:46:15.654-04:00 INFO [ServerBootstrap] Graylog server up and running.
```
At this point, the Graylog server is started and listening on port 9000.
## Step 5 – Access Graylog Interface
Now, you can access the Graylog web interface using the URL **http://your-server-ip:9000**. You should see the Graylog login page:
Provide your admin username and password and click on the **Sign**–**in** button. You should see the Graylog dashboard on the following page:
## Conclusion
Congratulations! You have successfully installed and configured the Graylog server on CentOS 8. You can now configure your Graylog server to receive Rsyslog logs from external servers. For more information, you can visit the Graylog [documentation](https://docs.graylog.org/). Get started with Graylog today on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Install Dgraph on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-dgraph-on-centos-8/ | Published: 2020-10-24 | Updated: 2026-05-04 | Author: Hitesh Jethva
Dgraph is a free, open-source, distributed GraphQL database with a graph backend written in Go language. It is one of the most advanced graphing and multi-model NoSQL database systems available to small and large companies that process massive amounts of data. Dgraph aims to provide Google production-level scale and throughput and serve real-time user queries. It is capable of handling terabytes of structured data running on commodity hardware with low latency for real-time user queries. Dgraph is fast and highly available, offers flexible schema, distributed and transactional graphs, and much more.
In this tutorial, we will show you how to install the Dgraph database system on CentOS 8.
## Step 1 – Install Dgraph
A simple and easy way to install Dgraph is to run the Dgraph auto-installation script. You can run the Dgraph installation script using the following command:
```
curl https://get.dgraph.io -sSf | bash
```
You will need to accept the terms of service to install the Dgraph in your system, as shown below:
```
By downloading Dgraph you agree to the Dgraph Community License (DCL) terms
shown above. An open-source (Apache 2.0) version of Dgraph without any
DCL-licensed enterprise features is available by building from the Dgraph
source code. See the source installation instructions for more info:
https://github.com/dgraph-io/dgraph#install-from-source
Do you agree to the terms of the Dgraph Community License? [Y/n] Y
Latest release version is v20.07.0.
Downloading checksum file for v20.07.0 build.
######################################################################## 100.0%##O#- # ######################################################################## 100.0%
Download complete.
Comparing checksums for dgraph binaries
Downloading https://github.com/dgraph-io/dgraph/releases/download/v20.07.0/dgraph-linux-amd64.tar.gz
######################################################################## 100.0%#=#=# ######################################################################## 100.0%
Download complete.
Inflating binaries (password may be required).
Dgraph binaries v20.07.0 have been installed successfully in /usr/local/bin.
```
Once Dgraph is installed, you can proceed to the next step.
## Step 2 – Create a User for Dgraph
Next, you will need to create a separate user and group to run the Dgraph service. You can create them with the following command:
```
groupadd --system dgraph
useradd --system -d /var/run/dgraph -s /bin/false -g dgraph dgraph
```
Next, you will need to create directories to store Dgraph log and state files. You can create them with the following command:
```
mkdir -p /var/log/dgraph
mkdir -p /var/run/dgraph/{p,w,zw}
```
Next, change the ownership of the directory to dgraph as shown below:
```
chown -R dgraph:dgraph /var/{run,log}/dgraph
```
## Step 3 – Create a Systemd Service File for Dgraph
Next, you will need to create some systemd service files to manage Dgraph.
First, create a dgraph.service file with the following command:
```
nano /etc/systemd/system/dgraph.service
```
Add the following lines:
```
[Unit]
Description=dgraph.io data server
Wants=network.target
After=network.target dgraph-zero.service
Requires=dgraph-zero.service
[Service]
Type=simple
ExecStart=/usr/local/bin/dgraph alpha --lru_mb 2048 -p /var/run/dgraph/p -w /var/run/dgraph/w
StandardOutput=journal
StandardError=journal
User=dgraph
Group=dgraph
[Install]
WantedBy=multi-user.target
```
Save and close the file when you are finished.
Next, create a dgraph-zero.service file with the following command:
```
nano /etc/systemd/system/dgraph-zero.service
```
Add the following lines:
```
[Unit]
Description=dgraph.io zero server
Wants=network.target
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/dgraph zero --wal /var/run/dgraph/zw
StandardOutput=journal
StandardError=journal
User=dgraph
Group=dgraph
[Install]
WantedBy=multi-user.target
RequiredBy=dgraph.service
```
Save and close the file when you are finished.
Next, create a graph-ui.service file with the following command:
```
nano /etc/systemd/system/dgraph-ui.service
```
Add the following lines:
```
[Unit]
Description=dgraph.io UI server
Wants=network.target
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/dgraph-ratel
StandardOutput=journal
StandardError=journal
User=dgraph
Group=dgraph
[Install]
WantedBy=multi-user.target
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start and enable all services to start at system reboot with the following command:
```
systemctl enable --now dgraph
systemctl enable --now dgraph-ui
systemctl enable --now dgraph-zero
systemctl start dgraph
systemctl start dgraph-ui
systemctl start dgraph-zero
```
At this point, all Dgraph services are running and listening on port 8000 and 8080. You can check them with the following command:
```
ss -tunelp | grep 8000
```
You should get the following output:
```
tcp6 0 0 :::8000 :::* LISTEN 990 24437 1066/dgraph-ratel
ss -tunelp | grep 8080
```
You should get the following output:
```
tcp6 0 0 :::8080 :::* LISTEN 990 24979 1083/dgraph
```
## Step 4 – Access Dgraph Web Interface
Now, open your web browser and access the Dgraph web interface using the URL http://your-server-ip:8000. You should see the following page:
Click on the **Launch** **Latest** button. You will be redirected to the following page:
Provide your Dgraph server URL and click on the **Continue** button. You should see the following page:
Click on the **Continue** button. You will be redirected to the Dgraph dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed Dgraph on CentOS 8. You can now start building your application with Dgraph and GraphQL on your Atlantic.Net [VPS](https://www.atlantic.net/vps-hosting/). For more information, visit the Dgraph official [documentation](https://docs.dgraph.io/).
---
# How to Install Mautic Marketing Automation Tool on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-mautic-marketing-automation-tool-on-ubuntu-20-04/ | Published: 2020-10-24 | Updated: 2023-11-18 | Author: Hitesh Jethva
Mautic is a very popular open-source email marketing and lead management software that helps you create customized email templates and email campaigns. It is an alternative to other [email service providers](https://www.omnisend.com/blog/email-marketing-software/), like MailChimp, and can be integrated with third-party SMTP relay services, like Gmail, Mandrill, Sendgrid, and others. Mautic offers a rich set of features, including customizable dripflow programs, marketing campaigns, social media monitoring, and many more.
In this tutorial, we will show you how to install Mautic Marketing Automation Tool on Ubuntu 20.04.
## Step 1 – Install Apache, MariaDB, and PHP
First, you will need to install Apache web server and MariaDB in your server. You can install them using the following command:
```
apt-get install apache2 mariadb-server -y
```
Once both packages are installed, you will also need to install PHP version 7.2 on your server.
By default, Ubuntu 20.04 ships with PHP version 7.4, so you will need to add the Ondrej PHP repository in your system.
You can add it with the following command:
```
apt-get install software-properties-common -y
add-apt-repository ppa:ondrej/php
apt-get update -y
```
Once the repository is added, install PHP with all required extensions by running the following command:
```
apt-get install php7.2 libapache2-mod-php7.2 php7.2-common php7.2-gmp php7.2-curl php7.2-intl
php7.2-mbstring php7.2-xmlrpc php7.2-mysql php7.2-bcmath php7.2-gd php7.2-xml php7.2-cli
php7.2-zip php7.2-imap curl git -y
```
After installing PHP, edit the php.ini file and change some desired settings:
```
nano /etc/php/7.2/apache2/php.ini
```
Change the following lines:
```
memory_limit = 512M
upload_max_filesize = 100M
max_execution_time = 360
date.timezone = America/Chicago
```
Save and close the file then restart Apache web service to apply the changes:
```
systemctl restart apache2
```
## Step 2 – Configure Database for Mautic
First, log in to MariaDB shell with the following command:
```
mysql
```
Once logged in, create a database and user for Mautic with the following command:
```
CREATE DATABASE mauticdb;
CREATE USER 'mauticuser'@'localhost' IDENTIFIED BY 'password';
```
Next, grant all the privileges to the Mautic database with the following command:
```
GRANT ALL ON mauticdb.* TO 'mauticuser'@'localhost' IDENTIFIED BY 'password' WITH
GRANT OPTION;
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Download Mautic
First, change the directory to the Apache web root directory and download the latest version of the Mautic from the Git Hub using the following command:
```
cd /var/www/html
git clone https://github.com/mautic/mautic.git
```
Once downloaded, install the Composer in your system with the following command:
```
curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
```
Next, change the directory to mautic and install all PHP dependencies with the following command:
```
cd mautic
composer install
```
Next, change the ownership of the mautic to www-data and set proper permissions with the following command:
```
chown -R www-data:www-data /var/www/html/mautic/
chmod -R 755 /var/www/html/mautic/
```
## Step 4 – Configure Apache for Mautic
First, create an Apache virtual host configuration file to serve Mautic.
```
nano /etc/apache2/sites-available/mautic.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
DocumentRoot /var/www/html/mautic
ServerName example.com
ServerAlias www.example.com
Options +FollowSymlinks
AllowOverride All
Require all granted
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
```
Save and close the file, then enable the Mautic virtual host file and rewrite module with the following command:
```
a2ensite mautic.conf
a2enmod rewrite
```
Next, restart the Apache web service to apply the changes:
```
systemctl restart apache2
```
## Step 5 – Access Mautic Web UI
At this point, Mautic is installed. Now, open your web browser and access the Mautic web UI using the URL **http://example.com**. You should see the following screen:
Click on the **Next** **Step** button. You should see the following screen:
Provide your Mautic database details and click on the **Next** **Step** button. You should see the following screen:
Provide your Mautic admin username, email, and password and click on the **Next** **Step** button. You should see the following screen:
Provide your desired SMTP settings and click on the **Next** **Step** button. You will be redirected to the Mautic login screen:
Provide your Mautic admin username and password and click on the **login** button. You should see the Mautic dashboard in the following screen:
## Conclusion
Congratulations! You have successfully installed Mautic on Ubuntu 20.04. You can now install additional plugins to extend the functionality of Mautic and create your own email campaigns; try it out on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Install Chef Automation Server on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-chef-automation-server-on-ubuntu-20-04/ | Published: 2020-10-25 | Updated: 2023-11-23 | Author: Hitesh Jethva
Chef is a powerful platform for automation, simplifying how infrastructure is managed, deployed, or configured across a network. Chef operates by transforming the infrastructure into code. The developer can then deploy or manage resources across multiple servers or nodes, but before the developer deploys the code over any other environment, they first create and test it over a workstation. Overall, Chef is one of the best tools for administering infrastructure from a workstation.
For compliance, node visibility, and workflow, Chef Automate makes available a full suite of enterprise capabilities. The software integrates with Open source products such as Habitat, InSpec, and Chef.
In this tutorial, we will show you how to install the Chef server and client on Ubuntu 20.04.
**Note: **The procedure uses requires two Ubuntu instances:
- One Client
- One Server
## Step 1 – Setup Hostname
Before starting, you will need to set up a fully qualified hostname and hostname resolution on your Chef server.
First, set up the hostname with the following commands:
```
apt-get update -y
```
```
hostnamectl set-hostname chef.example.com
```
Next, open /etc/hosts file and bind your server IP address with hostname:
```
nano /etc/hosts
```
Add the following line:
```
chef-server-ip chef.example.com
```
Save and close the file when you are finished.
## Step 3 – Install Chef Server
By default, Chef package is not available in the Ubuntu 20.04 default repository, so you will need to download it from their official website.
First, install the required dependencies by running the following command on the Chef server:
```
apt-get install curl wget gnupg2 -y
```
Next, download the Chef package with the following command:
```
wget https://packages.chef.io/files/stable/chef-server/13.1.13/ubuntu/18.04/chef-server-core_13.1.13-1_amd64.deb
```
Once the package is downloaded, install it by running the following command:
```
dpkg -i chef-server-core_13.1.13-1_amd64.deb
```
Once the package is installed, you will need to reconfigure the Chef server. You can reconfigure it with the following command:
```
chef-server-ctl reconfigure
```
You will be asked to accept the term of license as shown below:
```
+---------------------------------------------+
Chef License Acceptance
Before you can continue, 3 product licenses
must be accepted. View the license at
https://www.chef.io/end-user-license-agreement/
Licenses that need accepting:
* Chef Infra Server
* Chef Infra Client
* Chef InSpec
Do you accept the 3 product licenses (yes/no)?
> yes
```
Type yes to accept the license and hit enter to continue. Once the installation has been completed, you should get the following output:
```
Running handlers:
Running handlers complete
Chef Infra Client finished, 482/1032 resources updated in 04 minutes 34 seconds
Chef Server Reconfigured!
```
**Note**: The installation will take over 5 minutes
## Step 4 – Create an Administrator Account and Organization
First, create a directory to store all keys.
```
mkdir ~/.chef_key
```
Next, run the following command to create an administrator account:
```
chef-server-ctl user-create atlanticuser Atlantic User admin@example.com 'mypassword' --filename ~/.chef_key/atlantic.pem
```
The above command will create an admin account with the name atlanticuser, full name “Atlantic User,” password “mypassword,” and generate the keyfile at ~/.chef_key/atlantic.pem.
Next, create an organization with the following command:
```
chef-server-ctl org-create atlantic "atlantic cloud" --association_user atlanticuser --filename ~/.chef_key/atlantic-org.pem
```
The above command will create an organization with name atlantic, full name “atlantic cloud,” associate user “atlanticuser,” and generate keyfile at ~/.chef_key/atlantic-org.pem.
You can now verify the generated keys with the following command:
```
ls ~/.chef_key/
```
You should see the following output:
```
atlantic.pem hitjethva.pem
```
## Step 5 – Install Chef Web Management Console
Next, you will need to install the Chef manage in your server. Chef manage is an add-on that can be used to manage Chef server from the web-based interface.
You can install the Chef manage with the following command:
```
chef-server-ctl install chef-manage
```
Next, reconfigure the Chef server and Chef manage with the following command:
```
chef-server-ctl reconfigure
chef-manage-ctl reconfigure
```
You will be asked to accept the license agreement as shown below:
```
Press any key to continue.
Type 'yes' to accept the software license agreement or anything else to cancel.
yes
```
Type **yes** and hit Enter to finish the installation.
## Step 6 – Install Chef Client
Next, you will need to log into the Chef client machine and install the Chef client package.
By default, the Chef client package is not available in the Ubuntu 20.04 default repository, so you will need to download it from their official website.
Run the following command to download the Chef workstation package:
```
wget https://packages.chef.io/files/stable/chef-workstation/20.6.62/debian/10/chef-workstation_20.6.62-1_amd64.deb
```
Once the package is downloaded, install it with the following command:
```
dpkg -i chef-workstation_20.6.62-1_amd64.deb
```
After installing Chef client, you will need to create a Chef repo in your system. The chef-repo directory will store your Chef cookbooks and other related files.
You can create it with the following command:
```
chef generate repo chef-repo
```
You will be asked to accept the license as shown below:
```
+---------------------------------------------+
Chef License Acceptance
Before you can continue, 3 product licenses
must be accepted. View the license at
https://www.chef.io/end-user-license-agreement/
Licenses that need accepting:
* Chef Workstation
* Chef Infra Client
* Chef InSpec
Do you accept the 3 product licenses (yes/no)?
> yes
```
Type **yes** and hit Enter to accept the License. You should get the following output:
```
Persisting 3 product licenses...
✔ 3 product licenses persisted.
+---------------------------------------------+
Generating Chef Infra repo chef-repo
- Ensuring correct Chef Infra repo file content
Your new Chef Infra repo is ready! Type `cd chef-repo` to enter it.
```
You can list all generated files and directories inside the Chef repo with the following command:
```
ls chef-repo
```
You should get the following output:
```
chefignore cookbooks data_bags LICENSE policyfiles README.md
```
Next, you will need to create a .chef directory to store all Knife configuration file and the .pem files that are used for RSA key pair authentication with the Chef server.
You can create it with the following command:
```
mkdir ~/chef-repo/.chef
```
Next, generate an SSH key pair with the following command:
```
ssh-keygen -b 4096
```
Don’t provide any password, just press Enter to generate an SSH key pair as shown below:
```
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Created directory '/root/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa
Your public key has been saved in /root/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:OvOCW9vNnVfs8II8TKJnRxv9vwRu5R4JqRxWPVU1rTY root@clientnode
The key's randomart image is:
+---[RSA 4096]----+
| .B|
| . +|
| . + |
| . E .|
| S o * + |
| . + B B +|
| .= . O * @ |
| ...*.oo.O.= =|
| ....ooo.oo ++|
+----[SHA256]-----+
```
Next, copy the generated key to the Chef server machine with the following command:
```
ssh-copy-id root@chef-server-ip
```
Next, you will need to copy all .pem files from the Chef server to the client machine. You can copy them with the following command:
```
scp root@chef-server-ip:~/.chef_key/*.pem ~/chef-repo/.chef/
```
You should get the following output:
```
atlantic.pem 100% 1674 2.2MB/s
00:00
hitjethva.pem 100% 1678 2.4MB/s
00:00
```
## Step 7 – Configure Knife and Generate Cookbook
Next, you will need to configure Knife and generate cookbook on the client machine.
First, change into the repository with the command:
```
cd ~/chef-repo
```
Next, generate yourfirst cookbook with the following command:
```
chef generate cookbook my_cookbook
```
Once the cookbook is generated, create a new Knife configuration file:
nano ~/chef-repo/.chef/config.rb
Add the following lines:
```
current_dir = File.dirname(__FILE__)
log_level :info
log_location STDOUT
node_name 'hitjethva'
client_key "hitjethva.pem"
validation_client_name 'atlantic-validator'
validation_key "atlantic-validator.pem"
chef_server_url 'https://chef.example.com/organizations/atlantic'
cache_type 'BasicFile'
cache_options( :path => "#{ENV['HOME']}/.chef/checksums" )
cookbook_path ["#{current_dir}/../cookbooks"]
```
Save and close the file.
Make sure all names match with your organization name and admin username.
Next, edit the /etc/hosts file and add the fully qualified name of your Chef server.
```
nano /etc/hosts
```
Add the following line:
```
chef-server-ip chef.example.com
```
Save and close the file when you are finished.
Next, fetch the SSL certificate from the Chef server with the following command:
```
cd ~/chef-repo
knife ssl fetch
```
You should get the following output:
```
WARNING: Certificates from chef.example.com will be fetched and placed in your trusted_cert
directory (/root/chef-repo/.chef/trusted_certs).
Knife has no means to verify these are the correct certificates. You should
verify the authenticity of these certificates after downloading.
Adding certificate for chef_example_com in /root/chef-repo/.chef/trusted_certs/chef_example_com.crt
```
You can also verify the SSL with the following command:
```
knife ssl check
```
You should get the following output:
```
Connecting to host chef.example.com:443
Successfully verified certificates from `chef.example.com'
```
## Step 8 – Bootstrap a Client Node
Next, you will need to install the Chef client on the node and validate the node. This allows the node to read from the Chef server and pull down and apply any needed configuration updates detected by the chef-client from the workstation.
On the Chef client machine, change the directory to .chef with the following command:
```
cd ~/chef-repo/.chef
```
Next, bootstrap the client with the following command:
```
knife bootstrap chef.example.com -x root -P rootpassword --node-name clientnode
```
Once the installation is completed, you should get the following output:
```
Patents: https://www.chef.io/patents
[chef.example.com] resolving cookbooks for run list: []
[chef.example.com] Synchronizing Cookbooks:
[chef.example.com] Installing Cookbook Gems:
[chef.example.com]
[chef.example.com] Compiling Cookbooks...
[chef.example.com] [2020-10-02T07:56:21+00:00] WARN: Node clientnode has an empty run list.
[chef.example.com] Converging 0 resources
[chef.example.com]
[chef.example.com] Running handlers:
Running handlers complete
Chef Infra Client finished, 0/0 resources updated in 02 seconds
```
You can now list all nodes with the following command:
```
knife client list
```
You should get the following output:
```
atlantic-validator
clientnode
```
## Step 9 – Access Chef Manage Console
Now, open your web browser and access the Chef manage console using the URL http://chef.server-ip/login. You should see the Chef login page:
Provide your admin username and password and click on the **Sign** **in** button. You should see the Chef dashboard in the following page:
## Conclusion
In the above guide, you learned how to install Chef server and client on Ubuntu 20.04 server. You also learned its components with installation and configuration settings. For more information, you can visit Chef [documentation](https://www.chef.io/). Try out Chef on your [virtual private server](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# Install OpenMeetings on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/install-openmeetings-on-ubuntu-20-04/ | Published: 2020-10-25 | Updated: 2023-11-27 | Author: Hitesh Jethva
OpenMeeting is open-source conferencing software used for web conferencing, online training, and desktop sharing. It is an Apache Foundation project and based on Red5 Media Server. OpenMeeting is written in Java and supports multiple database servers. It allows you to record sessions and includes features such as an advanced file explorer, chat, user management, and more.
In this tutorial, we will show you how to install OpenMeetings on Ubuntu 20.04.
## Step 1 – Install Required Dependencies
OpenMeeting is written in Java, so you will need to install Java JDK in your system. You can install it with the following command:
```
apt-get update -y
apt-get install openjdk-11-jdk openjdk-11-jdk-headless -y
```
Once installed, verify the Java version using the following command:
```
java -version
```
You should see the following output:
```
openjdk version "11.0.7" 2020-04-14
OpenJDK Runtime Environment (build 11.0.7+10-post-Ubuntu-3ubuntu1)
OpenJDK 64-Bit Server VM (build 11.0.7+10-post-Ubuntu-3ubuntu1, mixed mode, sharing)
```
Next, install icedtea, imagemagick, and other required packages in your system. You can install them with the following command:
```
apt-get install icedtea-netx imagemagick libjpeg62 zlib1g-dev flashplugin-installer ffmpeg vlc sox -y
```
Next, you will need to modify ImageMagick, so OpenMeetings can upload office files to a whiteboard.
You can do it by editing the following file:
```
nano /etc/ImageMagick-6/policy.xml
```
Comment out the following lines:
```
```
Save and close the file, then install LibreOffice with the following command:
```
apt-get install software-properties-common -y
add-apt-repository ppa:libreoffice/ppa
apt-get update -y
apt-get install libreoffice -y
```
Once you are finished, you can proceed to the next step.
## Step 2 – Install and Configure a Database
OpenMeeting uses MariaDB/MySQL as a database backend, so you will need to install the MariaDB server in your system. You can install it with the following command:
```
apt-get install mariadb-server -y
```
Once installed, login to the MariaDB shell with the following command:
```
mysql
```
Once login, create a database and user for OpenMeeting with the following command:
```
CREATE DATABASE openmeeting DEFAULT CHARACTER SET 'utf8';
GRANT ALL PRIVILEGES ON openmeeting.* TO 'open'@'localhost' IDENTIFIED BY
'password' WITH GRANT OPTION;
```
Next, flush the privileges and exit from the MariaDB shell using the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Install OpenMeeting
First, you will need to download the OpenMeeting from the Apache website:
```
wget http://archive.apache.org/dist/openmeetings/4.0.9/bin/apache-openmeetings-4.0.9.tar.gz
```
Once the download is completed, create a directory for OpenMeeting and extract the downloaded file inside it:
```
mkdir /opt/openmeetings
tar -xvzf apache-openmeetings-4.0.9.tar.gz -C /opt/openmeetings
```
Next, you will need to download the MySQL connector and copy it to OpenMeeting. You can download it with the following command:
```
wget https://repo1.maven.org/maven2/mysql/mysql-connector-java/5.1.48/mysql-connector-java-
5.1.48.jar
```
Next, copy the downloaded file to the OpenMeeting directory with the following command:
```
cp mysql-connector-java-5.1.48.jar /opt/openmeetings/webapps/openmeetings/WEB-INF/lib/
```
Next, change the directory to /opt/openmeetings and start the application with the following command:
```
cd /opt/openmeetings
sh red5.sh openmeetings
```
At this point, OpenMeeting is started and listening on port 5080.
## Step 4 – Access OpenMeeting Web UI
Now, open your web browser and access OpenMeeting using the URL **http://your-server-ip:5080/openmeetings**. You should see the following screen:
Click on the **>** button. You should see the following screen:
Select your database type and provide the database name, then click on the > button. You should see the following screen:
Provide your username, password, and email, then click on the **>** button. You should see the following screen:
Provide your SMTP details and click on the **>** button. You should see the following screen:
Provide your ImageMagick, sox, and FFmpeg path and click on the **>** button. You should see the following screen:
Click on the **>** button. You should see the following screen:
Click on the **Finish** button. You should see the following screen:
Click on the **Enter the Application** button. You should see the following screen:
Provide your admin username, password, and click on the **Sign** **In** button. You should see the OpenMeeting dashboard in the following screen:
**Conclusion**
Congratulations! You have successfully installed OpenMeeting on Ubuntu 20.04. Try setting up your own web conferencing and training system on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
---
# How To Setup Bareos Backup Solution On CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-setup-bareos-backup-solution-on-centos-8/ | Published: 2020-10-26 | Updated: 2023-11-18 | Author: Hitesh Jethva
Bareos, also called “Backup Archiving Recovery Open Sourced,” is an open-source software used for backing up and protecting data. It is cross-platform and supports all major operating systems including Linux, Windows, MacOS and Unix. Bareos comes with a simple and user-friendly web interface that helps you to perform backup operations through a web browser.
Bareos consists of several components, including the Backup Directory, Control Unit, Storage Daemons, and File Daemons. The Director is the controller for the other daemons, while the File Daemons are responsible for backing up the data from the client.
In this tutorial, we will learn how to install the Bareos backup application on CentOS 8.
## Step 1 – Install LAMP Server
Bareos uses MariaDB or MySQL as a database backend. You will need to install the MariaDB database server, Apache and PHP in your system. You can install them with the following command:
```
dnf install httpd mariadb-server php php-cli php-common -y
```
Once all the packages are installed, start the Apache and MariaDB services and enable them to start at system reboot with the following command:
```
systemctl start httpd
systemctl enable httpd
systemctl start mariadb
systemctl enable mariadb
```
## Step 2 – Install Bareos
By default, the Bareos is not available in the CentOS 8 default repository. You will need to download the Bareos repo from their official website.
You can download it with the following command:
```
wget -O /etc/yum.repos.d/bareos.repo http://download.bareos.org/bareos/release/latest/CentOS_8/bareos.repo
```
Next, install the Bareos server by running the following command:
```
dnf install bareos bareos-database-mysql -y
```
Once all the packages are installed, start all Bareos services and enable them to start at boot with the following command:
```
systemctl start bareos-dir
systemctl start bareos-sd
systemctl start bareos-fd
systemctl enable bareos-dir
systemctl enable bareos-sd
systemctl enable bareos-fd
```
## Step 3 – Prepare Bareos Database
Next, you will need to create a database and table for Bareos.
First, create a database with the following command:
```
/usr/lib/bareos/scripts/create_bareos_database
```
You should get the following output:
```
Creating mysql database
Creating of bareos database succeeded.
```
Next, create a database table with the following command:
```
/usr/lib/bareos/scripts/make_bareos_tables
```
You should get the following output:
```
Making mysql tables
Creation of Bareos MySQL tables succeeded.
```
Next, grant all the privileges to the Bareos with the following command:
```
/usr/lib/bareos/scripts/grant_bareos_privileges
```
You should get the following output:
```
Granting mysql tables
Privileges for user bareos granted ON database bareos.
```
## Step 4 – Install Bareos Web UI
First, you will need to install EPEL repo in your system. You can install it with the following command:
```
dnf install epel-release -y
```
Once installed, you can run the following command to install the Bareos WebUI.
```
dnf install bareos-webui -y
```
Once the installation is completed, restart the httpd and Bareos services with the following command:
```
systemctl restart httpd
systemctl restart bareos-dir bareos-sd bareos-fd
```
Next, you will need to create an admin user and password for Bareos WebUI.
To do so, login to Bareos console with the following command:
```
bconsole
```
You should get the following output:
```
Connecting to Director localhost:9101
Encryption: TLS_CHACHA20_POLY1305_SHA256
1000 OK: bareos-dir Version: 19.2.7 (16 April 2020)
bareos.org build binary
bareos.org binaries are UNSUPPORTED by bareos.com.
Get official binaries and vendor support on https://www.bareos.com
You are connected using the default console
```
```
Enter a period (.) to cancel a command.
```
Next, run the following command to create an admin user and password:
```
configure add console name=admin password=admin123 profile=webui-admin
```
You should get the following output:
```
Created resource config file "/etc/bareos/bareos-dir.d/console/admin.conf":
Console {
Name = admin
Password = admin123
Profile = webui-admin
}
```
Next, exit from the Bareos console and edit the Bareos admin configuration file:
```
nano /etc/bareos/bareos-dir.d/console/admin.conf
```
Add the “TLS Enable = No” line as shown below:
```
Console {
Name = admin
Password = admin123
Profile = webui-admin
TLS Enable = No
}
```
Save and close the file, then restart the Bareos service with the following command:
```
systemctl restart bareos-dir bareos-sd bareos-fd
```
## Step 5 – Access Bareos WEB UI
Now, open your web browser and access the Bareos Web UI using the URL **http://your-server-ip/bareos-webui**. You will be redirected to the following page:
Provide your admin username, password and click on the **Login** button. You should see the Bareos dashboard in the following page:
Congratulations! You have successfully installed and configured Bareos backup application on CentOS 8. Now, you can add your first Bareos client and create a job for it to run on a regular basis – get started with Bareos on Atlantic.Net [VPS Hosting](https://www.atlantic.net/vps-hosting/) today!
---
# How to Install Bludit CMS with NGINX on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-bludit-cms-with-nginx-on-ubuntu-20-04/ | Published: 2020-10-27 | Updated: 2024-06-02 | Author: Hitesh Jethva
Bludit is a free, open-source, file-based content management system that helps you to host a blogging website within a minute. It is written in PHP and uses flat-files to store posts and pages. You don’t need to install any database system on your system to use Bludit. It is very similar to other content management systems including Drupal, Joomla, and WordPress, and offers a rich set of features including SEO friendliness, WYSIWYG support, a flexible CSS framework, and many more.
In this tutorial, we will explain how to install and configure Bludit CMS on Ubuntu 20.04 server.
## Step 1 – Install LAMP Server
First, you will need to install Nginx, PHP, and other required packages in your system. You can install all of them with the following command:
```
apt-get update -y
apt-get install nginx php php-cli php-fpm php-common php-mbstring php-zip php-pgsql php-sqlite3 php-curl php-gd php-mysql php-intl php-json php-opcache php-xml unzip git curl -y
```
The above command will also install the Apache package in your system, but it is recommended that you remove it from your system. You can remove it using the following command:
```
apt-get remove apache2 --purge
```
Next, edit the php.ini file and make some desired changes:
```
nano /etc/php/7.4/fpm/php.ini
```
Change the following values:
```
memory_limit = 512M
upload_max_filesize = 32M
date.timezone = Asia/Kolkata
```
Save and close the file, then restart the PHP-FPM service to apply the changes:
```
systemctl restart php7.4-fpm
```
## Step 2 – Install Bludit CMS
First, you will need to download the latest version of Bludit from its official website. You can download it with the following command:
```
wget https://www.bludit.com/releases/bludit-3-13-1.zip
```
Once downloaded, unzip the downloaded file with the following command:
```
unzip bludit-3-13-1.zip
```
Next, move the extracted directory to the Nginx root directory:
```
mv bludit-3-13-1 /var/www/html/bludit
```
Next, change the ownership and provide necessary permissions to the bludit directory:
```
chown -R www-data:www-data /var/www/html/bludit
chmod -R 775 /var/www/html/bludit
```
## Step 3 – Configure Nginx for Bludit
First, you will need to create an Nginx virtual host configuration file for Bludit. You can create it with the following command:
```
nano /etc/nginx/sites-available/bludit.conf
```
Add the following lines:
```
server {
listen 80;
server_name your-domain.com;
root /var/www/html/bludit;
index index.php;
location ~ \.php$ {
fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
fastcgi_index index.php;
include fastcgi.conf;
}
location / {
try_files $uri $uri/ /index.php?$args;
}
location ^~ /bl-content/tmp/ { deny all; }
location ^~ /bl-content/pages/ { deny all; }
location ^~ /bl-content/databases/ { deny all; }
}
```
Save and close the file, then activate the Nginx virtual host with the following command:
```
ln -s /etc/nginx/sites-available/bludit.conf /etc/nginx/sites-enabled/
```
Next, verify the Nginx for any syntax errors with the following command:
```
nginx -t
```
You should get the following output:
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Finally, restart the Nginx service to apply the configuration changes:
```
systemctl restart nginx
```
## Step 4 – Access Bludit Web Interface
Now, open your web browser and access the Bludit CMS using the URL **http://your-domain.com**. You should see the following screen:
Select your desired language and click on the **Next** button. You should see the following screen:
Set your admin password and click on the **Install** button. You should see the following screen:
Click on the **admin panel** button. You should see the Bludit login screen:
Provide your admin username, password and click on the **Login** button. You should see the Bludit dashboard in the following screen:
## Conclusion
In the above guide, you learned how to install Bludit CMS on Ubuntu 20.04 server. You can now build your blogging website easily with Bludit dashboard on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account with Atlantic.Net.
---
# Install Splunk Log Analyzer Tool on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/install-splunk-log-analyzer-tool-on-ubuntu-20-04/ | Published: 2020-10-27 | Updated: 2024-06-05 | Author: Hitesh Jethva
Splunk is a powerful log analysis tool used for searching, monitoring, and analyzing machine-generated big data from a web browser. It helps you simplify log data from servers and networking devices into a simple format that you can easily read and digest. Splunk supports all major operating systems including Windows, Linux, and Mac OS. It is easily scalable, fully integrated, and supports both local and remote data sources.
In this tutorial, we will show you how to install Splunk Log Analyzer Tool on Ubuntu 20.04.
## Step 1 – Install Splunk
First, you must download Splunk onto the Ubuntu server.
- Log in to the [Splunk](https://www.splunk.com/en_us/download/splunk-enterprise.html) website to download the latest version of Splunk package.
- Click on the “Free Splunk” logo on their website.
- Complete the brief registration form to create an account.
- Once the download is complete, use your favorite FTP client to transfer the file to the server.
Note – If you are not sure how to use FTP, please visit either of these guides:
- [FileZilla](https://www.atlantic.net/vps-hosting/how-to-upload-files-filezilla/)
- or [Monsta FTP](https://www.atlantic.net/vps-hosting/upload-files-with-monsta-ftp/)
Once the download is completed, install the downloaded file with the following command:
```
dpkg -i splunk-8.0.5-a1a6394cc5ae-linux-2.6-amd64.deb
```
Once the installation is completed, enable the Splunk service at system boot with the following command:
```
/opt/splunk/bin/splunk enable boot-start
```
You will need to accept the license agreement as shown below:
```
"Personnel" means any employee, consultant, contractor, or
subcontractor of Splunk.
"Splunk Preexisting IP" means, with respect to any C&I Services
Materials, all associated Splunk Technology and all Intellectual Property
Rights created or acquired: (a) prior to the date of the Statement of
Work that includes such C&I Services Materials, or (b) after the date of
such Statement of Work but independently of the C&I Services provided
under such Statement of Work.
"Statement of Work" means the statements of work and/or any all
applicable Orders that describe the specific services to be performed by
Splunk, including any materials and deliverables to be delivered by
Splunk.
SPLUNK GENERAL TERMS (v1.2020)
Do you agree with this license? [y/n]: y
```
Type **y** and hit **Enter** to continue. You will be asked to create an administrative account and set a password as shown below:
```
This appears to be your first time running this version of Splunk.
Splunk software must create an administrator account during startup. Otherwise, you cannot log in.
Create credentials for the administrator account.
Characters do not appear on the screen when you type in credentials.
Please enter an administrator username: admin
Password must contain at least:
* 8 total printable ASCII character(s).
Please enter a new password:
Please confirm new password:
```
Type your admin username and password and hit **Enter**. You should see the following output:
```
Copying '/opt/splunk/etc/openldap/ldap.conf.default' to '/opt/splunk/etc/openldap/ldap.conf'.
Generating RSA private key, 2048 bit long modulus
.........+++++
..+++++
e is 65537 (0x10001)
writing RSA key
Generating RSA private key, 2048 bit long modulus
.+++++
..................................................................................................................................................+++++
e is 65537 (0x10001)
writing RSA key
Moving '/opt/splunk/share/splunk/search_mrsparkle/modules.new' to
'/opt/splunk/share/splunk/search_mrsparkle/modules'.
Init script installed at /etc/init.d/splunk.
Init script is configured to run at boot.
```
## Step 2 – Start Splunk Service
At this point, Splunk is installed in your system. Now, start the Splunk service with the following command:
```
service splunk start
```
You can verify the status of the Splunk service with the following command:
```
service splunk status
```
You should get the following output:
At this point, Splunk is started and listening on port 8000.
## Step 3 – Access Splunk Web Interface
Now, open your web browser and access the Splunk interface using the URL **http://your-server-ip:8000**. You should see the following screen:
Provide your admin username and password and click on the **Sign** **In** button. You should see the Splunk dashboard in the following screen:
## Conclusion
Congratulations! You have successfully installed Splunk on Ubuntu 20.04. Splunk is a very useful solution for log processing, collection, and analysis. Monitor your Linux environment with Splunk on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
---
# Rsync Command in Linux with Examples
> URL: https://www.atlantic.net/vps-hosting/rsync-command-in-linux-with-examples/ | Published: 2020-10-28 | Updated: 2023-11-27 | Author: Hitesh Jethva
rsync is a command-line utility for Unix-based operating systems that can be used to transfer and synchronize files and directories between multiple computers. It is an extraordinarily fast file copying tool that uses an algorithm to transfer only the portions of files that have changed.
rsync is written in C and is a replacement for scp, sftp, and cp commands.
rsync uses compression and decompression of data blocks, which will save your bandwidth compared to other file transfer protocols, like FTP. It also encrypts the data during the file transfer using SSH protocol.
In this tutorial, we will show you how to use rsync command to transfer files and directories in Linux.
## Install rsync
rsync comes pre-installed in most Linux operating systems. If not installed, you can install it with the following command:
```
apt-get update -y
apt-get install rsync -y
```
Once installed, you can verify the version of rsync using the following command:
```
rsync --version
```
You should see the following output:
## Rsync Syntax
The basic syntax of rsync command is shown below:
```
rsync [OPTION] [SOURCE] [DESTINATION]
```
rsync comes with a lot of options. A brief explanation of each option is shown below:
**-a:** Used to sync directories recursively and preserve symbolic links, modification times, group, ownership, and permissions.
**-r:** Used to sync directories recursively but does not keep ownership for users and groups, permissions, timestamps, or symbolic links.
**-z:** Used to compress the data during the transfer.
**-e:** Used to specify SSH protocol for remote transfers.
**-h:** Used to print the numbers in the output in a human-readable format.
**-b:** Used to take a backup during synchronization.
## 1. Copy a File Locally
To copy a single file from one directory to another on the local system, use the following command:
```
rsync -v /etc/rsyslog.conf /mnt/
```
This will copy a file named rsyslog.conf located in /etc to the /mnt directory:
To copy multiple files from one directory to another on the local system, use the following command:
```
rsync -v /etc/fstab /etc/passwd /mnt
```
This will copy files fstab and passwd to the /mnt directory:
```
rsync -v /etc/fstab /etc/passwd /mnt
```
## 2. Copy a Directory Locally
To copy a directory with all its contents to the other directory on the local system, use the following command:
```
rsync -av /etc/init.d /mnt
```
This will copy directory named init.d and all its contents to the /mnt directory:
## 3. Copy Files and Directories from the Local to the Remote System
With rsync, you can also copy or sync files and directories from the local to the remote system.
For example, to copy the directory /etc on the local system to the remote system (192.168.0.102) under the /mnt directory, run the following command:
```
rsync -zarvh /etc/init.d/ root@192.168.0.102:/mnt/
```
You will be asked to provide the root password of remote system:
## 4. Copy Files and Directories from the Remote to the Local System
If you want to copy the directory /etc/rcS.d from the remote system (192.168.0.102) to the local system inside /opt directory, run the following command:
```
rsync -zarvh root@192.168.0.102:/etc/rcS.d /opt/
```
You should see the following output:
## 5. Display Synchronization Progress During Transfer
You can also display the file transfer progress using the option –progress. You can run the following command to display the progress bar:
```
rsync -avh --progress root@192.168.0.102:/etc/apache2 /opt/
```
## 6. Limit Bandwidth During Transfer
You can also set the bandwidth limit for data transfer using the option –bwlimit.
For example, set the bandwidth limit to 500 KB/s during file transfer using the following command:
```
rsync -avz --progress --bwlimit=500 /root/ubuntu-20.04-live-server-amd64.iso
root@192.168.0.102:/mnt/
```
## 7. Include and Exclude Files During Transfer
In some cases, you want to include or exclude only specific file types during the transfer. In this case, you can use –include and –exclude option.
```
rsync -avz --include '*.php' --exclude *.png /var/www/html/wordpress /opt/
```
This will copy only PHP files and exclude PNG files from /var/www/html/wordpress to /opt directory.
## Conclusion
In the above guide, you learned how to use rsync command to transfer files from one system to another. You also learned how to use different options with rsync command. You can now easily use the rsync command to perform backup tasks; try using rsync on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# SaaS, Cloud, or Any Business – When Profitability Matters!
> URL: https://www.atlantic.net/vps-hosting/saas-cloud-or-any-business-when-profitability-matters/ | Published: 2020-11-02 | Updated: 2024-11-14 | Author: Hitesh Jethva
Atlantic.Net was founded in 1994 with no Venture Capital backing or Wall Street funding. 25 years ago, what mattered most to our founders was how to grow the business organically and simultaneously develop profitability, and always offer the latest technology to our wonderful customers.
This approach still holds true today, now that Atlantic.Net has become a leading global cloud provider with clients in hundreds of countries, being served from eight global data centers, we will always remember our humble beginnings back in 1994 as an internet service provider.
## How Atlantic.Net Has Stayed Independent and Profitable
Running a profitable business with little to no debt, staying ahead of the technology curve, and most importantly, being able to bill our customers accurately are some of the top reasons behind our continued success. Credit goes to Marty Puranik, our CEO, who has consistently shown real strength to make his vision become true.
### Atlantic.Net’s Beginnings
Marty dropped out of the University of Florida to start his own internet company in neighboring Gainesville, Florida. The University was at that time proactively blocking student access to the internet from their halls of residence. It might seem inconceivable that today a University would have this kind of stance towards Internet access.
However, this decision kickstarted Marty on his journey to becoming a successful dot-com entrepreneur, rapidly building an Internet Service Provider company with 2000 customers and eight employees in the first 12 months. ICC Computers, as it was known at the time, launched commercial internet services in 1995, and had expanded into Tampa and Orlando before the end of 1996.
### Growth of Atlantic.Net’s Services & the Dot-Com Bubble
The business continued to grow at pace, introducing services into Mississippi, Louisiana, Georgia, and Alabama before going national in 2000 with dial-up and DSL services. At one point, Atlantic.Net was the largest independent internet service provider in the South East and most of the national brands were providing access to their clients by using the Atlantic.Net network.
This all took place during the height of the Dot-Com bubble, global investors were lavishly keen to spend on technology companies. Between 1995 and 2000, the Nasdaq stock market index rose by 400%. Sadly, when the bubble started to burst between 2000-2001, many dotcom businesses went under.
Investors became extremely cautious, trust in the industry was waning after Microsoft was found [guilty in a landmark antitrust case in 2001](https://www.justice.gov/atr/us-v-microsoft-courts-findings-fact), and the tragic events of 9/11 accelerated the rapid decline. Even Atlantic.Net, as a privately owned company, was not immune to the crisis. Consumer confidence was at an all-time low, but Marty never gave up and showed strength and persistence.
### Into the Modern Era
Atlantic.Net survived the DotCom crash thanks to some tough decision making, Marty took a major pay cut and he made many other sacrifices. Today, COVID-19 is threatening an even bigger economic downturn, but this time it is different.
Even though our economy is facing a difficult future, a bubble bigger than Dot-Com, Atlantic.Net is in a unique position to grow stronger, as we realize the digital transformation goals of our clients. This is all because of Marty’s leadership and vision.
From its inception in 1994 until 2002, Atlantic.Net became one of Florida’s largest privately-owned Internet Service Providers, providing Internet access to consumers in cities and small towns throughout Florida and the southeastern United States. Atlantic.Net acquired 16 Internet companies in those nine years, doubling and tripling revenues annually.
As legislation made it more difficult for a small business like Atlantic.Net to exist as an ISP, from 2002 Atlantic.Net entered the Data Center Services business and we have never looked back.
## “Weathering the Storm”
Atlantic.Net knows how to weather a storm. For 25 years the company has remained profitable despite the dot.com bust, a strategic redirection, and the current economic downturn caused by COVID-19.
How have we achieved this? By helping local, regional and global businesses remain up and running through computer outages, failed Internet connections, and, well, bad weather. The core business principals that helped to build the business are still incredibly important today.
Customer satisfaction, security, and technical mastery are some of the foundations that the business was built upon, and today these foundations keep the business driving forward and capable of absorbing the next misfortune to face the industry.
## Business Accomplishments
In addition to growing organically, Atlantic.Net acquired 16 Internet companies from 1994-2002, doubling, and tripling revenues annually. In 1998 Atlantic.Net was named in the *Florida Council of 100*, a non-profit organization of Florida business leaders that recognizes the state’s fastest-growing private companies.
Between 1998 and 2002, Atlantic.Net made the *Inc 500* list for four consecutive years. This was an incredible achievement to be named in the top 500 US privately-held businesses. During the past 20 years, fewer than 6 percent of the winners have been named to the list three times. Atlantic.Net is one of only 31 Florida-based companies to make the Inc 500 and was the state’s only Internet service provider to be honored.
### How Ubersmith Has Helped
The business continues to grow even during the current economic down-turn and biggest pandemic in a century, and this is thanks to our solid partnership with Ubersmith. One thing we have always understood since the business was founded is that you can only grow if you can bill your customers accurately and efficiently.
Our confidence in Ubersmith has been unwavering in the 25 years we have been in business. They are champions at what they do, and we are delighted to have partnered up with them to help us grow, and most importantly handle our complex billing transactions between hundreds of countries with a growing diverse set of services and solutions.
### Recent Recognition
More recently, Atlantic.Net won two awards at the 2020 Stevies, we were awarded the *Gold Stevie Winner* for Healthcare Technology and the *Silver Stevie Winner* for Cloud Platform. Our world-class [HIPAA compliant hosting](https://www.atlantic.net/hipaa-compliant-hosting/) solutions and [VPS Cloud Hosting](https://www.atlantic.net/vps-hosting/) Platforms won us these awards. Ubersmith billings underpin these platforms, another example of our great partnership.
Atlantic.Net was recognized as a leading cloud services provider in Gartner’s 2019 Market Guide for Cloud Service Providers to Healthcare Delivery Organizations, and this was for the second time! the first time was in 2017. Our inclusion inside a highly recognized, leading research and advisory company publication was down to an exceptional job done by our technical teams.
Our other reward highlights include being in the [CRN MSP Top 500](https://web.archive.org/web/20210508051149/http://assets.cdnma.com/8247/assets/2015_SP_Lists/2015%20MSP500%20PDF.pdf) of 2015 and then making it into the CRN Tech Elite Top 250 in 2019. The Medtech Breakthrough award wins in 2018 and 2019 are also treasured by the team as it validates our Medical IoT platforms.
## Why Choose Atlantic.Net?
Today, Atlantic.Net is a leading managed services provider, with a strong presence in cloud compliance, and [dedicated hosting](https://www.atlantic.net/dedicated-server-hosting/). From meeting the strictest security, privacy, and compliance requirements to ensuring a robust and scalable hosting environment, our hosting solutions are designed to help bring focus to your core business and applications.
Our Compliance Hosting solutions are a perfect fit for financial services and healthcare organizations that require the most robust security levels for their data. Certified and audited by third party independent auditors, Atlantic.Net Compliance Hosting Solutions fulfill HIPAA, HITECH, PCI, or SOC requirements.
## Why Choose Ubersmith?
Accurate billing is a cornerstone of building a successful data center services business. It might sound simple to just bill your customer, but in reality, it is an extremely complex task to undertake, especially for a company like Atlantic.Net who manages ten of thousands of customers globally.
What makes cloud computing so popular is the flexibility of costs, Ubersmith empowers Atlantic.Net to bill accurately for the compute, network, and storage usage of our customers. Ubersmith creates fast, accurate, and automated billing down at a finite level. It is easy to apply our pay-as-you-go model costings, or automatically assign one or three-year discount offerings.
Our customers benefit because they can predict the recurring billing costs and can pay with a large number of payment options. We highly recommend Ubersmith and no matter what business you are running, make sure you are billing your customers!
---
# Setup Personal Audio Streaming Server with Koel on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/setup-personal-audio-streaming-server-with-koel-on-ubuntu-20-04/ | Published: 2020-11-03 | Updated: 2024-06-05 | Author: Hitesh Jethva
Koel is a simple, free, open-source, web-based personal audio streaming server written in PHP and JavaScript. It uses Laravel on the server-side and Vue on the client-side. Koel allows you to stream your music and access it from anywhere through the Internet. It supports many media formats, including AAC, OGG, WMA, FLAC and APE, and it can stream music over HTTP / HTTPS.
In this tutorial, we will explain how to install Koel Audio Streaming server on Ubuntu 20.04.
## Step 1 – Install Required Dependencies
First, you will need to install some dependencies required for Koel. You can install all of them with the following command:
```
apt-get update -y
apt-get install git unzip curl build-essential libpng-dev gcc make ffmpeg -y
```
Once all the dependencies are installed, you can proceed to the next step.
## Step 2 – Install LEMP Server
Next, you will need to install Nginx, MariaDB, PHP, and other PHP extensions in your system. You can install all of them with the following command:
```
apt-get install nginx mariadb-server php php-cli php-fpm php-json php-common php-mysql php-zip
php-gd php-mbstring php-curl php-xml php-pear php-bcmath php-tokenizer openssl php-json -y
```
**Note**: If you get an error when Apache2 automatically starts – see this [procedure](https://askubuntu.com/questions/256013/apache-error-could-not-reliably-determine-the-servers-fully-qualified-domain-n).
After installing the above packages, Apache package will be installed automatically with PHP. Here, we will use Nginx web server so remove the Apache package with the following command:
```
systemctl stop apache2
apt-get purge apache2 -y
```
Next, edit the php.ini file and tweak some desired settings:
```
nano /etc/php/7.4/fpm/php.ini
```
Change the following lines:
```
memory_limit = 512M
date.timezone = Asia/Kolkata
```
Save and close the file when you are finished.
## Step 3 – Install Composer
Composer is a dependency manager used for managing PHP dependencies. You can install it with the following command:
```
curl -sS https://getcomposer.org/installer -o composer-setup.php
php composer-setup.php --install-dir=/usr/local/bin --filename=composer
```
You should get the following output:
```
All settings correct for using Composer
Downloading...
Composer (version 1.10.10) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer
```
Next, verify the installed version of Composer using the following command:
```
composer -V
```
You should get the following output:
```
Composer version 1.10.10 2020-08-03 11:35:19
```
## Step 4 – Create a Database for Koel
Next, you will need to create a database and user for Koel.
First, log in to MariaDB with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
CREATE DATABASE koeldb;
CREATE USER 'koeluser'@'localhost' IDENTIFIED BY 'password';
```
Next, grant all the privileges to the Koel database with the following command:
```
GRANT ALL PRIVILEGES ON koeldb.* TO 'koeluser'@'localhost';
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 5 – Install Node.js
First, install the necessary dependencies using the following command.
```
apt-get install -y ca-certificates curl gnupg
```
Next, download the Node.js GPG key.
```
mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
```
Next, add the NodeSource repo to the APT source list.
```
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_18.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
```
Then, update the repository index and install the Ndoe.js with the following command.
```
apt update
apt-get install -y nodejs
```
Additionally, you will also need to import the Yarn repository with the following command:
```
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | gpg --dearmor -o /usr/share/keyrings/yarn-archive-keyring.gpg
```
Next, create a new file in the /etc/apt/sources.list.d/ directory to store the Yarn repository information:
```
echo "deb [signed-by=/usr/share/keyrings/yarn-archive-keyring.gpg] https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
```
Finally, update the repository and install Yarn using the following command.
```
apt update -y
apt install yarn -y
```
## Step 6 – Install Koel
First, change the directory to the Nginx root directory and install Laravel dependencies using the following command:
```
cd /var/www/html
composer global require laravel/installer
```
Next, download the latest version of Koel with the following command:
```
git clone https://github.com/koel/koel.git --recursive
```
Once downloaded, change the directory to Koel and install Node dependencies with the following command:
```
cd koel
npm install
npm audit fix
npm audit fix --force
```
Finally, install PHP dependencies using the following command:
```
composer install
```
Next, edit the .env file and define your database and other settings:
```
nano .env
```
Change the following lines:
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=koeldb
DB_USERNAME=koeluser
DB_PASSWORD=password
ADMIN_NAME="admin"
ADMIN_EMAIL=admin@example.com
ADMIN_PASSWORD=adminpassword
MEMORY_LIMIT=512
FFMPEG_PATH=/usr/bin/ffmpeg
```
Save and close the file, then initialize the database with the following command:
```
php artisan koel:init --no-interaction
```
You should get the following output:
```
Done in 156.20s.
🎆 Success! Koel can now be run from localhost with `php artisan serve`.
Again, visit 📙 https://docs.koel.dev for the official documentation.
Feeling generous and want to support Koel's development? Check out
https://github.com/users/phanan/sponsorship 🤗
Thanks for using Koel. You rock! 🤘
```
Next, initialize the database again with the following command:
```
php artisan koel:init
```
You should see the following output:
```
Attempting to install or upgrade Koel.
Remember, you can always install/upgrade manually following the guide here:
📙 https://docs.koel.dev
Generating app key
JWT secret exists -- skipping
Migrating database
Data seeded -- skipping
The absolute path to your media directory. If this is skipped (left blank) now, you can set it later via
the web interface.
Media path []:
>
Now to front-end stuff
├── Installing Node modules in resources/assets directory
```
Next, create a logs directory and provide necessary permissions and ownership with the following command:
```
mkdir /var/www/html/koel/storage/logs
chown -R www-data:www-data /var/www/html/koel
chmod -R 755 /var/www/html/koel
```
## Step 7 – Configure Nginx for Koel
Now, create a Nginx virtual host configuration file to serve Koel.
```
nano /etc/nginx/sites-available/koel.conf
```
Add the following lines:
```
server {
listen 80 default_server;
server_name koel.example.com;
root /var/www/html/koel;
index index.html index.htm index.php;
location / {
try_files $uri /index.php$is_args$args;
}
location ~ \.php$ {
fastcgi_pass unix:/run/php/php7.4-fpm.sock;
fastcgi_index index.php;
fastcgi_read_timeout 240;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
fastcgi_split_path_info ^(.+.php)(/.+)$;
}
}
```
Save and close the file, then activate the Nginx virtual host file with the following command:
```
ln -s /etc/nginx/sites-available/koel.conf /etc/nginx/sites-enabled/
```
Next, restart the Nginx and PHP-FPM services to apply the changes:
```
systemctl restart nginx
systemctl restart php7.4-fpm
```
## Step 8 – Access Koel Web UI
Now, open your web browser and access the Koel UI using the URL http://koel.example.com. You will be redirected to the Koel login page:
Provide your admin email and password which you have set in .env file, then click on the **Log** **In** button. You should see the Koel default dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed and configured a Koel audio streaming server on Ubuntu 20.04. Now, you can host your own music streaming server and access it over the Internet. Try Koel on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net using the tutorial above!
---
# Install and Set Up Grafana Monitoring Dashboards with Telegraf and InfluxDB Backend on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/install-and-set-up-grafana-monitoring-dashboards-with-telegraf-and-influxdb-backend-on-ubuntu-20-04/ | Published: 2020-11-04 | Updated: 2024-06-06 | Author: Hitesh Jethva
A TIG stack is a collection of open-source tools including Telegraf, InfluxDB, and Grafana. It is one of the most popular tools for montoring a wide panel of data sources.
Telegraf is a server agent used for collecting and aggregating data and reporting metrics. It is highly scalable and allows users to access metrics from the system.
Grafana is an open-source data visualization tool that supports various time series datastores including Prometheus, Elasticsearch, and InfluxDB.
InfluxDB is an open-source database used to store data and expose it to the Grafana dashboard. It can automate sensors and devices in real-time.
In this tutorial, we will learn how to install the TIG stack on Ubuntu 20.04 server.
## Step 1 – Install Telegraf
First, you will need to install Telegraf in your system. By default, Telegraf is not available in the Ubuntu 20.04 standard repository, so you will need to add the InfluxData repo to your system.
First, install the required dependencies using the following command:
```
apt-get install gnupg2 software-properties-common -y
```
Next, import the GPG key with the following command:
```
wget -qO- https://repos.influxdata.com/influxdb.key | apt-key add -
```
Next, activate the lsb-release and add the InfluxData repository with the following command:
```
source /etc/lsb-release
echo "deb https://repos.influxdata.com/${DISTRIB_ID,,} ${DISTRIB_CODENAME} stable" | tee
/etc/apt/sources.list.d/influxdb.list
```
Next, update the repository and install Telegraf with the following command:
```
apt-get update -y
apt-get install telegraf
```
Once the installation is completed, start and enable the Telegraf service with the following command:
```
systemctl enable --now telegraf
systemctl start telegraf
```
Next, verify the status of Telegraf using the following command:
```
systemctl status telegraf
```
You should get the following output:
- ```
telegraf.service - The plugin-driven server agent for reporting metrics into InfluxDB
Loaded: loaded (/lib/systemd/system/telegraf.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2020-10-10 09:46:53 UTC; 23s ago
Docs: https://github.com/influxdata/telegraf
Main PID: 105155 (telegraf)
Tasks: 8 (limit: 4691)
Memory: 17.4M
CGroup: /system.slice/telegraf.service
└─105155 /usr/bin/telegraf -config /etc/telegraf/telegraf.conf -config-directory
/etc/telegraf/telegraf.d
105155]: 2020-10-10T09:46:53Z I! Loaded outputs: influxdb
```
## Step 2 – Install InfluxDB
We have added the InfluxData repo in the previous step, so you can install InfluxDB by just running the following command:
```
apt-get install influxdb -y
```
Once InfluxDB has been installed, start the InfluxDB service and enable it to start at system reboot with the following command:
```
systemctl enable --now influxdb
systemctl start influxdb
```
Next, verify the status of the InfluxDB service using the following command:
```
systemctl status influxdb
```
You should get the following output:
- ```
influxdb.service - InfluxDB is an open-source, distributed, time series database
Loaded: loaded (/lib/systemd/system/influxdb.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2020-10-10 09:48:22 UTC; 13s ago
Docs: https://docs.influxdata.com/influxdb/
Main PID: 105724 (influxd)
Tasks: 10 (limit: 4691)
Memory: 10.3M
CGroup: /system.slice/influxdb.service
└─105724 /usr/bin/influxd -config /etc/influxdb/influxdb.conf
```
## Step 3 – Install Grafana
By default, the latest version of Grafana is not available in the Ubuntu 20.04 server, so you will need to add the Grafana repository to your system.
First, import the Grafana key with the following command:
```
wget -q -O - https://packages.grafana.com/gpg.key | apt-key add -
```
Next, add the Grafana repository with the following command:
```
add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
```
Once the repository is added, update the repository and install the latest version of Grafana using the following command:
```
apt-get update -y
apt-get install grafana -y
```
Once Grafana has been installed, reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the Grafana service and enable it to start at system reboot with the following command:
```
systemctl enable --now grafana-server
systemctl start grafana-server
```
Next, verify the status of the Grafana service with the following command:
```
systemctl status grafana-server
```
You should get the following output:
- ```
grafana-server.service - Grafana instance
Loaded: loaded (/lib/systemd/system/grafana-server.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2020-10-10 09:50:26 UTC; 44s ago
Docs: http://docs.grafana.org
Main PID: 106788 (grafana-server)
Tasks: 8 (limit: 4691)
Memory: 19.4M
CGroup: /system.slice/grafana-server.service
└─106788 /usr/sbin/grafana-server --config=/etc/grafana/grafana.ini --
pidfile=/var/run/grafana/grafana-server.pid --packaging=deb>
```
## Step 4 – Configure InfluxDB
Next, you will need to configure the InfluxDB database to store the metrics collected by Telegraf agent. First, connect the InfluxDB with the following command:
```
influx
```
You should get the following output:
```
Connected to http://localhost:8086 version 1.8.3
InfluxDB shell version: 1.8.3
```
Next, create a database and user with the following command:
```
> create database telegrafdb
> create user telegraf with password 'password'
> grant all on telegrafdb to telegraf
```
Next, verify the database using the following command:
```
> show databases
```
You should get the following output:
```
name: databases
name
----
telegraf
_internal
telegrafdb
```
Next, verify the users by using the following command:
```
> show users
```
You should get the following output:
```
user admin
---- -----
telegraf false
```
Next, exit from the InfluxDB console with the following command:
```
>exit
```
## Step 5 – Configure Telegraf Agent to Collect System Metrics
Next, you will need to configure the Telegraf agent to collect system metrics. Here, we will configure the Telegraf agent to collect system metrics including memory usage, system processes, disk usage, system load, system uptime, and logged in users.
You can generate a custom Telegraf configuration file with the following command:
```
telegraf config -input-filter cpu:mem:swap:system:processes:disk -output-filter influxdb >
/etc/telegraf/telegraf.conf
```
Once the configuration file is generated, edit the configuration file:
```
nano /etc/telegraf/telegraf.conf
```
Define your InfluxDB database details:
```
[[outputs.influxdb]]
urls = ["http://127.0.0.1:8086"]
database = "telegrafdb"
username = "telegraf"
password = "password"
```
Save and close the file, then restart the Telegraf service to apply the configuration changes:
```
systemctl restart telegraf
```
Next, you will need to verify whether the data appears or not. You can run the configuration test using the following command:
```
telegraf --config /etc/telegraf/telegraf.conf --test
```
If everything is correct, you should see the following output:
```
2020-10-10T09:57:58Z I! Starting Telegraf 1.15.3
> mem,host=ubuntu2004
active=1144344576i,available=3518758912i,available_percent=85.25516847152974,buffered=164
536320i,cached=2911133696i,commit_limit=2559074304i,committed_as=1576108032i,dirty=6144
0i,free=731619328i,high_free=0i,high_total=0i,huge_page_size=2097152i,huge_pages_free=0i,hug
e_pages_total=0i,inactive=1903452160i,low_free=0i,low_total=0i,mapped=218427392i,page_table
s=3502080i,shared=651264i,slab=326660096i,sreclaimable=277262336i,sunreclaim=49397760i,sw
ap_cached=24576i,swap_free=495136768i,swap_total=495411200i,total=4127326208i,used=3200
36864i,used_percent=7.754096668677951,vmalloc_chunk=0i,vmalloc_total=35184372087808i,vm
alloc_used=6316032i,write_back=0i,write_back_tmp=0i 1602323878000000000
> system,host=ubuntu2004 load1=0,load15=0.05,load5=0.08,n_cpus=2i,n_users=4i 1602323878000000000
> disk,device=sda1,fstype=ext4,host=ubuntu2004,mode=rw,path=/
free=95962320896i,inodes_free=6365813i,inodes_total=6553600i,inodes_used=187787i,total=105
619841024i,used=5238685696i,used_percent=5.176515404753021 1602323878000000000
> diskio,host=ubuntu2004,name=sda1
io_time=351028i,iops_in_progress=0i,merged_reads=2995i,merged_writes=420522i,read_bytes=5
23574272i,read_time=3572i,reads=11978i,weighted_io_time=287724i,write_bytes=13355402240i,
write_time=574952i,writes=587911i 1602323878000000000
> diskio,host=ubuntu2004,name=sda
io_time=353848i,iops_in_progress=0i,merged_reads=2995i,merged_writes=420522i,read_bytes=5
25794304i,read_time=3581i,reads=12094i,weighted_io_time=288784i,write_bytes=13355402240i,
write_time=593845i,writes=641651i 1602323878000000000
> kernel,host=ubuntu2004
boot_time=1602216148i,context_switches=13167299i,entropy_avail=2803i,interrupts=8104602i,pr
ocesses_forked=107054i 1602323878000000000
> system,host=ubuntu2004 uptime=107730i 1602323878000000000
> system,host=ubuntu2004 uptime_format="1 day, 5:55" 1602323878000000000
```
## Step 6 – Setup Grafana Data Source
Next, you will need to access the Grafana dashboard and add a data source to display the InfluxDB and Telegraf metrics.
You can access the Grafana Dashboard using the URL **http://your-server-ip:3000**/. You should see the Grafana login page:
Provide default username as admin and password as admin then click on the **login** button. You should see the password reset screen:
Note: Since Grafana version 7.2.2, many users have reported the default *admin* and *password* does not work. If this is the case, type the following on your server command prompt:
```
grafana-cli admin reset-admin-password mynewpassword
```
Provide your new password and click on the **Submit** button to change the default password. You should see the Grafana dashboard on the following page:
To add the data source, click on the **Add your first data source**. You should see the following screen:
Search for **InfluxDB** and click on the **Select** button. You should see the following page:
Set the name of the **InfluxDB**, select **InfluxQL** in Query Language, define the URL of the InfluxDB data source, provide InfluxDB database details, and click on the **Save & Test** button. Once the test is successful, you should see the following page:
## Step 7 – Setup Grafana Dashboard
At this point, we have added InfluxDB as a data source to the Grafana server. Next, you will need to import the Grafana dashboard.
On the Grafana Dashboard, click on the **‘+’** menu on the left panel and click the ‘**Import**‘ button. You should see the following page:
Type Grafana ID **5955** and click on the **Load** button to load the dashboard as shown below.
Select InfluxDB and click on the **Import** button. You should see the Grafana Dashboard showing the system metrics collected by the Telegraf agent:
## Conclusion
Congratulations! You have successfully installed and configured a TIG stack on Ubuntu 20.04 server. You can now explore the Dashboard and start monitoring your server using the TIG stack. Try it on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# Best Practices for Creating a HIPAA-Compliant cPanel Host
> URL: https://www.atlantic.net/hipaa-compliant-hosting/best-practices-for-creating-a-hipaa-compliant-cpanel-host/ | Published: 2020-11-05 | Updated: 2025-07-26 | Author: Richard Bailey
cPanel, one of the most popular Linux-based control panels, simplifies website and server management. This powerful application offers a user-friendly and intuitive platform to create multiple, detailed, and highly secure websites. cPanel is very popular with developers and web designers who are not completely comfortable using the Linux Shell command line.
cPanel allows simplified management of files, databases, domains, email, metrics, security, and software, and because there is so much available in cPanel, extra care must be taken to ensure the platform remains HIPAA-Compliant.
## cPanel Hosting
Your choice of host for cPanel is the most important part of meeting the required administrative, technical, and physical safeguards of HIPAA compliance. The chosen infrastructure must meet and exceed the minimum required elements of HIPAA. Atlantic.Net has been supporting US healthcare organizations for decades, and we specialize in both [HIPAA compliant hosting](https://www.atlantic.net/hipaa-compliant-hosting/) and cPanel.
##### Did you know?
###### Atlantic.Net is HIPAA Audited for our hosting solutions and data centers. Our support, management and business processes are fully compliant to HIPAA standards and we are the best choice for your healthcare hosting needs
To ensure HIPAA compliance your hosting must have:
- Fully Managed Firewall
- Intrusion Prevention Service
- Encrypted VPN, Backups, and Storage
- Offsite Backups
- Multi Factor Authentication
- Business Associate Agreement
- Vulnerability Scans
- File Integrity Monitoring
- Anti-Malware Protection
- Log Management System
- High Availability Networking
## Securing cPanel
- Secure Apache – cPanel and WHM include the ModSecurity tool that prevents unauthorized Apache scripts from being executed
- Secure PHP – The suPHP module forces PHP scripts to run as the script owner, denying unauthorized scripts from being executed
- Secure SSH – changing the port used by SSH is a great way to harden your server. SSH is usually port 22, but you can modify it in /etc/ssh/sshd_config
- Secure passwords – It may sound like common sense, but use long and complex passwords and make sure you use different passwords throughout cPanel
##### Did you know?
###### The /etc/login.defs file on a Linux server can be used to enforce a strict password policy.
- Harden the tmp partition – cPanel advises separating the /tmp partition and mounting it with the nosuid option. This forces the OS to access /tmp with user-based permissions
- Restrict the system compilers – C and C++ compilers can be used to execute malicious code, so it is best practice to limit these permissions only to users in the compilers group in /etc/group/
- Disable unused services and daemons
- Restrict your filesystem permissions – locking down file and folder permissions is fundamental to securing the server
##### Did you know?
###### Atlantic.Net is fully SOC audited, we are compliant to AICPA SOC service organization control reporting. These standards ensure our information management and network technology assurance adheres to AICPA best practice and ethical standards.
- Control access to service by IP address – Access can be controlled at the firewall, but also by WHM’s Host Access Control interface. Here you can create granular controls to most cPanel services
- Stay up-to-date – updating cPanel, the operating system, and all the installed applications is necessary to limit the attack surface of your cPanel server. This process can be automated for simplicity
- Enable cPanel logging – there is a hidden logging feature to cPanel which should be enabled; this will give you cPanel access and server access logs
##### Did you know?
###### You can monitor and alert on what users login to their cPanel account. To do so, type:
```
grep "login=1&post_login=" /usr/local/cpanel/logs/access_log | awk '{print $1" : "$3" : "$4}'
```
- Suspend email in cPanel – There are strict rules in HIPAA regarding encrypting and securing email communications. It is recommended to disable the email features of cPanel: cpanel>home>email>emailaccounts
## Securing Apache
cPanel uses Apache as a web server by default. Users can change this or use another Web Server such as Nginx, but the principle of securing the webserver is still the same.
- Keep Apache up-to-date
- Configure Apache to increase DDOS (denial of service) protection level
##### Did you know?
###### Editing the httpd.conf file and reducing the RequestReadTimeout, Timeout, KeepAliveTimeout, and MaxRequestWorkers thresholds will greatly improve DDOS protection.
- Set strict chown, chmod, and chggrp permissions on ServerRoot Directories; this will reduce the ability of a hacker to run arbitrary code
- Enforce TLS certificate encryption using mod_ssl, ensuring you use a strong cipher suite and OCSP stapling
- Implement dynamic content security
##### Did you know?
###### The Apache module mod_security can be finely tuned as an HTTP firewall, perfect for dynamic content security.
- Protect system settings with .htaccess restrictions
- Protect access to service files
##### Did you know?
###### To enable this protection, add this to your httpd.conf:
```
AllowOverride None
Require all denied
```
## Secure Your Database
cPanel is heavily reliant on a MySQL database for cPanel configuration and for content delivery on websites.
- Invoke MySQL Enterprise Data Masking and De-identification routines
##### Did you know?
###### A server-side plugin called data_masking can manage a SQL-Level API to perform masking and de-identification tasks on your data when it is used by an application.
- Data must be encrypted at rest
##### Did you know?
###### Atlantic.Net’s Cloud Platform is encrypted at rest with every server deployed by default.
- Enable SELinux for mandatory access controls to protect the MySQL daemon
- Implement MySQL plugins to authenticate users and restrict access by user, password, and approved IP address
- Enable MySQL Enterprise Audit plugin to enable standard, policy-based monitoring and logging of connections and query activity executed on the MySQL DB
##### Did you know?
###### Atlantic.Net always recommends customers encrypt their Operating Systems and Databases, even though we take the extra step of encrypting data at rest.
## Secure PHP
In cPanel, PHP can either run as an Apache plugin or as a standalone CGI binary. No HIPAA legislation relates directly to PHP; instead, PHP must adhere to access and transmission security:
- Ensure PHP is kept up-to-date
- Use PHP to hash and verify all passwords entered by users; BCrypt is included with PHP 7 onwards
##### Did you know?
###### Passwords can be hashed using the password_hash PHP function.
- Use PHP to protect against cross-site scripting (XSS) and Request Forgery XSFR
##### Did you know?
###### Atlantic.Net is audited and compliant to the HITECH standards for privacy and security of confidential Electronic Health Record (EHR) data. This certification ensures we are the best choice for your healthcare hosting and data confidentiality requirements.
## Ready to find out more?
Atlantic.Net stands ready to help you attain fast compliance with a range of certifications, such as SOC 2 and SOC 3, HIPAA, and HITECH, all with 24x7x365 support, monitoring, and world-class data center infrastructure. For faster application deployment, free IT architecture design, and assessment, [contact us today](https://www.atlantic.net/about-us/corporate-contact/), call 866-618-DATA (3282), or email us at sales@atlantic.net.
---
# BAA vs BASA: What Is the Difference Between a BAA and BASA?
> URL: https://www.atlantic.net/hipaa-compliant-hosting/baa-vs-basa-what-is-the-difference-between-a-baa-and-basa/ | Published: 2020-11-06 | Updated: 2025-09-19 | Author: Richard Bailey
You may be surprised to learn that there are two types of business associate agreements related to HIPAA compliance. Most healthcare professionals will already know what a BAA consists of, but did you know that there is also a Business Associate Subcontractor Agreement?
## BAA vs. BASA Comparison
Both agreements are a vital part of HIPAA compliance, forming the basis of the contractual agreements between a covered entity and a business associate. Here is a breakdown of the two types of business associate relationships:
- **BAA:** Business Associate Agreement between a Covered Entity and a Business Associate
- **BASA:** Business Associate Subcontractor Agreement between a Business Associate and a subcontractor
While each agreement synergizes with the other and they share much in common, the key factor is that the *Business Associate*that has the subcontractor relationship, not the covered entity. A BASA is needed if the Business Associate outsources part of a service to another company or service provider.
### Example BAA/BASA Scenario
To demonstrate, consider system backups that contain Protected Health Information; on occasion, there might be a requirement to archive PHI insurance data to an external data warehouse, perhaps on tape or in the cloud. The business associate may choose to outsource this responsibility to a subcontractor.
The Covered Entity must be made aware of the details of such an arrangement, but it is the Business Associate that maintains the relationship with the subcontractor. The BASA makes the subcontractor liable for the safeguarding of PHI as per the rules of HIPAA compliance, the BAA, and the BASA.
Both agreements outline the shared responsibilities between the Covered Entity and the Business Associate or the Business Associate and the Subcontractor.
## [What Is a BAA?](https://www.atlantic.net/what-is-baa-hipaa-business-associate-agreement/)
To recap, the requirement to hold a [Business Associate Agreement](https://www.atlantic.net/what-is-baa-hipaa-business-associate-agreement/) was introduced in 2003 as part of the HIPAA Privacy Rule amendments. A Covered Entity (CE) is considered to be any healthcare provider, health plan provider, or clearinghouse. A Business Associate is someone that handles or processes PHI on behalf of the covered entity.
Atlantic.Net is a business associate, as we provide HIPAA Compliant hosting services to the healthcare industry. Covered Entities may use our service to process and transmit protected health information. We sign a BAA with each of our healthcare clients to document our responsibilities and the guarantees we adhere to when handling PHI.
Atlantic.Net’s BAA offers assurances regarding our HIPAA and HITECH accreditations and details the guarantees we provide for each of the administrative, physical, and technical safeguards we uphold to secure Protected Health Information.
## What Is a BASA?
The Business Associate Subcontractor Agreement is very similar to a BAA, but with subtle differences that govern the obligations and activities of the subcontractor. The BASA permits the subcontractor to process or disclose PHI under HIPAA regulations (typically redacted information).
There are several additional obligations required of a subcontractor that creates, receives, maintains, or transmits on behalf of another business associate. The obligations vary depending on who the subcontractor is.
## Types of subcontractors
There are numerous examples of subcontractors that need access to protected health information as part of their daily tasks. If any of this information is processed or transmitted by the Business Associate, then a Business Associate Subcontractor Agreement must be in place.
All subcontractors have a relationship with the business associate. here are the most common types of subcontractors that will process PHI:
- **Accountants** – medical accountants, or for example, those who work for insurance companies to process patient medical bills, will likely have access to sensitive protected health information. HIPAA compliant accounting software such as Clinko, Lytec, or NueMD might use data collected on a Business Associate’s infrastructure
- **Consultancy Firms** – many healthcare organizations outsource some or all of the HIPAA compliance responsibility to a consultancy firm, a company that specializes in gaining compliance for its customers. A business associate may be required by terms within the BAA to share PHI with the subcontractor consultancy firms
- **Lawyers** – any attorney who provides legal services to a health plan in reviewing a benefits claim would likely be a business associate subcontractor if the claim involves PHI
- **Medical equipment engineering** – field engineers or service companies may be handling equipment that holds PHI, in particular, if the equipment must be sent offsite for repair or servicing. Consider a medical imaging device that has failed mid-consultation; it’s possible PHI would still be on the device, and as a result, the company responsible would need to sign a BASA
- **Translator services** – medical interpreters are bound by HIPAA regulations as well, similar to doctor-patient confidentiality; interpreters may need access to PHI to assess a client
- **Shredding services** – you may think that shredding services are just responsible for paper records, but in reality, any Protected Health Information that is stored digitally is still bound by the same rule. If a tape hosted at Iron Mountain is damaged in transit, a certified record will be needed to prove its destruction
- **Cloud Service Providers** – external cloud providers may be used by a business associate; a good example is Microsoft Office and OneDrive. Cloud vendors can be both under a BAA or BASA depending on if there is a middle vendor between the Cover Entity and the Cloud Vendor.
## Why choose Atlantic.Net as your next Business Associate
Atlantic.Net has more than 25 years of experience exceeding the needs of health professionals and is one of the country’s leading healthcare technology companies. If you’re in this industry and you need help with IT, contact our sales team to find out how our managed services could help your organization.
If you are in the market for managed IT healthcare services, make sure you choose an experienced HIPAA compliant provider that focuses on security, business continuity, and scalability: a provider that can grow with you, and one that focuses on collaboration and data interoperability. We know that the regulations of the industry are intense, but Atlantic.Net can take away the stress of managing your entire IT operation.
We have an extensive list of healthcare clients who have trusted us for many years, and our managed service packages do allow you to forget about the complexities of IT and focus on your patients. We will protect your infrastructure from the very latest cybersecurity threats, as well as manage upgrades and maintenance behind the scenes. We will work with you to identify and secure PHI, protect you from ransomware attacks, and offer you the very best Healthcare Managed Services platform available.Atlantic.Net offers [HIPAA Cloud](https://www.atlantic.net/hipaa-compliant-hosting/) and [HIPAA Compliant Hosting](https://www.atlantic.net/hipaa-compliant-hosting/) services to support IT Solutions for Healthcare.
---
# How to Install Kanboard on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-kanboard-on-ubuntu-20-04/ | Published: 2020-11-08 | Updated: 2023-11-24 | Author: Hitesh Jethva
Kanboard is a free and open-source project management software that helps you visualize and limit your work in progress to focus on your goal. It follows the Kanban methodology and is specially designed for those people who want to manage their projects efficiently and simply. Kanboard also supports reports and analytics and can be integrated with external services. It allows you to create multiple projects and customize your boards according to your needs.
In this tutorial, we will learn how to install the Kanboard software on Ubuntu 20.04.
## Step 1 – Install Apache, MariaDB, and PHP
First, you must install your system’s Apache web server, MariaDB, PHP, and other necessary extensions. You can install all of them with the following command:
```
apt-get update -y
apt-get install apache2 mariadb-server php libapache2-mod-php php-common php-curl php-intl
php-mbstring php-xmlrpc php-mysql php-gd php-pgsql php-xml php-cli php-zip unzip wget curl git
-y
```
After installing all the packages, edit the php.ini file and make some desired changes:
```
nano /etc/php/7.4/apache2/php.ini
```
Change the following lines:
```
file_uploads = On
allow_url_fopen = On
short_open_tag = On
memory_limit = 512M
upload_max_filesize = 150M
max_execution_time = 360
date.timezone = America/Chicago
```
Save and close the file, then restart the Apache service to apply the changes:
```
systemctl restart apache2
```
## Step 2 – Create a Database for Kanboard
Next, you will need to create a database and user for Kanboard. First, log into MariaDB with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
CREATE DATABASE kanboard;
CREATE USER 'kanboard'@'localhost' IDENTIFIED BY 'password';
```
Next, grant all the privileges to the database with the following command:
```
GRANT ALL ON kanboard.* TO 'kanboard'@'localhost' WITH GRANT OPTION;
```
Next, flush the privileges and exit from the MariaDB with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
At this point, your database and user are created. You can now proceed to the next step.
## Step 3 – Download Kanboard
First, download the latest version of Kanboard from the Git repository using the following command:
```
wget https://github.com/kanboard/kanboard/archive/v1.2.15.zip
```
Once downloaded, unzip the downloaded file with the following command:
```
unzip v1.2.15.zip
```
Next, move the extracted directory to the Apache root directory:
```
mv kanboard-1.2.15 /var/www/html/kanboard
```
Next, change the directory to kanboard and rename the default configuration file:
```
cd /var/www/html/kanboard
cp config.default.php config.php
```
Next, edit the default configuration file with the following command:
```
nano config.php
```
Define your database setting as shown below, and ensure you overwrite the default entries already in confiig.php:
```
// Database driver: sqlite, mysql or postgres (sqlite by default)
define('DB_DRIVER', 'mysql');
// Mysql/Postgres username
define('DB_USERNAME', 'kanboard');
// Mysql/Postgres password
define('DB_PASSWORD', 'password');
// Mysql/Postgres hostname
define('DB_HOSTNAME', 'localhost');
// Mysql/Postgres database name
define('DB_NAME', 'kanboard');
```
Save and close the file, then give proper ownership and permissions to Kanboard:
```
chown -R www-data:www-data /var/www/html/kanboard
chmod -R 755 /var/www/html/kanboard
```
## Step 4 – Configure Apache for Kanboard
First, create an Apache virtual host configuration file using the following command:
```
nano /etc/apache2/sites-available/kanboard.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
DocumentRoot /var/www/html/kanboard
ServerName your-domain.com
Options FollowSymlinks
AllowOverride All
Require all granted
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
```
Save and close the file, then activate the virtual host and enable the Apache rewrite module with the following command:
```
a2ensite kanboard.conf
a2enmod rewrite
```
Finally, restart the Apache service to apply the changes:
```
systemctl restart apache2
```
## Step 5 – Access Kanboard UI
Now, open your web browser and access Kanboard using the URL http://your-domain.com. You will be redirected to the Kanboard login page:
Provide the default username and password as admin/admin and click the **Sign** **in** button. You should see the Kanboard dashboard on the following page:
## Conclusion
Congratulations! You have successfully installed Kanboard on the Ubuntu 20.04 server. You can now create your project, create a board, and manage project workflow using the Kanban methodology. Try Kanboard on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net using the tutorial above!
---
# How to Setup a GitHub Style Wiki Using Gollum on Debian
> URL: https://www.atlantic.net/vps-hosting/how-to-setup-a-github-style-wiki-using-gollum-on-debian/ | Published: 2020-11-09 | Updated: 2025-09-03 | Author: Hitesh Jethva
Gollum is wiki software based on Git using GitHub Wiki as a backend. This free, open-source software is written in Ruby and comes with a simple web interface to create and manage pages from the web browser. Gollum supports a variety of formats including Markdown, AsciiDoc, ReStructuredText, Creole, and MediaWiki markup.
In this tutorial, we will show you how to install Gollum with Nginx as a reverse proxy on Debian 12.
## Step 1 – Install Required Dependencies
Gollum is written in Ruby, so you will need to install Ruby and other dependencies in your system. You can install all of them using the following command:
```
apt-get update -y
apt-get install ruby ruby-dev cmake libssl-dev pkg-config build-essential zlib1g-dev libicu-dev git -
y
```
Once all the packages are installed, you can proceed to the next step.
## Step 2 – Install Gollum
Next, run the following command to install Gollum with other required packages:
```
gem install gollum org-ruby omnigollum github-markup omniauth-github
```
Next, install the GitHub Flavored Markdown, Textile and MediaWiki type markups using the following command:
```
gem install wikicloth
gem install RedCloth
gem install github-markdown
```
After installing all packages, you can proceed to the next step.
## Step 3 – Setup Git Repository
Next, you will need to setup a Git repository for Gollum. First, configure Git username and email address with the following command:
```
git config --global user.name "Gollum Admin"
git config --global user.email "admin@example.com"
```
Next, create a directory name mywiki and initialize it with the following command:
```
mkdir mywiki
cd mywiki
git init .
```
Once you are finished, you can proceed to the next step.
## Step 4 – Configure Gollum
Next, you will need to create a Gollum configuration directory in your system. You can create it with the following command:
```
mkdir /etc/gollum/
```
Next, create a Gollum configuration file using the following command:
```
nano /etc/gollum/config.rb
```
Add the following lines:
```
=begin
This file can be used to (e.g.):
- alter certain inner parts of Gollum,
- extend it with your stuff.
It is especially useful for customizing supported formats/markups. For more information and
examples:
- https://github.com/gollum/gollum#config-file
=end
```
Save and close the file when you are finished.
## Step 5 – Create a Systemd Service File for Gollum
Next, you will need to create a Gollum systemd service file to manage the Gollum service. You can create it with the following command:
```
nano /etc/systemd/system/gollum.service
```
Add the following lines:
```
[Unit]
Description=Gollum wiki server
After=network.target
After=syslog.target
[Service]
Type=simple
User=root
Group=root
WorkingDirectory=/root/mywiki/
ExecStart=/usr/local/bin/gollum --config "/etc/gollum/config.rb"
Restart=on-abort
[Install]
WantedBy=multi-user.target
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the Gollum service and enable it to start at system reboot with the following command:
```
systemctl start gollum
systemctl enable gollum
```
You can verify the status of the Gollum service using the following command:
```
systemctl status gollum
```
You should get the following output:
- ```
gollum.service - Gollum wiki server
Loaded: loaded (/etc/systemd/system/gollum.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2025-08-10 15:28:00 UTC; 3s ago
Main PID: 23069 (gollum)
Tasks: 2 (limit: 4701)
Memory: 61.8M
CGroup: /system.slice/gollum.service
└─23069 /usr/bin/ruby2.5 /usr/local/bin/gollum --config /etc/gollum/config.rb
Oct 10 15:28:00 debian10 systemd[1]: Started Gollum wiki server.
```
At this point, Gollum is started and listening on port 4567. You can check it with the following command:
```
ss -tunelp | grep 4567
```
You should get the following output:
```
tcp LISTEN 0 128 0.0.0.0:4567 0.0.0.0:*
users:(("gollum",pid=23069,fd=7)) ino:41646 sk:9 <->
```
## Step 6 – Configure Nginx for Gollum
Next, you will need to install and configure Nginx as a reverse proxy to access Gollum using port 80. First, install the Nginx web server by running the following command:
```
apt-get install nginx -y
```
Once installed, create a new Nginx virtual host configuration file with the following command:
```
nano /etc/nginx/conf.d/gollum.conf
```
Add the following lines:
```
server {
listen 80;
server_name gollum.example.com;
location / {
proxy_pass http://127.0.0.1:4567;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_connect_timeout 150;
proxy_send_timeout 100;
proxy_read_timeout 100;
proxy_buffers 4 32k;
client_max_body_size 500m;
client_body_buffer_size 128k;
}
access_log /var/log/nginx/gollum-access.log;
error_log /var/log/nginx/gollum-error.log;
}
```
Save and close the file when you are finished. Then, restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
If you get any errors, then you will need to edit the Nginx default server configuration file and set server_names_hash_bucket_size:
```
nano /etc/nginx/nginx.conf
```
Add the following line below http {:
```
server_names_hash_bucket_size 64;
```
Save and close the file, then restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 7 – Access Gollum Web UI
Now, open your web browser and type the URL http://gollum.example.com. You should see the Gollum dashboard in the following screen:
Now, create your first page by adding some content and click on the **Save** button. You should see your Home page in the following screen:
## Conclusion
In the above guide, you learned how to install Gollum wiki with Nginx as a reverse proxy on Debian 12. You can now easily deploy GitHub style wiki with Gollum. Try Gollum on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to install RainLoop Webmail on Debian
> URL: https://www.atlantic.net/vps-hosting/how-to-install-rainloop-webmail-on-debian/ | Published: 2020-11-10 | Updated: 2025-09-03 | Author: Hitesh Jethva
RainLoop is a free, open-source, web-based mail client written in PHP. It allows you to access your external mail server from a web browser. RainLoop is simple, fast, lightweight, and supports both SMTP and IMAP. It is an alternative to other web-based mail applications like RoundCube and SquirrelMail. It supports two-factor authentication and can be integrated with Facebook, Twitter, Google, and Dropbox.
In this tutorial, we will learn how to install RainLoop Webmail on Debian 12.
## Step 1 – Install LEMP Server
First, you will need to install the Nginx web server, MariaDB, PHP and other required PHP extensions to your server. You can install all of them with the following command:
```
apt-get install nginx mariadb-server php php-cli php-fpm php-curl php-json php-mbstring php-
mysql php-common php-xml unzip -y
```
Once all the packages are installed, edit the php.ini file and make some changes:
```
nano /etc/php/7.3/fpm/php.ini
```
Change the following lines:
```
upload_max_filesize = 50M
post_max_size = 50M
date.timezone = Asia/Kolkata
```
Save and close the file,. then restart the PHP-FPM service to apply the changes:
```
systemctl restart php8.2-fpm
```
## Step 2 – Create a Database for RainLoop
Next, you will need to create a database and user for RainLoop. First, log in to MariaDB shell with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
CREATE DATABASE raindb;
CREATE USER 'rainuser'@'localhost' IDENTIFIED BY 'password';
```
Next, grant all the privileges to the raindb with the following command:
```
GRANT ALL ON raindb.* TO 'rainuser'@'localhost';
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
At this point, MariaDB is configured for RainLoop.
## Step 3 – Install RainLoop
First, create a directory for RainLoop inside the Nginx default root directory:
```
mkdir /var/www/rainloop
```
Next, download the latest version of RainLoop with the following command:
```
wget https://www.rainloop.net/repository/webmail/rainloop-latest.zip
```
Next, unzip the downloaded file to the /var/www/rainloop directory with the following command:
```
unzip rainloop-latest.zip -d /var/www/rainloop
```
Next, change the ownership and permission of the rainloop directory:
```
chown -R www-data:www-data /var/www/rainloop
chmod -R 775 /var/www/rainloop
```
Once you are finished, you can proceed to configure Nginx.
## Step 4 – Configure Nginx for RainLoop
Next, you will need to create an Nginx virtual host configuration file for RainLoop. You can create it with the following command:
```
nano /etc/nginx/sites-available/rainloop.conf
```
Add the following lines:
```
server {
listen 80;
server_name rainloop.example.com;
root /var/www/rainloop;
index index.php;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location ~ \.php$ {
fastcgi_index index.php;
fastcgi_split_path_info ^(.+\.php)(.*)$;
fastcgi_keep_conn on;
include fastcgi_params;
fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}
location ~ /\.ht {
deny all;
}
location ^~ /data {
deny all;
}
}
```
Save and close the file, then activate the Nginx virtual host with the following command:
```
ln -s /etc/nginx/sites-available/rainloop.conf /etc/nginx/sites-enabled/
```
Next, verify the Nginx for any syntax errors with the following command:
```
nginx -t
```
You should get the following output:
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Next, restart the Nginx service to apply the changes.
```
systemctl reload nginx
```
If you get any errors, then you will need to edit the Nginx default server configuration file and set server_names_hash_bucket_size:
```
nano /etc/nginx/nginx.conf
```
Add the following line below http {:
```
server_names_hash_bucket_size 64;
```
Save and close the file, then restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 5 – Access RainLoop Dashboard
Now, open your web browser and access the RainLoop dashboard using the URL rainloop.example.com/?admin. You should see the following page:
Provide the default username **admin** and password **12345** and click on the **>** button. You should see the RainLoop dashboard in the following screen:
Next, click on the **change** **password** button to change the default admin password. You should see the following screen:
Provide your new password and click on the **Update** **Password** button to change the password.
## Conclusion
Congratulations! You have successfully installed RainLoop mail client on Debian 12 server. You can now add your mail server from the RainLoop web interface and access your email through the web browser. For more information, visit the RainLoop [documentation](https://www.rainloop.net/docs/configuration) page. Get started with RainLoop on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# Top 13 Difficult Questions Your HIPAA Consultant Should Be Asking You
> URL: https://www.atlantic.net/hipaa-compliant-hosting/top-13-difficult-questions-your-hipaa-consultant-should-be-asking-you/ | Published: 2020-11-10 | Updated: 2026-09-15 | Author: Richard Bailey
Becoming HIPAA compliant is a challenging undertaking, as the Health Insurance Portability and Accountability Act of 1996 together with all of the subsequent amendments and updates form a very complex piece of legislation.
There are countless mandatory and recommended safeguards concerning the physical, technical, and administrative securities over Protected Health Information (PHI).
### Questions Your HIPAA Consultant Should Be Asking
The questions we have highlighted will often be difficult to answer, and once you have the answer, it might be difficult to implement and successfully maintain, but they reflect core elements of HIPAA that must be adhered to. This is where Atlantic.Net can help with our fully managed service offerings. We take care of the hard and repetitive work to maintain your HIPAA environment.
You can readily understand why so many covered entities hire a HIPAA compliance consultant to oversee the monumental task of becoming HIPAA compliant. If you are embarking on this journey, it is important to consider these top critical questions:
1. When was your last Risk Assessment completed?
2. Do you know where your PHI resides?
3. Who is managing your firewall(s) and network to ensure they are patched, up to date, and in compliance?
4. Who is managing your servers and operating systems to ensure they are patched, up to date, and in compliance?
5. Do you have a cloud strategy?
6. Do you have an Incident Response Plan in place?
7. What are your off-site backup and disaster recovery plans?
8. How do you encrypt PHI?
9. How do you control access to PHI?
10. How do you log access to PHI?
11. What is your workstation policy?
12. Have your employees recently had a security awareness training refresh?
13. Do you outsource to a HIPAA Compliant Hosting partner?
## When was your last Risk Assessment completed?
A **Risk Assessment** is a mandatory administrative safeguard of HIPAA compliance, is usually the first task undertaken on the journey to becoming compliant, and should form part of a systematic risk management program. It is advisable to complete a risk assessment at least once a year.
A consultant will advise that all covered entity IT systems are analyzed for security risks and security measures are implemented to mitigate against the risk. All measures must be documented and, if necessary, the covered entity must install and maintain reasonable, appropriate, and continuous protection.
The scope of the risk assessment is enormous, and the aim is to make sure all systems adhere to the physical and technical requirements of HIPAA, such as PHI data being encrypted at rest and in transit or implementing a VPN solution to access a [HIPAA compliant hosting platform](https://www.atlantic.net/hipaa-compliant-hosting/) .
When you partner with Atlantic.Net, we will work with you to complete a full risk assessment, helping to detect compliance weaknesses and document what future action is required by the availability standards of HIPAA. We will look for vulnerabilities, complete a threat analysis, and assess PHI data locations to help determine the likelihood of threat occurrence.
Need help with your risk assessment? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## Do you know where your PHI resides?
The covered entity must know what PHI they manage and where it is located and processed on their IT systems. Understanding what databases, applications, and file servers contain PHI and where PHI is located underpins the entire process.
Making a change to the security outlook of a covered entity is essential. Securing PHI is the cornerstone of HIPAA and one of the most important first steps to achieve compliance. Know where PHI is stored and how you process PHI!
Knowing what PHI you have will help to create a baseline to work upon, and the baseline acts as a line in the sand, helping to define how to handle and process PHI and creating a roadmap for the future desired state configuration.
As part of the risk assessment, Atlantic.Net can complete a Data Collection assessment which will determine where PHI is stored, received, maintained, or transmitted.
Need help with Data Collection? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## Who is managing your firewall(s) and network to ensure they are patched, up to date, and in compliance?
Network firewalls are difficult to update gracefully and require a high availability configuration to prevent downtime. Firewalls are the #1 network component we find not being patched or managed in HIPAA compliant environments. Passwords must be changed from defaults, the networking stacks must be updated to the latest run-time code levels, and SFP fiber connectors need their firmware updated, not to mention the software used to manage the firewalls.
This is a tough assignment even for the professionals, and it is one of the principal reasons customers outsource to a HIPAA compliant hosting provider like Atlantic.Net. Our engineers have vast experience looking for vulnerabilities at the network layer.
Need help with your managed firewall? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## Who is managing your servers and operating systems to ensure they are patched, up to date, and in compliance?
When we review customer infrastructure before onboarding them, one of the major concerns we find is the lack of operating system patching or the use of operating systems that are at end-of-life from the vendor.
Server patching is often months and sometimes years out of date. This is a major security concern, and these systems potentially have countless vulnerabilities. Running an out-of-date operating system, basically any Windows Server platform up to and including Windows Server 2008 R2, puts your organization at risk.
Atlantic.Net can provide a managed service offering wherein our highly skilled engineers will manage and maintain your server infrastructure. This can include a patch management program, anti-virus consolidation, and a best practice security implementation to defend against system vulnerabilities.
Need help with Managed Services? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## Do you have a cloud strategy?
Digital transformation is a hot topic in 2020, with many organizations fast-tracking cloud migration strategies in the wake of Covid-19. How can the cloud help your healthcare organization grow on a HIPAA compliant platform? The cloud offers many benefits to healthcare, outsourcing the responsibility of server hardware patching, managing, replacement, monitoring, and more.
Working alongside Atlantic.Net, a cloud-first strategy will help to ensure access and uptime within a fully redundant cloud stack from physical, hardware, and network, including multiple carriers with multiple high-speed connections. The cloud provider will also be responsible for vulnerability scanning and mitigation.
Need help with your cloud strategy? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## Do you have an Incident Response Plan in place?
An IRP is an administrative safeguard that forms part of the HIPAA Breach Notification Rule (2009). It is a mandatory requirement to have a plan in place that documents the steps undertaken in the event of a security breach affecting PHI.
The IRP contains details about who is responsible and what roles employees undertake to react to a security incident. There are regulations about notifying patients and the media in a timely fashion.
Investigate the nature and extent of PHI involved and understand if patients can be tracked from data leaked. If possible, work out who was involved and try to determine if PHI was accessed/taken. The investigation will determine if PHI was put at risk and if the theft needs to be reported to the [Office of Civil Rights](https://ocrportal.hhs.gov/ocr/breach/breach_report.jsf) (OCR).
Working with Atlantic.Net will dramatically reduce the risk of ever having to use an incident response plan, as our HIPAA compliant services have been finely tuned to provide the best-in-class security for your healthcare organization. However, if the worst should happen, we will stand by you, implementing an IRP that is created as part of the risk assessment.
Need help with an IRP? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## What are your off-site backup and disaster recovery plans?
A business continuity plan is something every business must focus on, especially since the Covid-19 outbreak. Two key parts of a BCP are Off-Site Backups and Disaster Recovery Planning. They are a required safeguard that aims to document and test how a covered entity responds to a disaster recovery scenario such as a natural disaster, a global pandemic, or flooding of a data center. The availability of PHI is mandatory; authorized systems must be able to access PHI, and appropriate measures must be undertaken to protect PHI.
A BCP usually consists of a predefined backup strategy that protects PHI systems, such as a data backup system that replicates to a secondary location. Likewise, critical IT systems, such as patient databases, must be capable of failing over service to a secondary data center location. This is a technical solution commonly provided by your HIPAA compliant hosting partner.
Some providers achieve this using tape backup, but it has become increasingly popular to hold backup data on secure, redundant, geolocated storage systems. Data is replicated from the source location to at least one other offsite location, and regular test restores should be conducted to confirm the validity of the backup data.
At all times, a backup is available should the worst happen, meaning that data can be restored in all scenarios. A BCP is an evolving administrative task that involves an annual disaster recovery test to ensure the failover process works, and lessons can be learned if issues are encountered.
Atlantic.Net are specialists in backup and disaster recovery. Our cloud backup solution can be added by a simple checkbox enable, and our DR service provides best-in-class site failover to any of our 8 data centers located in the United States, Canada, Asia, and Europe.
Need help with your Backup Strategy and DR? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## How do you encrypt PHI?
Data encryption is a method of translating data into a protected format that can only be read by the person or computer with the decryption key. Unencrypted data, sometimes called *plaintext,* is readable by humans and computers. Encrypted data, sometimes called *ciphertext* , is only readable by the holder of the secret (encryption) key.
It is highly recommended to encrypt all PHI data, and the only way to achieve this standard is to use AES-256 encryption for PHI data stored at rest and in transit. By default, Atlantic.Net encrypts all data. Surprisingly, holding PHI data encrypted at rest is not mandatory, but you need to have a very good excuse when you are audited as to why you are not encrypting data at rest. Only encrypting PHI in transit is mandatory.
HIPAA recommends using end-to-end encryption (E2EE); this standard means that only the sender and receiver can view or access the data (it is encrypted everywhere but at the endpoints). Data is not stored on an intermediate server, such as a content server, during the data transfer, making the entire data transaction incredibly secure.
You should also consider making your email platform encrypted and encrypting user laptops, mobile phones, tablets, and strictly manage your employee’s BYOD habits. Backups must be encrypted, as well as any in-scope database.
Need help with encryption? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## How do you control access to PHI?
Controlling who has access to PHI is another mandatory requirement of HIPAA compliance. It is important to know who should have access to PHI and what PHI they should have access to. It requires credential management, access control lists, and several administrative policies to remain compliant.
Each user must have a unique username and password combination, credentials must never be shared and to enforce this, and accounts must be protected by Multifactor authentication. Servers or applications that contain PHI must use access control lists; this is usually managed by directory service security groups that can deny access to all but a chosen few.
System administrators and service desks need to oversee the entire process, not only enforcing system-wide password policies and restricting access to sensitive systems, but also taking care of user management; for example, enforce a strict leavers policy, ensuring at minimum a user’s credentials are locked as soon as they leave the business.
Atlantic.Net has vast experience in assessing current security measures, including making sure access controls are in place to manage inappropriate accesses or disclosure of PHI.
Need help with your access controls? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## How do you log access to PHI?
HIPAA compliance also demands that in addition to maintaining access controls to PHI, detailed logging must also be enabled to log who has accessed PHI, what PHI has been accessed, and when the PHI was accessed. Verbose logging can be enabled inside applications, databases, and on server and cloud infrastructure.
Logging creates huge volumes of data, making manual monitoring is all but impossible. An automated SIEM solution can be implemented to automatically audit the logs for specific trends, such as users logging in outside-of-hours, multiple failed login attempts, changes in user’s elevated permissions, and so on.
These controls are required to introduce a technical layer of auditing on PHI. It ensures that the covered entity can determine when PHI is accessed, altered, or destroyed in an unapproved manner. Security Information Event Management (SIEM) platforms are configured to audit and alert on any changes made to PHI, and the alerts should be monitored and escalated as required.
Need help with your access controls? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## What is your workstation policy?
Write a policy that limits which workstations can access protected health data; it should define how a screen should be guarded against snooping and specify appropriate workstation use.
Automated lock screens should be enabled by system administrators. A clear screen states that whenever your staff members leave their desks for an extended time, they should log off their computers and that whenever they leave, even for a moment, they should lock their screens.
A clean desk policy should be in place that mandates that employees empty their desks of any materials, including removable media, sticky notes, business cards, and documents, whenever they leave it unattended.
Atlantic.Net can offer advice and guidance related to the physical protection of a workstation. This includes cable locks, screen filters, docking stations with locks, privacy screens, and technical protections such as password policies, automated lockouts, and so on.
Need help with your workstation policy? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## Have your employees recently had a security awareness training refresh?
Finally, one of the most important questions you should be asked is about employee training about HIPAA compliance and security best practices. Training plays such as a large part in protecting the covered entity’s IT ecosystem, as employees form the front line of defense against breaches of PHI.
Adequate training includes not only the latest security awareness training, such as the latest trends and threats in cybersecurity, but also training on how to correctly use computer systems and medical devices, and how to protect patient information.
To wrap up, if you are in the market for Managed IT services for healthcare, make sure you choose an experienced HIPAA compliant provider that focuses on security, business continuity, and scalability. Choose a provider that can grow with you, one that focuses on collaboration and data interoperability. We know that the regulations of the industry are intense, but Atlanic.Net can take away the stress of managing your entire IT operation.
We have an extensive list of healthcare clients who have trusted us for many years, and our managed service packages allow you to forget about the complexities of IT and focus on your patients. We will protect your infrastructure from the very latest cybersecurity threats, as well as manage upgrades and maintenance behind the scenes. We will work with you to identify and secure PHI, protect you from ransomware attacks, and offer you the very best Healthcare Managed Services platform available.
The most effective way to manage training is to ensure all workforce members are given security training on regular occasions. Speak to our sales team to learn how Atlantic.Net can guide your organization through this critical learning journey.
Need help with your learning journey? [Get in touch today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) !
## Do you outsource to a HIPAA Compliant Hosting partner?
Are you in need of an infrastructure that can protect the health data of your organization? At Atlantic.Net, whatever your technical requirements, we can offer a top-grade [HIPAA-Compliant Hosting](https://www.atlantic.net/hipaa-compliant-hosting/) solution. Get a [HIPAA-Compliant Server Cost](https://www.atlantic.net/hipaa-compliant-hosting/) from one of our experts.
If you’re in need of a HIPAA compliance consultant, check out our [list of the top 10 HIPAA consulting companies](https://www.atlantic.net/hipaa-compliant-hosting/top-10-hipaa-consulting-companies/).
[Get a free consultation today!](https://www.atlantic.net/hipaa-compliant-hosting/)
---
#### Read More About Consulting Services
- [IT Consulting Services](https://www.atlantic.net/managed-services/consulting/)
- Best [Cloud Computing Consulting Services](https://www.atlantic.net/vps-hosting/best-cloud-consultancy-or-msp/)
---
---
# How to Install Jenkins on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-jenkins-on-centos-8/ | Published: 2020-11-11 | Updated: 2023-11-24 | Author: Hitesh Jethva
Jenkins is an open-source, Java-based continuous integration and continuous delivery tool that makes the development process easier. It helps developers to effectively test and deploy code. Continuous integration is a development practice where every developer commits their code changes to the central repository. Continuous delivery is the second part of this development process where code changes are tested and deployed to production automatically.
In this tutorial, we will learn how to install Jenkins on CentOS 8.
## Step 1 – Install Java
Jenkins is a Java-based software and requires Java version 8, so Java must be installed on your server. If not installed, you can install it by running the following command:
```
yum update -y
yum install java-1.8.0-openjdk-devel -y
```
After installing Java, verify the Java version with the following command:
```
java -version
```
You should get the following output:
```
openjdk version "1.8.0_265"
OpenJDK Runtime Environment (build 1.8.0_265-b01)
OpenJDK 64-Bit Server VM (build 25.265-b01, mixed mode)
```
## Step 2 – Install Jenkins
By default, Jenkins is not available in the CentOS standard repository, so you will need to add the Jenkins official repository to your system.
First, add the Jenkins repository with the following command:
```
wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
```
Next, import the Jenkins key with the following command:
```
rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key
```
Next, install the Jenkins by running the following command:
```
yum install jenkins
```
Once the Jenkins is installed, start the Jenkins service and enable it to start at system reboot with the following command:
```
systemctl start jenkins
systemctl enable jenkins
```
You can also verify the status of Jenkins with the following command:
```
systemctl status jenkins
```
You should get the following output:
- ```
jenkins.service - LSB: Jenkins Automation Server
Loaded: loaded (/etc/rc.d/init.d/jenkins; generated)
Active: active (running) since Sat 2020-10-17 03:41:00 EDT; 19s ago
Docs: man:systemd-sysv-generator(8)
Process: 39242 ExecStart=/etc/rc.d/init.d/jenkins start (code=exited, status=0/SUCCESS)
Tasks: 42 (limit: 25014)
Memory: 429.2M
CGroup: /system.slice/jenkins.service
└─39265 /etc/alternatives/java -Dcom.sun.akuma.Daemon=daemonized -
Djava.awt.headless=true -DJENKINS_HOME=/var/lib/jenkins -jar /usr>
```
```
Oct 17 03:40:59 centos systemd[1]: Starting LSB: Jenkins Automation Server...
Oct 17 03:40:59 centos runuser[39249]: pam_unix(runuser:session): session opened for user jenkins by (uid=0)
Oct 17 03:41:00 centos runuser[39249]: pam_unix(runuser:session): session closed for user jenkins
Oct 17 03:41:00 centos jenkins[39242]: Starting Jenkins [ OK ]
Oct 17 03:41:00 centos systemd[1]: Started LSB: Jenkins Automation Server.
```
## Step 3 – Access Jenkins
At this point, Jenkins is started and listening on port 8080. Now, open your web browser and access the Jenkins web interface using the URL **http://your-server-ip:8080**. You will be redirected to the following page:
The Jenkins password will be automatically generated during the installation. You can print it with the following command:
```
cat /var/lib/jenkins/secrets/initialAdminPassword
```
You should see the Jenkins password in the following output:
```
819d86d763024eacb9154f7697593eab
```
Type the password on the screen and click on the **Continue** button. You should see the following screen:
Click on the **Install suggested plugins** panel to start the installation process. You should see the following screen:
Once the installation has been completed, you should see the following screen:
Provide your admin username, password, and email and click on the **Save** **and** **Continue** button.
Provide your Jenkins URL and click on the **Save and Finish** button. You should see the following screen:
Click on the **Start using Jenkins** button. You should see the Jenkins dashboard in the following screen:
## Conclusion
Congratulations! You have successfully installed Jenkins on CentOS 8. You can now explore Jenkins and start creating your first software project. Get started with Jenkins on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Install Monit Monitoring Server on Ubuntu
> URL: https://www.atlantic.net/vps-hosting/how-to-install-monit-monitoring-server-on-ubuntu/ | Published: 2020-11-12 | Updated: 2023-11-24 | Author: Hitesh Jethva
Monit is a utility to designed to manage and monitor filesystems, directories, files, programs, and processes over a UNIX system for changes in size, checksum, and timestamp. Monit not only undertakes automatic repair and maintenance, but also executes meaningful casual actions when error situations arise. Just as an example, Monit can start a process if it ceases to run, restart a process if it fails to respond, and halt a process if it uses too many resources. An easy-to-configure control file, which is based on a token-oriented, free-format syntax, is used for controlling Monit. Monit also sends customizable alert messages as notifications regarding error conditions.
In this tutorial, we will learn how to install the Monit monitoring tool on Ubuntu 20.04.
## Step 1 – Install Monit
By default, Monit is available in the Ubuntu 20.04 default repository. You can install it with the following command:
```
apt-get update -y
apt-get install monit -y
```
Once Monit is installed, the Monit service will be started automatically. You can check the status of Monit with the following command:
```
systemctl status monit
```
You should get the following output:
```
monit.service - LSB: service and resource monitoring daemon
Loaded: loaded (/etc/init.d/monit; generated)
Active: active (running) since Thu 2020-10-01 09:35:07 UTC; 17s ago
Docs: man:systemd-sysv-generator(8)
Tasks: 1 (limit: 2353)
Memory: 1.6M
CGroup: /system.slice/monit.service
└─40909 /usr/bin/monit -c /etc/monit/monitrc
Oct 01 09:35:07 ubuntu2004 systemd[1]: Starting LSB: service and resource monitoring daemon...
Oct 01 09:35:07 ubuntu2004 monit[40893]: * Starting daemon monitor monit
Oct 01 09:35:07 ubuntu2004 monit[40893]: ...done.
Oct 01 09:35:07 ubuntu2004 systemd[1]: Started LSB: service and resource monitoring daemon.
```
## Step 2 – Configure Monit
The Monit default configuration file is located at /etc/monit/monitrc. Monit provides a web-based interface to monitor Monit through the web browser.
By default, the Monit web interface is disabled, so you will need to enable it and set the admin password. You can do this by editing the file /etc/monit/monitrc.
```
nano /etc/monit/monitrc
```
Uncomment and set the Monit admin password as shown below:
```
set httpd port 2812 and
allow admin:adminpassword
```
Save and close the file when you are finished, then check for syntax errors with the following command:
```
monit -t
```
You should get the following output:
```
Control file syntax OK
```
Next, restart the Monit service to apply the changes:
```
systemctl restart monit
```
At this point, Monit is started and listening on port 2812. You can check it with the following command:
```
ss -plunt | grep 2812
```
You should see the following output:
```
tcp LISTEN 0 1024 0.0.0.0:2812 0.0.0.0:*
users:(("monit",pid=41867,fd=6))
tcp LISTEN 0 1024 [::]:2812 [::]:*
users:(("monit",pid=41867,fd=7))
```
Now, open your web browser and access the Monit web interface using the URL **http://your-server-ip:2812**. You should see the Monit login page:
Provide your admin username and password, then click on the **Sign**–**in** button. You should see the Monit dashboard on the following page:
You can also verify the status of your system with the following command:
```
monit status
```
You should get the following output:
```
Monit 5.26.0 uptime: 2m
System 'ubuntu2004'
status OK
monitoring status Monitored
monitoring mode active
on reboot start
load average [0.17] [0.30] [0.30]
cpu 7.8%us 5.1%sy 0.1%wa
memory usage 794.3 MB [40.0%]
swap usage 1.8 MB [0.4%]
uptime 5h 21m
boot time Thu, 01 Oct 2020 04:19:36
data collected Thu, 01 Oct 2020 09:40:29
```
## Step 3 – Monitor Apache and MariaDB with Monit
Monit woks by continuously monitoring different services in your system. If any service goes down Monit, automatically start it.
In this section, we will install Apache and MariaDB and monitor both services using Monit.
First, install Apache and MariaDB with the following command:
```
apt-get install apache2 mariadb-server -y
```
Next, enable the Apache and MariaDB monitoring with the following command:
```
ln -s /etc/monit/conf-available/apache2 /etc/monit/conf-enabled/
ln -s /etc/monit/conf-available/mysql /etc/monit/conf-enabled/
```
Now, restart the Monit service to apply the changes:
```
systemctl restart monit
```
You can now check the status of the Apache and MariaDB using the Monit command-line utility:
```
monit summary
```
You should get the following output:
Now, go to the Monit web interface and refresh the page. You should see the status of all services in the following page:
Next, stop the Apache service and check whether the Monit starts it automatically or not.
You can stop the Apache service with the following command:
```
systemctl stop apache2
```
Now, check the Monit log file and see how Monit starts the Apache service:
tail -f /var/log/monit.log
You should get the following output:
```
[UTC Oct 1 09:58:06] error : 'apache' process is not running
[UTC Oct 1 09:58:06] info : 'apache' trying to restart
[UTC Oct 1 09:58:06] info : 'apache' start: '/etc/init.d/apache2 start'
[UTC Oct 1 10:00:06] info : 'apache' process is running with pid 4404
```
.
Wait some time, then run the following command to check the status of the Apache service.
```
monit summary apache
```
You should see that Apache is started and in listening status:
```
Monit 5.26.0 uptime: 6m
┌─────────────────────────────────┬────────────────────────────┬───────────────┐
│ Service Name │ Status │ Type │
├─────────────────────────────────┼────────────────────────────┼───────────────┤
│ apache │ OK │ Process │
└─────────────────────────────────┴────────────────────────────┴───────────────┘
```
## Conclusion
In this guide, you learned how to install and configure Monit on Ubuntu 20.04. You also learned how to configure Monit to monitor different services. You can now use Monit in the production environment and monitor your desired services. Try Monit on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net using the tutorial above!
---
# How to Install and Use MySQL Workbench on Ubuntu
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-use-mysql-workbench-on-ubuntu/ | Published: 2020-11-14 | Updated: 2023-11-23 | Author: Hitesh Jethva
MySQL Workbench is a graphical and visual database designing tool for MySQL servers and databases. It is specially designed to enable database administrators, developers and database architects to visually design, generate, model and manage databases. MySQL Workbench’s aim is to provide a simple and easy-to-use interface for working with databases. It has an ability to create multiple models in the same environment and supports all objects including tables, views, triggers, and stored procedures.
In this tutorial, we will install MySQL server on one Ubuntu 18.04 server, install MySQL workbench on another Ubuntu 18.04 desktop and connect MySQL server with MySQL Workbench interface.
## Step 1 – Install and Configure MySQL Server
MySQL Workbench supports MySQL server versions 5.6 and higher, so you will need to install a MySQL server version greater than 5.6 in your first server.
On the Ubuntu 18.04 server, run the following command to install MySQL server:
```
apt-get update -y
apt-get install mysql-server -y
```
After installing the MySQL server, you will need to set the MySQL root password, as MySQL is configured to login without a password by default.
First, access the MySQL shell with the following command:
```
mysql
```
Once connected, change the database to mysql using the following command:
```
use mysql;
```
Next, set the MySQL root password with the following command:
```
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
```
Next, flush the privileges and exit from the MySQL shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
Next, log in to MySQL with root user:
```
mysql -u root -p
```
Provide your MySQL root password and hit Enter to connect the MySQL shell. Next, create a test database with the following command:
```
create database testdb;
```
Next, grant all privileges to all database and all remote IPs with the following command:
```
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'password';
```
Next, flush the privileges and exit from the MySQL shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
In order to connect MySQL Workbench via TCP/IP over SSH tunnel, you will need to add KexAlgorithms key exchange algorithms in your SSH config file. You can do it by editing the file /etc/ssh/sshd_config:
```
nano /etc/ssh/sshd_config
```
Add the following line at the end of the file:
```
KexAlgorithms curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-
nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha1,diffie-hellman-
group1-sha1
```
Save and close the file when you are finished, then restart the SSH service to implement the changes:
```
systemctl restart ssh
```
At this point, the MySQL server is installed and configured.
## Step 2 – Install MySQL Workbench
Next, you will need to install MySQL Workbench in your **Ubuntu 18.04 desktop system.**
By default, MySQL Workbench is available in the Ubuntu 18.04 default repository. You can install it by simply running the following command:
```
apt-get install mysql-workbench -y
```
Once the installation is completed, you can proceed to the next step.
## Step 3 – Connect MySQL Server with MySQL Workbench
In this section, we will open the MySQL Workbench interface and connect the MySQL server via TCP/IP over SSH.
On the Ubuntu 18.04 desktop system, open the MySQL Workbench interface as shown below:
Click on the **+** icon to create a new connection. You should see the following screen:
Provide connection name, select connection method, provide your MySQL Server IP address and username, and in SSH Password field, click on “**Store in keychain**“. You should see the following screen:
Provide your MySQL server SSH root password and click on the OK button. Next, provide your MySQL server host, port, and username, then in the MySQL Password field, click on “**Store in Keychain**” and click on the **Test Connection** button. Once the connection is tested successfully, you should see the following screen:
Click on the **OK** button and again click on the **OK** button to save the connection. You should see the following screen:
Now, double click on your connection. Once the connection has been established successfully, you should see the MySQL Workbench start page.
Now, click on the **Server** **Status** in the left pane and you should see your MySQL Server status in the following screen:
## Conclusion
Congratulations! You have successfully installed MySQL server on Ubuntu 18.04 server and connected with MySQL Workbench. You can now start managing your MySQL users, schemas, databases, and much more. For more information, visit the [MySQL Workbench](https://www.mysql.com/products/workbench/) documentation. Get started with MySQL Workbench on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Install Metabase on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-metabase-on-centos-8/ | Published: 2020-11-15 | Updated: 2023-11-24 | Author: Hitesh Jethva
Metabase is a free and open-source business intelligence tool that helps you to visualize large data sets without ever writing a single line of SQL. It is a powerful database lookup tool that comes with a web-based interface that makes it easier to search for data sets and display information. Metabase can be integrated with almost all types of databases and allows you to run queries on the database.
In this tutorial, we will explain how to install Metabase on CentOS 8.
## Step 1 – Install Java
Metabase is a Java-based application, so Java must be installed in your system. If not installed, you can install it by running the following command:
```
dnf update -y
dnf install java-11-openjdk-devel -y
```
Once Java is installed, verify the installed version of Java with the following command:
```
java --version
```
You should get the following output:
## Step 2 – Install and Configure MariaDB
Next, you will need to install the MariaDB server in your system. You can install it with the following command:
```
dnf install mariadb-server -y
```
Once installed, start the MariaDB service and enable it to start on system reboot with the following command:
```
systemctl start mariadb
systemctl enable mariadb
```
Next, log in to MariaDB with the following command:
```
mysql
```
Once logged in, create a database and user for Metabase with the following command:
```
create database metabasedb;
create user metabaseuser@'localhost' identified by 'password';
```
Next, grant all privileges to the Metabase with the following command:
```
grant all on metabasedb.* to metabaseuser@'localhost' with grant option;
```
Next, flush the privileges and exit from the MariaDB with the following command:
```
flush privileges;
exit
```
## Step 3 – Download and Setup Metabase Installation Directory
Before starting, create a user and group for Metabase with the following command:
```
groupadd --system metabase
useradd --system -g metabase --no-create-home metabase
```
Next, create the necessary directories and files for Metabase:
```
mkdir -p /opt/metabase
touch /var/log/metabase.log
touch /etc/default/metabase
```
Next, change the ownership with the following command:
```
chown -R metabase:metabase /opt/metabase
chown metabase:metabase /var/log/metabase.log
chmod 640 /etc/default/metabase
```
Next, create a log file for Metabase with the following command:
```
nano /etc/rsyslog.d/metabase.conf
```
Add the following lines:
```
:msg,contains,"metabase" /var/log/metabase.log
& stop
```
Save and close the file, then restart the rsyslog service with the following command:
```
systemctl restart rsyslog
```
Next, change the directory to metabase and download the latest version of Metabase with the following command:
```
cd /opt/metabase
wget https://downloads.metabase.com/v0.36.2/metabase.jar
```
Next, change the ownership of the downloaded file to metabase with the following command:
```
chown -R metabase:metabase /opt/metabase
```
## Step 4 – Create a System Service File for Metabase
Next, create a systemd service file to manage the Metabase service. You can create it with the following command:
```
nano /etc/systemd/system/metabase.service
```
Add the following lines:
```
[Unit]
Description=Metabase server
After=syslog.target
After=network.target
[Service]
WorkingDirectory=/opt/metabase/
ExecStart=/usr/bin/java -jar /opt/metabase/metabase.jar
EnvironmentFile=/etc/default/metabase
User=metabase
Type=simple
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=metabase
SuccessExitStatus=143
TimeoutStopSec=120
Restart=always
[Install]
WantedBy=multi-user.target
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the Metabase service and enable it to start at system reboot with the following command:
```
systemctl start metabase
systemctl enable metabase
```
You can now check the status of the Metabase service with the following command:
```
systemctl status metabase
```
You should get the following output:
## Step 5 – Access Metabase Web Interface
At this point, Metabase is started and listening on port 3000. Now, open your web browser and access Metabase using the URL http://your-server-ip:3000. You should see the following page:
Click on the “**Let’s get started**“. You should see the following page:
Select your language and click on the **Next** button. You should see the following page:
Provide your full name, email address, and password and click on the **Next** button. You should see the following page:
Provide your database details and click on the **Next** button. You should see the following page:
Enable your “**Usage data preferences**” and click on the **Next** button. You should see the following page:
Provide your admin email address and click on the **Take me to Metabase** button. You should see the Metabase default dashboard in the following page:
## Conclusion
In this guide, you learned how to install and configure Metabase on CentOS 8. You can now use the application for gleaning new insights from your dataset. You can visit the Metabase official [documentation](https://metabase.com/docs/latest/) for more information. Try Metabase on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net using the tutorial above!
---
# Atlantic.Net Announces New Initiatives to Help America’s Small to Mid-Size Businesses During the COVID-19 Pandemic
> URL: https://www.atlantic.net/press-releases/atlantic-net-announces-new-initiatives-to-help-americas-small-to-mid-size-businesses-during-the-covid-19-pandemic/ | Published: 2020-11-15 | Updated: 2024-06-11 | Author: Editorial Team
*Company to Offer Double the Resources at No Cost Permanently and Free Cloud Virtual Servers for One Full Year*
**ORLANDO, FLA. (November 15, 2020)** – [Atlantic.Net](https://www.atlantic.net/), a leading cloud services provider, today launched a plan that enables new cloud VPS customers double their server resources at no extra cost. This program aims to help businesses establish more permanent remote workforces in response to social distancing measures and work-from-home policies during COVID-19. Atlantic.Net will upgrade all cloud plans hosted at its Orlando data center to the capabilities of the next highest price bracket at no additional cost for new customers. Additionally, the company plans to offer this upgrade at all seven global data centers in the coming weeks. This program also includes Atlantic.Net’s Free-to-Use for One Year Server promotion, meaning that any new free tier users will be automatically upgraded from 1GB to 2GB Cloud Server usage for one full year.
“COVID 19 has put an incredible strain on IT and cloud services systems, with remote work scaling to a larger and more permanent levels. In order to help businesses, we’re offering even more flexibility to organizations reevaluating their cloud provider,” said Marty Puranik, CEO and Founder of Atlantic.Net. “We truly hope that this will not only help America’s small to mid-size businesses get more for less, but also our healthcare providers, who can now get audit-ready and healthcare compliant solutions for half the price!”
Initially, Atlantic.Net will offer the new program in its Orlando, Florida data center, with plans to make it available at all of its locations before the end of this year; the company provides scalable computing from seven international data centers including New York, London, San Francisco, Toronto, Dallas, Ashburn, and Orlando..
The Atlantic.Net Cloud Platform, which is engineered to provide fault-tolerant, and ultra-fast performance, includes award-winning Cloud Servers, Secure Block Storage, one-click applications, DNS, dedicated private nodes, private networking, RESTful API, data backup, a full suite of managed services, 24/7/365 expert U.S.-based support, and more. This infrastructure is ideally suited to support businesses and organizations as they evolve toward a distributed, remote work environment to mitigate the health risks of COVID-19 to the global workforce.
To view the latest cloud offerings and pricing structure, visit [https://www.atlantic.net/vps-hosting/](https://urldefense.proofpoint.com/v2/url?u=https-3A__www.atlantic.net_vps-2Dhosting_&d=DwMFAg&c=euGZstcaTDllvimEN8b7jXrwqOf-v5A_CdpgnVfiiMM&r=UChi3C1F2KzF3gDdKeDIWT0Y2FVnGxMftp5efqLBa9U&m=g04GC2HzMtXXVCRxt7u_STJ-x-16xkLdaBH77qqaSAM&s=Y-R78AI7NK1KhSzsD5fRocVtvoKvgdGMjTQ-ljhCweg&e=) .
**About Atlantic.Net**
Atlantic.Net is a global [cloud services](https://www.atlantic.net/hipaa-compliant-hosting/) provider with over 25 years of experience, serving thousands of developers and small, medium, and large clients in more than one hundred countries. Atlantic.Net specializes in managed and non-managed Windows, Linux, and FreeBSD server hosting solutions and has served dynamic business clients including Lenovo, Newegg, NASA, and Hilton, among others. With a focus on security, compliance, and simplifying the user experience, Atlantic.Net provides business-class dedicated and cloud hosting solutions, backed by 24/7/365 support in New York, London, San Francisco, Toronto, Dallas, Ashburn, and Orlando. For more information, please visit [Atlantic Net/](https://www.atlantic.net/).
---
# How to Install ONLYOFFICE Docs on Debian
> URL: https://www.atlantic.net/vps-hosting/how-to-install-onlyoffice-document-server-on-debian/ | Published: 2020-11-17 | Updated: 2025-09-03 | Author: Hitesh Jethva
ONLYOFFICE Docs is a free and open-source document server for small and medium-sized organizations. This web-based collaboration suite can manage documents, projects, teams, and customer relations from a central location. ONLYOFFICE Docs support several Open XML formats, including .xlsx, .pptx, and .docx, enabling real-time collaborative editing. You can use the ONLYOFFICE Docs API to integrate the ONLYOFFICE Document Editor into your website to manage editors.
This tutorial will show you how to install ONLYOFFICE Docs on Debian 12.
## Step 1- Install Nginx and Other Dependencies
First, you must install the Nginx webserver to serve the ONLYOFFICE Dcos. You can install it with the following command:
```
apt-get update -y
apt-get install nginx nginx-extras -y
```
After installing the Nginx web server, you must install RabbitMQ-server and Redis in your system. You can install both using the following command:
```
apt-get install redis-server rabbitmq-server gnupg2 curl -y
```
Once both packages are installed, start the RabbitMQ and Redis service with the following command:
```
systemctl start rabbitmq-server
systemctl start redis-server
```
Once you are finished, you can proceed to the next step.
## Step 2 – Install and Configure PostgreSQL
ONLYOFFICE uses PostgreSQL as a database backend, so you must install it on your server. You can install it using the following command:
```
apt-get install postgresql -y
```
Once installed, start the PostgreSQL service with the following command:
```
systemctl start postgresql
```
Next, log into the PostgreSQL shell with the following command:
```
su - postgres
postgres@debian12:~$ psql
```
Once logged in, you should get the following output:
```
psql (12.9 (Debian 12.9-0+deb10u1))
Type "help" for help.
```
Next, create a database and user for the Document server with the following command:
```
postgres=# CREATE DATABASE onlyoffice;
postgres=# CREATE USER onlyoffice WITH password 'onlyoffice';
postgres=# GRANT ALL privileges ON DATABASE onlyoffice TO onlyoffice;
```
Next, exit from the PostgreSQL shell with the following command:
```
postgres=# EXIT
```
Next, **rerun the exit command**to exit from the Postgres user:
```
exit
```
## Step 3 – Install ONLYOFFICE Docs
By default, the ONLYOFFICE Docs package is unavailable in the Debian 12 default repository, so you must add the ONLYOFFICE Docs repository to your system.
First, download and add the GPG key with the following command:
```
mkdir -p -m 700 ~/.gnupg
curl -fsSL https://download.onlyoffice.com/GPG-KEY-ONLYOFFICE | gpg --no-default-keyring --keyring gnupg-ring:/tmp/onlyoffice.gpg --import
chmod 644 /tmp/onlyoffice.gpg
chown root:root /tmp/onlyoffice.gpg
mv /tmp/onlyoffice.gpg /usr/share/keyrings/onlyoffice.gpg
```
Next, add the ONLYOFFICE Docs repository with the following command:
```
echo "deb [signed-by=/usr/share/keyrings/onlyoffice.gpg] https://download.onlyoffice.com/repo/debian squeeze main" | tee /etc/apt/sources.list.d/onlyoffice.list
```
Once the storage is added, update the repository with the following command:
```
apt-get update -y
```
Next, download and install the ttf-mscorefonts-installer and other packages using the following command.
```
wget http://ftp.de.debian.org/debian/pool/contrib/m/msttcorefonts/ttf-mscorefonts-installer_3.8.1_all.deb
dpkg -i ttf-mscorefonts-installer_3.8.1_all.deb
apt install x11-common xfonts-encodings libfontenc1 fonts-dejavu-extra cabextract xfonts-utils libcurl4 libxml2 fonts-dejavu fonts-liberation ttf-mscorefonts-installer fonts-crosextra-carlito fonts-takao-gothic fonts-opensymbol -y
```
You will get some dependency errors after running the above commands. You can fix it with the following management.
```
apt install -f
```
Finally, install the ONLYOFFICE Docs with the following command.
```
apt-get install onlyoffice-documentserver -y
```
During the installation, you will be asked to provide the password as shown below:
Provide your ONLYOFFICE database password that you created earlier, then hit Enter to finish the installation:
```
Setting up onlyoffice-documentserver (5.6.5-3) ...
Generating AllFonts.js, please wait...Done
Generating presentation themes, please wait...Done
Congratulations, the ONLYOFFICE docs has been installed successfully!
```
ONLYOFFICE creates an Nginx configuration file automatically during the installation. You can check it with the following command:
```
cat /etc/nginx/conf.d/ds.conf
```
Output:
```
include /etc/nginx/includes/http-common.conf;
server {
listen 0.0.0.0:80;
listen [::]:80 default_server;
server_tokens off;
include /etc/nginx/includes/ds-*.conf;
}
```
Next, restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 4 – Access ONLYOFFICE Docs Web UI
Now, open your web browser and access the ONLYOFFICE Docs web interface using the URL **http://your-server-ip**. You should see the ONLYOFFICE dashboard on the following screen:
Use the integrated test example, a simple doc management system, to check if the editors are running correctly. Run the following command in your terminal.
```
systemctl start ds-example
```
Now, click on the **GO TO TEST EXAMPLE.** You will see your example docs on the following screen.
## Conclusion
Congratulations! You have successfully installed the ONLYOFFICE Docs on Debian 12. You can now integrate ONLYOFFICE Docs API into your website and edit your documents. For more information, visit the ONLYOFFICE [documentation](https://api.onlyoffice.com/editors/basic) page. Start using ONLYOFFICE on your Alantic.Net [VPS Hosting](https://www.atlantic.net/vps-hosting/) account!
---
# How to Install MyWebSQL on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-mywebsql-on-centos-8/ | Published: 2020-11-18 | Updated: 2023-11-25 | Author: Hitesh Jethva
MyWebSQL is a free, open-source, web-based MySQL database client written in PHP. It supports MySQL, PostgreSQL, and SQLite databases, and can be used to perform all database-related operations and is compatible with all major web browsers. MyWebSQL is simple, fast, easy-to-use, and allows you to keep track of your databases from any location and to edit and delete multiple records at the same time.
In this tutorial, we will show you how to install MyWebSQL on CentOS 8.
## Step 1 – Install LAMP Server
First, you will need to install the Apache web server, MariaDB server, PHP, and other required modules in your system. You can install all of them by running the following command:
```
dnf install httpd mariadb-server php php-cli php-mysqlnd php-zip php-devel php-gd php-mbstring
php-curl php-xml php-pear php-bcmath php-json unzip curl wget -y
```
Once all the packages are installed, start the Apache and MariaDB service and enable them to start at system reboot:
```
systemctl start httpd
systemctl start mariadb
systemctl enable httpd
systemctl enable mariadb
```
## Step 2 – Configure MariaDB Database
First, you will need to secure the MariaDB and set a root password. You can do it with the following command:
```
mysql_secure_installation
```
Answer all the questions as shown below:
```
Enter current password for root (enter for none):
OK, successfully used password, moving on...
Set root password? [Y/n] Y
New password:
Re-enter new password:
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
```
Once your MariaDB is secured, you can proceed to the next step.
## Step 3 – Download MyWebSQL
First, download the latest version of the MyWebSQL with the following command:
```
wget https://downloads.sourceforge.net/project/mywebsql/stable/mywebsql-3.7.zip
```
Once downloaded, unzip the downloaded file with the following command:
```
unzip mywebsql-3.7.zip
```
Next, copy the extracted directory to the Apache root directory:
```
mv mywebsql /var/www/html/
```
Next, change the ownership of the mywebsql directory to apache:
```
chown -R apache:apache /var/www/html/mywebsql/
```
Once you are finished, you can proceed to the next step.
## Step 4 – Access MyWebSQL
Now, open your web browser and type the URL http://your-server-ip/mywebsql. You will be redirected to the MyWebSQL login page:
Provide your MariaDB root username and password and click on the **Login** button. You should see the MyWebSQL dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed MyWebSQL on CentOS 8. I hope you can now easily manage your databases from a central location. MyWebSQL is very useful for those who don’t know how to use the command line. Get started with MyWebSQL on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Allow Remote Connection to MySQL Database Server
> URL: https://www.atlantic.net/vps-hosting/how-to-allow-remote-connection-to-mysql-database-server/ | Published: 2020-11-19 | Updated: 2023-11-16 | Author: Hitesh Jethva
Many websites and applications host their web server and database backend on the same machine. However, some organizations are moving to a distributed environment. A separate database server can improve hardware performance and security and allows you to scale resources quickly.
By default, MySQL is configured to allow connections only from the localhost. You will need to allow remote access to the MySQL database server if your application and database are hosted on different servers.
In this tutorial, we will show you how to enable remote connections to a MySQL database.
## Step 1 – Configure MySQL
Before starting, verify the MySQL listening connection with the following command:
```
ss -tunlp | grep 3306
```
You should get the following output:
```
tcp LISTEN 0 151 127.0.0.1:3306 0.0.0.0:*
users:(("mysqld",pid=7753,fd=33))
```
As you can see, the MySQL server is listening on the localhost on port 3306. That means the MySQL server is accessible only from the localhost.
You will need to configure MySQL server to listen for an external IP address where the server can be reached.
To enable this, edit the mysqld.cnf file:
```
nano /etc/mysql/mysql.conf.d/mysqld.cnf
```
Find the following line:
```
bind-address = 127.0.0.1
```
And replace it with the following line:
```
bind-address = 0.0.0.0
```
Save and close the file when you are finished, then, restart the MySQL service to implement the changes:
```
systemctl restart mysql
```
At this point, MySQL server is configured to listen on external IP.
## Step 2 – Grant Access to User from Remote System
In this section, we will create a new database and database user and grant access to the remote system to connect to the database.
First, log in to the MySQL shell with the following command:
```
mysql
```
Once logged in, create a database named testdb and a user named testuser for a remote system using the following command:
```
CREATE DATABASE testdb;
CREATE USER 'testuser'@'remote-server-ip' IDENTIFIED BY 'password';
```
Next, grant access to the remote system (remote-server-ip) to connect to a database named testdb as a testuser:
```
GRANT ALL PRIVILEGES ON testdb.* TO 'testuser'@'remote-server-ip';
```
Next, flush the privileges and exit from the MySQL shell with the following command:
```
FLUSH PRIVILEGES ;
EXIT;
```
**In the example above:**
**testdb**: The name of the database.
**testuser**: The name of the user.
**remote-server-ip**: The IP address of the remote system.
## Step 3 – Verify Database Connection
At this point, MySQL is configured to allow remote connections from the IP remote-server-ip.
Now, log in to the remote system and connect to the MySQL server with the following command:
```
mysql -u testuser -h remote-server-ip -p
```
Provide the password for testuser and hit Enter. If everything is set up correctly, you will be able to log in to the remote MySQL server. Next, list the database with the following command:
```
show databases;
```
You should see the following output:
```
+--------------------+
| Database |
+--------------------+
| information_schema |
| testdb |
+--------------------+
2 rows in set (0.01 sec)
```
## Conclusion
In the above guide, we learned how to enable MySQL remote connection and grant access to the remote system to connect the database, and you can now host your application using a database hosted on the remote server. Get started with a MySQL remote connection on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today! We can even help with your HIPAA [compliant database](https://www.atlantic.net/hipaa-compliant-hosting/).
---
# How to Install Nginx with RTMP Module on Ubuntu 24.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-nginx-with-rtmp-module-on-ubuntu/ | Published: 2020-11-20 | Updated: 2025-12-21 | Author: Hitesh Jethva
RTMP (Real-Time Messaging Protocol) is a streaming protocol originally developed by Macromedia to deliver audio, video, and data over the internet with low latency. It is still widely used today for live video streaming, especially when pushing streams from tools like OBS or FFmpeg to a media server.
The Nginx RTMP module extends Nginx into a lightweight yet powerful streaming server. It supports live RTMP streaming, HLS (HTTP Live Streaming) generation, video-on-demand playback, and even on-the-fly transcoding when combined with FFmpeg. Because Nginx is fast, stable, and resource-efficient, it is a popular choice for self-hosted streaming setups.
In this tutorial, you will compile Nginx 1.28.0 from source with the RTMP module enabled and set up a live RTMP + HLS streaming server on Ubuntu 24.04. This procedure has been tested on Ubuntu 20.04, 22.04, and 24.04.
## Step 1: Install Required Dependencies
First, update your system.
```
apt update -y
```
To compile Nginx with the RTMP module, you need several build tools and libraries. These packages provide compiler support, compression, SSL, media processing, and additional Nginx features such as HTTP streaming and image handling. You can install all required tools using the below command.
```
apt install -y build-essential wget git ffmpeg unzip libpcre3 libpcre3-dev zlib1g zlib1g-dev libssl-dev libxml2 libxml2-dev libxslt1-dev libgd-dev geoip-database libgeoip-dev perl perl-modules
```
Next, create a dedicated system user for Nginx. Running Nginx as a non-login user improves security.
```
useradd -r -s /sbin/nologin nginx
```
## Step 2: Download Required Components
In this step, you will download the Nginx source code, OpenSSL source, and the Nginx RTMP module. These components are required to compile Nginx with RTMP support enabled.
First, download the latest Nginx source.
```
wget http://nginx.org/download/nginx-1.28.0.tar.gz
```
After the download completes, extract the archive.
```
tar -xvzf nginx-1.28.0.tar.gz
```
This creates a new directory named nginx-1.28.0 containing the Nginx source files.
Nginx will link against OpenSSL during compilation. Download the required OpenSSL version.
```
wget https://www.openssl.org/source/openssl-1.1.0h.tar.gz
tar -xzvf openssl-1.1.0h.tar.gz
```
Next, clone the RTMP module repository from GitHub.
```
git clone https://github.com/sergey-dryabzhinsky/nginx-rtmp-module.git
```
This module adds RTMP, HLS, and VOD streaming capabilities to Nginx.
## Step 3: Compile and Install Nginx with RTMP Support
Now that all required source components are available, you can compile Nginx with the RTMP module enabled. This step builds a custom Nginx binary with streaming, SSL, and HTTP features.
Change into the extracted Nginx source directory.
```
cd nginx-1.28.0
```
Run the following ./configure command to enable RTMP, SSL, HTTP streaming, and other commonly used modules.
```
./configure \
--prefix=/etc/nginx \
--sbin-path=/usr/sbin/nginx \
--conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--http-log-path=/var/log/nginx/access.log \
--pid-path=/var/run/nginx.pid \
--lock-path=/var/run/nginx.lock \
--user=nginx \
--group=nginx \
--with-threads \
--with-file-aio \
--with-http_ssl_module \
--with-http_v2_module \
--with-http_realip_module \
--with-http_addition_module \
--with-http_xslt_module \
--with-http_image_filter_module \
--with-http_geoip_module \
--with-http_sub_module \
--with-http_flv_module \
--with-http_mp4_module \
--with-http_gunzip_module \
--with-http_gzip_static_module \
--with-http_stub_status_module \
--with-stream \
--with-stream_ssl_module \
--with-openssl=../openssl-1.1.0h \
--add-module=../nginx-rtmp-module
```
After the configuration completes successfully, compile and install Nginx.
```
make
make install
```
The compilation process may take a few minutes depending on your server’s resources.
Check the installed Nginx version and build options.
```
nginx -V
```
You should see output similar to the following, confirming RTMP and OpenSSL support:
```
nginx version: nginx/1.28.0
built by gcc 13.3.0 (Ubuntu 13.3.0-6ubuntu2~24.04)
built with OpenSSL 1.1.0h 27 Mar 2018
TLS SNI support enabled
configure arguments: --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --user=nginx --group=nginx --with-threads --with-file-aio --with-http_ssl_module --with-http_v2_module --with-http_realip_module --with-http_addition_module --with-http_xslt_module --with-http_image_filter_module --with-http_geoip_module --with-http_sub_module --with-http_flv_module --with-http_mp4_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_stub_status_module --with-stream --with-stream_ssl_module --with-openssl=../openssl-1.1.0h --add-module=../nginx-rtmp-module
```
Once verified, Nginx is successfully installed with RTMP support. In the next step, you will create a systemd service to manage the Nginx service.
## Step 4: Create systemd Service for Nginx
Since you compiled Nginx from source, it does not include a systemd service file by default. You need to create one so you can start, stop, and manage Nginx using systemctl.
Create a service file.
```
nano /lib/systemd/system/nginx.service
```
Add the following content:
```
[Unit]
Description=nginx - high performance web server
After=network.target
[Service]
Type=forking
PIDFile=/var/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID
[Install]
WantedBy=multi-user.target
```
Reload systemd to apply the new service file.
```
systemctl daemon-reload
```
Start the Nginx service.
```
systemctl start nginx
```
Enable Nginx to start automatically at boot.
```
systemctl enable nginx
```
## Step 5: Configure Nginx RTMP and HLS Streaming
With Nginx installed and running, the next step is to configure it for RTMP live streaming, HLS playback, and VOD support.
First, backup the Nginx main configuration file.
```
mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak
```
Next, create a new configuration file.
```
nano /etc/nginx/nginx.conf
```
Add the below configuration.
```
worker_processes auto;
events {
worker_connections 1024;
}
rtmp {
server {
listen 1935;
chunk_size 4000;
application show {
live on;
hls on;
hls_path /mnt/hls;
hls_fragment 3;
hls_playlist_length 60;
deny play all;
}
application stream {
live on;
}
application vod {
play /mnt/mp4s;
}
}
}
http {
sendfile off;
tcp_nopush on;
server {
listen 8080;
location / {
root /mnt;
add_header Cache-Control no-cache;
types {
application/vnd.apple.mpegurl m3u8;
video/mp2t ts;
}
}
}
}
```
Create directories for HLS and VOD content.
```
mkdir -p /mnt/hls /mnt/mp4s
chown -R nginx:nginx /mnt
```
Apply the new configuration by restarting Nginx.
```
systemctl restart nginx
```
## Step 6: Start RTMP Streaming Using FFmpeg
Now that the RTMP and HLS server is configured, you can push a live stream to Nginx using FFmpeg. This step helps you verify that RTMP ingestion and playback are working correctly.
First, download the sample video file from the URL https://file-examples.com/index.php/sample-video-files/sample-mp4-files/.
```
wget https://file-examples.com/storage/febe13078a694784e9dcb0b/2017/04/file_example_MP4_1280_10MG.mp4 -O myfile.mp4
```
Use FFmpeg to send the video to the RTMP application configured earlier.
```
ffmpeg -re -i myfile.mp4 -vcodec libx264 -acodec aac -f flv rtmp://your-server-ip:1935/show/vod
```
## Step 7: Test RTMP and HLS Playback
After pushing the stream to the RTMP server, the final step is to confirm that playback works correctly using both RTMP and HLS clients.
On the client system, open the VLS media player, go to VLC Media => Open Network Stream. You should see the following screen:
Provide your RTMP streaming server URL and click on the Play button.
Once you are connected successfully, you should see your MP4 video in the following screen:
## Conclusion
You have successfully installed Nginx 1.28.0 with the RTMP module on Ubuntu 24.04 and built a working live streaming server from source. This setup allows you to accept incoming RTMP streams, generate HLS segments in real time, and serve them over HTTP for broad device compatibility.
---
# Top ps Command Examples to Monitor Your Linux Processes
> URL: https://www.atlantic.net/dedicated-server-hosting/top-ps-command-examples-to-monitor-your-linux-processes/ | Published: 2020-11-22 | Updated: 2023-11-21 | Author: Hitesh Jethva
The ps command, also called “processes status,” is a tool to view information about running processes on a Linux-based operating system. It is used to monitor all running processes along with USER, PID, %CPU, %MEM, VSZ, RSS, TTY, STAT, and many more. The ps command is very useful, allowing system administrators to find the PID of any process to troubleshoot issues. It is one of the most powerful and essential process management tools that every Linux user should know and learn.
## 1. List All Processes of the Current User
You can use the ps command without any parameters to display a list of all running processes started by the user who ran the command.
```
ps
```
You should see the following output:
```
PID TTY TIME CMD
3871 pts/5 00:00:00 bash
5633 pts/5 00:00:00 ps
```
As you can see, there are four columns. A brief explanation of each column is shown below:
**PID :** Specifies the process ID of the process.
**TTY :** Specifies the name of the console the user logged in.
**TIME :** Specifies the amount of CPU processing time.
**CMS :** Specifies the command used to launch the process.
## 2. List Processes for All Users
You can list all processes started by all users using the following command:
```
ps -ef | less
```
or
```
ps ax | less
```
You should see all the processes in the following screen:
## 3. List Processes by User
You can also filter the processes using the option -u followed by the username.
For example, to list all processes owned by www-data user, use the following command:
```
ps -f -u www-data
```
You should see the following screen:
You can also specify multiple usernames using a comma.
For example, to list all processes owned by the www-data and root users, use the following command:
```
ps -f -u www-data,root
```
## 4. List Processes by Name or PID
To list the processes, by name use the -C option with search term.
For example, to list the processes of MySQL, run the following command:
```
ps -C mysqld
```
Or
```
ps -ef | grep mysql
```
You should see the following screen:
You can also list the processes by process id using the -p option.
```
ps -f -p 11560
```
You should see the Apache process in the following output:
```
UID PID PPID C STIME TTY TIME CMD
www-data 11560 11559 0 Jun12 ? 00:00:00 /usr/sbin/apache2 -k start
```
## 5. Sort Processes by CPU and Memory Usage
Sometimes you will need to find out processes that are consuming lots of CPU and Memory. In this case, you can sort the process list based on a specific field or parameter.
Run the following command to list the top 10 processes consuming most of the CPU and Memory:
```
ps aux --sort=-pcpu,+pmem | head -10
```
You should see the following screen:
## 6. Display Processes in Realtime
You can also display the top CPU and Memory consuming processes using the watch command with ps:
```
watch -n 1 'ps -e -o pid,uname,cmd,pmem,pcpu --sort=-pmem,-pcpu | head -15'
```
You should see the following screen:
## 7. List the Process Tree
Some processes are forked out of parent processes. This can help you to figure out an issue or identify a particular process. You can use -e option with –forest to show how processes are linked in a Linux.
```
ps -e --forest
```
You should see the following screen:
## 8. Display Elapsed Time of Running Processes
You can find out how long the process has been running for using the -o option:
```
ps -e -o pid,comm,etime | less
```
You should see the following screen:
## Conclusion
In the above guide, you learned how to use the ps command to monitor Linux processes. Try using the ps command today on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to Install Seafile to Sync and Share Files on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-seafile-to-sync-and-share-files-on-centos-8/ | Published: 2020-11-23 | Updated: 2023-11-25 | Author: Hitesh Jethva
Seafile is a free, open-source, self-hosted file-sharing solution for Linux. It is a cross-platform file-hosting software that can be used to store files on a central server and sync them with your personal computer or mobile device. Seafile is written with Python Django framework and is functionally very similar to Dropbox and Google Drive. It has a lot of features including file encryption, version control, two-factor authentication, online editing, file locking, and many more.
In this tutorial, we will show you how to install Seafile with Nginx as a reverse proxy on CentOS 8.
## Prerequisites
- A fresh CentOS 8 [VPS](https://www.atlantic.net/vps-hosting/)
- A valid domain name pointed to your server IP
- A root password is configured on your server
## Step 1 – Install Required Dependencies
First, you will need to install the EPEL repository in your system. You can install it with the following command:
```
yum install epel-release -y
```
Once the EPEL repository is installed, install other dependencies with the following command:
```
yum install python3 python3-devel python3-setuptools gcc gcc-c++ freetype-devel python3-pip
python3-ldap memcached java-1.8.0-openjdk libmemcached libreoffice-headless libreoffice-pyuno
libffi-devel pwgen curl tar -y
```
Once all the dependencies are installed, use the pip command to install other dependencies:
```
pip3 install Pillow pylibmc captcha jinja2 sqlalchemy psd-tools django-pylibmc django-simple-
captcha
```
Once all the packages are installed, enable the Memcached service to start at system reboot:
```
systemctl enable --now memcached
```
## Step 2 – Install Nginx and MariaDB
Next, you will need to install Nginx and MariaDB server on your system. You can install both packages with the following command:
```
yum install nginx mariadb-server -y
```
Once installed, start the Nginx and MariaDB services and enable them to start at system reboot:
```
systemctl start nginx
systemctl start mariadb
systemctl enable nginx
systemctl enable mariadb
```
## Step 3 – Create a Database for Seafile
First, you will need to set the MariaDB root password and secure the MariaDB installation. You can do it using the following script:
```
mysql_secure_installation
```
Answer all the questions as shown below:
```
Enter current password for root (enter for none):
Set root password? [Y/n] Y
New password:
Re-enter new password:
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
```
Next, log in to the MariaDB shell with the following command:
```
mysql -u root -p
```
Once logged in, create a database for Seafile with the following command:
```
create database `ccnetdb` character set = 'utf8';
create database `seafiledb` character set = 'utf8';
create database `seahubdb` character set = 'utf8';
```
Next, create a user for Seafile with the following command:
```
create user 'seafile'@'localhost' identified by 'yourpassword';
```
Next, grant all the privileges to the ccnetdb, seafiledb and seahubdb with the following command:
```
GRANT ALL PRIVILEGES ON `ccnetdb`.* to `seafile`@localhost;
GRANT ALL PRIVILEGES ON `seafiledb`.* to `seafile`@localhost;
GRANT ALL PRIVILEGES ON `seahubdb`.* to `seafile`@localhost;
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 4 – Install Seafile
First, download the latest version of Seafile with the following command:
```
wget https://s3.eu-central-1.amazonaws.com/download.seadrive.org/seafile-server_7.1.5_x86-
64.tar.gz
```
Once downloaded, extract the downloaded file with the following command:
```
tar -xvzf seafile-server_7.1.5_x86-64.tar.gz
```
Next, move the extracted directory to /opt with the following command:
```
mv seafile-server-* /opt/seafile
cd /opt/seafile
```
Next, change the directory to /opt/seafile and set up the Seafile server by running the following script:
```
./setup-seafile-mysql.sh
```
You will be asked to provide the server name, valid domain name, and database details as shown below.
```
Checking python on this machine ...
-----------------------------------------------------------------
This script will guide you to setup your seafile server using MySQL.
Make sure you have read seafile server manual at
https://download.seafile.com/published/seafile-manual/home.md
Press ENTER to continue
-----------------------------------------------------------------
What is the name of the server? It will be displayed on the client.
3 - 15 letters or digits
[ server name ] seafile
What is the ip or domain of the server?
For example: www.mycompany.com, 192.168.1.101
[ This server's ip or domain ] seafile.example.com
Which port do you want to use for the seafile fileserver?
[ default "8082" ]
-------------------------------------------------------
Please choose a way to initialize seafile databases:
-------------------------------------------------------
[1] Create new ccnet/seafile/seahub databases
[2] Use existing ccnet/seafile/seahub databases
[ 1 or 2 ] 2
What is the host of mysql server?
[ default "localhost" ]
What is the port of mysql server?
[ default "3306" ]
Which mysql user to use for seafile?
[ mysql user for seafile ] seafile
What is the password for mysql user "seafile"?
[ password for seafile ]
verifying password of user seafile ... done
Enter the existing database name for ccnet:
[ ccnet database ] ccnetdb
verifying user "seafile" access to database ccnetdb ... done
Enter the existing database name for seafile:
[ seafile database ] seafiledb
verifying user "seafile" access to database seafiledb ... done
Enter the existing database name for seahub:
[ seahub database ] seahubdb
verifying user "seafile" access to database seahubdb ... done
```
Provide each detail carefully. Once the installation has been completed, you should see the following output:
```
---------------------------------
This is your configuration
---------------------------------
server name: seafile
server ip/domain: seafile.example.com
seafile data dir: /opt/seafile-data
fileserver port: 8082
database: use existing
ccnet database: ccnetdb
seafile database: seafiledb
seahub database: seahubdb
database user: seafile
---------------------------------
Press ENTER to continue, or Ctrl-C to abort
-----------------------------------------------------------------
Your seafile server configuration has been finished successfully.
-----------------------------------------------------------------
run seafile server: ./seafile.sh { start | stop | restart }
run seahub server: ./seahub.sh { start | stop | restart }
-----------------------------------------------------------------
If you are behind a firewall, remember to allow input/output of these tcp ports:
-----------------------------------------------------------------
port of seafile fileserver: 8082
port of seahub: 8000
When problems occur, Refer to
https://download.seafile.com/published/seafile-manual/home.md
for information.
```
## Step 5 – Set Up Admin Account
Next, you will need to set up an admin account to access Seafile. First, start the Seafile service with the following command:
```
/opt/seafile/seafile.sh start
```
Next, start the Seahub service to set an admin password:
```
/opt/seafile/seahub.sh start
```
You will be asked to set an admin username and password as shown below.
```
LC_ALL is not set in ENV, set to en_US.UTF-8
Starting seahub at port 8000 ...
----------------------------------------
It's the first time you start the seafile server. Now let's create the admin account
----------------------------------------
What is the email for the admin account?
[ admin email ] admin@example.com
What is the password for the admin account?
[ admin password ]
Enter the password again:
[ admin password again ]
----------------------------------------
Successfully created seafile admin
----------------------------------------
```
Next, stop the Seafile and Seahub services with the following command:
```
/opt/seafile/seafile.sh stop
/opt/seafile/seahub.sh stop
```
## Step 6 – Create a Systemd Service File for Seafile
Next, you will need to create systemd service files for Seafile and Seahub to manage the services. First, create a service file for Seafile using the following command:
```
nano /etc/systemd/system/seafile.service
```
Add the following lines:
```
[Unit]
Description=Seafile
After= mysql.service
After=network.target
[Service]
Type=forking
ExecStart=/opt/seafile-server-latest/seafile.sh start
ExecStop=/opt/seafile-server-latest/seafile.sh stop
[Install]
WantedBy=multi-user.target
```
Save and close the file, then create a service file for Seahub with the following command:
```
nano /etc/systemd/system/seahub.service
```
Add the following lines:
```
[Unit]
Description=Seafile
After= mysql.service
After=network.target
[Service]
Type=forking
ExecStart=/opt/seafile-server-latest/seahub.sh start
ExecStop=/opt/seafile-server-latest/seahub.sh stop
[Install]
WantedBy=multi-user.target
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the Seafile and Seahub service and enable them to start at system reboot with the following command:
```
systemctl start seafile
systemctl enable seafile
systemctl start seahub
systemctl enable seahub
```
At this point, Seafile server is started and listening on port 8000. You can verify it with the following command:
```
ss -tunelp | grep 8000
```
You should get the following output:
```
tcp LISTEN 0 128 127.0.0.1:8000 0.0.0.0:*
users:(("python3",pid=44925,fd=8),("python3",pid=44924,fd=8),("pyt
hon3",pid=44923,fd=8),("python3",pid=44922,fd=8),("python3",pid=44921,fd=8),("python3",pid=44916,fd=8)) ino:77620 sk:9
<->
```
## Step 7 – Configure Nginx for Seafile
Next, you will need to configure Nginx as a reverse proxy to access Seafile using port 80. You can configure it with the following command:
```
nano /etc/nginx/conf.d/seafile.conf
```
Add the following lines:
```
server {
listen 80;
listen [::]:80;
server_name seafile.example.com;
autoindex off;
client_max_body_size 100M;
access_log /var/log/nginx/seafile.com.access.log;
error_log /var/log/nginx/seafile.com.error.log;
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Host $server_name;
proxy_read_timeout 1200s;
}
location /seafhttp {
rewrite ^/seafhttp(.*)$ $1 break;
proxy_pass http://127.0.0.1:8082;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_connect_timeout 36000s;
proxy_read_timeout 36000s;
proxy_send_timeout 36000s;
send_timeout 36000s;
}
location /media {
root /opt/seafile-server-latest/seahub;
}
}
```
Save and close the file, then restart the Nginx service with the following command:
```
systemctl restart nginx
```
If you got any errors, then edit the Nginx.conf file:
```
nano /etc/nginx/nginx.conf
```
Add the following line below http {:
```
server_names_hash_bucket_size 64;
```
Save and close the file, then restart the Nginx service:
```
systemctl restart nginx
```
## Step 8 – Access Seafile Web Interface
At this point, Nginx is configured to serve Seafile. Now, open your web browser and access the Seafile web interface using the URL **http://seafile.example.com**. You will be redirected to the Seafile login page:
Provide your admin username and password and click on the **Login** button. You should see the Seafile dashboard on the following page:
## Conclusion
In the above tutorial, you learned how to install the Seafile server with Nginx as a reverse proxy on CentOS 8. You can now upload your files and personal photos to the Seafile server, share them with your friends, and access them from your computer or mobile device. Try Seafile on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net using the tutorial above!
---
# How to Install Mailtrain Newsletter Application on Ubuntu 20.04.
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-mailtrain-newsletter-application-on-ubuntu-20-04/ | Published: 2020-11-24 | Updated: 2023-11-14 | Author: Hitesh Jethva
Mailtrain is a free, open-source, self-hosted newsletter application and email marketing tool. It is built on Node.js and uses MySQL/MariaDB as a database backend. Mailtrain is not only a newsletter app, but also provides other features including list management, a template editor, RSS campaigns, custom fields, and much more. You can integrate Mailtrain with an external SMTP server or use a local SMTP server to send emails, and you can use the RSS feed to generate a newsletter automatically and send emails to all subscribers.
In this tutorial, we will learn how to install Mailtrain Newsletter Application on Ubuntu 20.04.
## Step 1 – Install and Configure MariaDB Server
Mailtrain uses MySQL/MariaDB as a database backend, so a MariaDB server must be installed in your system. If not installed, you can install it using the following command:
```
apt-get install mariadb-server mariadb-client -y
```
After installing the MariaDB server, you will need to set up a MariaDB root password. You can set up it with the following command:
mysql_secure_installation
Answer all the questions as shown below to reset the root password and secure MariaDB:
```
Enter current password for root (enter for none):
Set root password? [Y/n] Y
New password:
Re-enter new password:
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
```
Next, log in to MariaDB and create a database and user for Mailtrain.
```
mysql -u root -p
```
Provide your MariaDB root password, then create a database with the following command:
```
create database mailtrain;
```
Next, create a user and grant all the privileges to the Mailtrain database:
```
grant all privileges on mailtrain.* to mailtrain@localhost identified by 'password';
grant all privileges on mailtrain.* to mailtrain_readonly@localhost identified by 'password';
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
flush privileges;
exit;
```
## Step 2 – Install Node.js
Mailtrain is built on Node.js, so you will need to install it in your system. In this tutorial, we will install Node.js using Snapd, so you will need to install Snapd and other packages in your system. You can install them with the following command:
```
apt-get install snapd git build-essential -y
```
Once all the required packages are installed, run the following command to install Node.js:
```
snap install node --classic --channel=8/stable
```
Next, log out of the system and log in again to activate the snapd.
Once logged in, verify the Node.js version using the following command:
```
node -v
```
You should see the following output:
```
v8.16.0
```
## Step 3 – Install and Configure Mailtrain
First, create a separate user and group for Mailtrain.
```
adduser --system --group mailtrain
```
You should see the following output:
```
Adding system user `mailtrain' (UID 112) ...
Adding new group `mailtrain' (GID 121) ...
Adding new user `mailtrain' (UID 112) with group `mailtrain' ...
Creating home directory `/home/mailtrain' ...
```
Next, create a directory for Mailtrain with the following command:
```
mkdir -p /var/www/html
```
Next, change the directory to /var/www/html and download the latest version of Mailtrain from the Git repository using the following command:
```
cd /var/www/html
git clone https://github.com/Mailtrain-org/mailtrain.git
```
Next, import the Mailtrain database with the following command:
```
mariadb -u mailtrain -p mailtrain < /var/www/html/mailtrain/setup/sql/mailtrain.sql
```
Next, create a new Mailtrain configuration file:
```
nano /var/www/html/mailtrain/config/production.toml
```
Add the following lines:
```
user="mailtrain"
group="mailtrain"
[log]
level="error"
[www]
port="3000"
# HTTP interface to listen on
host="0.0.0.0"
[mysql]
host="localhost"
user="mailtrain"
password="password"
database="mailtrain"
[queue]
processes=5
```
Save and close the file, then create a configuration file for the report worker.
```
nano /var/www/html/mailtrain/workers/reports/config/production.toml
```
Add the following lines:
```
[log]
level="error"
[mysql]
user="mailtrain_readonly"
password="password"
```
Next, change the ownership and permissions of the mailtrain directory:
```
chown -R mailtrain:mailtrain /var/www/html/mailtrain/
chmod -R 775 /var/www/html/mailtrain/
```
Next, you will also need to install Python version 2.7 and create a symlink:
```
apt-get install python2.7 -y
ln -s /usr/bin/python2.7 /usr/bin/python
```
Next, change the directory to mailtrain and install required node packages with the following command:
```
cd /var/www/html/mailtrain
sudo -u mailtrain npm config set scripts-prepend-node-path true
sudo -u mailtrain npm install --no-progress --production --unsafe-perm=true
```
## Step 4 – Create a Systemd Service File for Mailtrain
Next, you will need to create a systemd service file to manage the Mailtrain application. You can create it with the following command:
```
nano /etc/systemd/system/mailtrain.service
```
Add the following lines:
```
[Unit]
Description=Mailtrain server
#Requires=mysql.service
After=syslog.target network.target
[Service]
Environment="NODE_ENV=production"
WorkingDirectory=/var/www/html/mailtrain
ExecStart=/snap/bin/node index.js
Type=simple
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.target
# Alias=mailtrain.service
```
Save and close the file, then reload the systemd daemon to apply the changes:
```
systemctl daemon-reload
```
Next, start the Mailtrain service and enable it to start at system reboot with the following command:
```
systemctl start mailtrain
systemctl enable mailtrain
```
Next, verify the status of Mailtrain with the following command:
```
systemctl status mailtrain
```
You should get the following output:
- ```
mailtrain.service - Mailtrain server
Loaded: loaded (/etc/systemd/system/mailtrain.service; disabled; vendor preset: enabled)
Active: active (running) since Fri 2020-10-30 06:11:52 UTC; 18s ago
Main PID: 31946 (mailtrain)
Tasks: 20 (limit: 4691)
Memory: 231.0M
CGroup: /system.slice/mailtrain.service
├─31946 mailtrain
└─31986 /snap/node/2310/bin/node /var/www/html/mailtrain/services/sender.js
```
```
Oct 30 06:11:52 ubuntu2004 systemd[1]: Started Mailtrain server.
```
At this point, Mailtrain is started and listening on port 3000. You can verify it with the following command:
```
ss -tunelp | grep 3000
```
You should get the following output:
```
tcp LISTEN 0 511 0.0.0.0:3000 0.0.0.0:*
users:(("mailtrain",pid=32013,fd=10)) ino:79343 sk:11 <->
```
## Step 5 – Access Mailtrain Web Interface
Now, open your web browser and access the Mailtrain using the URL **http://your-server-ip:3000**. You will be redirected to the following page:
Now, click on the **Sign** **in** button. You should see the Mailtrain login page:
Provide default username as **admin** and the password as **test** then click on the **Sign**–**in** button. You should see the Mailtrain default dashboard on the following screen:
## Conclusion
Congratulations! You have successfully installed and configured the Mailtrain newsletter application on Ubuntu 20.04. Now, you can configure the SMTP server setting or use an external SMTP server and start managing your email subscription lists. Start using Mailtrain today on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to Install and Configure Nextcloud on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-configure-nextcloud-on-ubuntu-20-04/ | Published: 2020-11-25 | Updated: 2024-03-04 | Author: Hitesh Jethva
Nextcloud is a free, open-source file share and collaboration platform – the most widely used one – that allows you to host your own file hosting services. It is a fork of ownCloud and very similar to other storage solutions including Dropbox, Google Drive, and others. Nextcloud allows you to store your personal contents, files, documents, and photos and share them with your friends and family. It comes with a lot of add-ons that help you to extend its functionality.
In this tutorial, we will show you how to install Nextcloud server and client on Ubuntu 20.04.
## Prerequisites
- A fresh Ubuntu 20.04 [VPS](https://www.atlantic.net/vps-hosting/) on the Atlantic.Net Cloud Platform
- A desktop system running Ubuntu 20.04
- A valid domain name pointed to your server IP
- A root password configured on your server
## Step 1 – Install LAMP Server
Before starting, a LAMP stack must be installed on your server. If not installed, you can install them with the following command:
```
apt-get install apache2 mariadb-server libapache2-mod-php php php-gmp php-bcmath php-gd php-
json php-mysql php-curl php-mbstring php-intl php-imagick php-xml php-zip bzip2 -y
```
Once all the packages are installed, edit the php.ini file and modify some of the values according to your requirements.
```
nano /etc/php/7.4/apache2/php.ini
```
Change the following lines:
```
memory_limit = 512M
date.timezone = Asia/Kolkata
```
Save and close the file when you are finished, then restart the Apache service to apply the changes:
```
systemctl restart apache2
```
## Step 2 – Create a Nextcloud Database
Next, you will need to create a database and user for Nextcloud. First, connect to MariaDB with the following command:
```
mysql
```
Once connected, create a database and user with the following command:
```
create database nextclouddb;
grant all on nextclouddb.* to 'nextcloud'@'localhost' identified by 'yourpassword';
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
flush privileges;
exit;
```
## Step 3 – Download Nextcloud
First, download the latest version of Nextcloud from its official website with the following command:
```
wget https://download.nextcloud.com/server/releases/latest-20.tar.bz2
```
Once the download is completed, extract the downloaded file with the following command:
```
tar -jxvf latest-20.tar.bz2
```
Next, move the extracted directory to the Apache web root directory and give proper permissions with the following command:
```
mv nextcloud /var/www/html/
chown -R www-data:www-data /var/www/html/nextcloud
chmod -R 775 /var/www/html/nextcloud
```
Once you are done, you can proceed to configure the Apache server.
## Step 4 – Configure Apache for Nextcloud
Next, you will need to create an Apache virtual host configuration file to serve Nextcloud.
You can create it with the following command:
```
nano /etc/apache2/sites-available/nextcloud.conf
```
Add the following lines:
```
DocumentRoot "/var/www/html/nextcloud"
ServerName nextcloud.example.com
ErrorLog ${APACHE_LOG_DIR}/nextcloud.error
CustomLog ${APACHE_LOG_DIR}/nextcloud.access combined
Require all granted
Options FollowSymlinks MultiViews
AllowOverride All
Dav off
SetEnv HOME /var/www/html/nextcloud
SetEnv HTTP_HOME /var/www/html/nextcloud
Satisfy Any
```
Save and close the file, then enable the Apache virtual host with the following command:
```
a2ensite nextcloud.conf
```
Next, enable the required Apache modules with the following command:
```
a2enmod rewrite headers env dir mime setenvif ssl
```
Next, restart the Apache service to apply the configuration changes:
```
systemctl restart apache2
```
At this point, Apache web server is configured to serve Nextcloud.
## Step 5 – Access Nextcloud
Now, open your web browser and access the Nextcloud using the URL **http://nextcloud.example.com**. You should see the following page:
Set your admin username and password, define your database settings, and click on the **Finish** setup page. You should see the Nextcloud dashboard in the following page:
## Step 6 – Install and Configure Nextcloud Client
Nextcloud provides a client application for Android, Windows, iOS that can be used to connect your Nextcloud server. It allows users to access and sync files on the go.
On the client machine, install the Nextcloud application using the following command:
```
apt-get install software-properties-common gnupg2 -y
add-apt-repository ppa:nextcloud-devs/client
apt-get update -y
apt-get install nextcloud-client -y
```
Once the application is installed, launch the Nextcloud application from your Ubuntu DASH. You should see the following screen:
Provide your Nextcloud server URL and click on the **Next** button. You will be asked to provide your Nextcloud username and password:
Provide your username and password and click on the **Next** button. You should see the following page:
Select your desired settings and click on the **Connect** button. Once connected, you should see the following page:
Select OpenLocal Folder and click on the **Finish** button. You should see your Nextcloud folder in the following page:
You can now easily put any files and folders inside this directory and synchronize them with Nextcloud.
## Conclusion
In this guide, you learned how to install Nextcloud on Ubuntu 20.04 server. You also learned how to install the Nextcloud client on the Desktop machine and connect it with the Nextcloud server. You can now easily save and share your personal content with your friends and family. Try out Nextcloud on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Setup Private Docker Registry on Ubuntu 20.04
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-setup-private-docker-registry-on-ubuntu-20-04/ | Published: 2020-11-26 | Updated: 2023-11-21 | Author: Hitesh Jethva
Docker Registry is a centralized application that can be used to store your images and share them with other users. The private registry gives you full control to protect your images. You can also use Docker Hub to store your images, but these images will be public and anyone can access them.
In this tutorial, we will show you how to set up your own private Docker registry on Ubuntu 20.04.
## Step 1 – Setup Hostname Resolution
First, you will need to set up the hostname resolution on **both** the **registry server** and the **client machine** so that they can communicate with each other using the hostname.
You set up it by editing /etc/hosts file on both server and client machine:
```
nano /etc/hosts
```
Add the following lines:
```
your-server-ip registry-server
your-client-ip registry-client
```
Save and close the file when you are finished.
## Step 2 – Install Docker
Next, you will need to install Docker on **both the server and client** machines. By default, the latest version of Docker is not available in the Ubuntu 20.04 default repository, so you will need to add the Docker repository in your system.
First, install the required dependencies with the following command:
```
apt-get install apt-transport-https ca-certificates curl software-properties-common curl -y
```
After installing all dependencies, import the Docker GPG key using the following command:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
```
Next, add the Docker CE official repository to the APT source file with the following command:
```
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -
cs) stable"
```
Once the repository has been added, you will need to update the repository cache. You can update it with the following command:
```
apt-get update -y
```
Once your repository is up-to-date, run the following command to install the latest version of Docker CE to your system.
```
apt-get install docker-ce -y
```
Once the installation is completed, you can verify the installed version of Docker CE by running the following command:
```
docker --version
```
You should get the following output:
```
Docker version 19.03.13, build 4484c46d9d
```
At this point, Docker CE is installed on both the registry server and the client machine.
## Step 3 – Install and Configure Registry Server
Next, you will need to install and configure the registry server on the server machine.
First, download the registry image from the Docker hub with the following command:
```
docker pull registry
```
You should get the following output:
Using default tag: latest
```
latest: Pulling from library/registry
cbdbe7a5bc2a: Pull complete
47112e65547d: Pull complete
46bcb632e506: Pull complete
c1cc712bcecd: Pull complete
3db6272dcbfa: Pull complete
Digest: sha256:8be26f81ffea54106bae012c6f349df70f4d5e7e2ec01b143c46e2c03b9e551d
Status: Downloaded newer image for registry:latest
docker.io/library/registry:latest
```
By default, Docker uses a secure connection over TLS to upload and download the images, so you will need to create a self-signed certificate for the registry server.
First, create a directory to store the certificates:
```
mkdir /etc/certs
```
Next, change the directory to the /etc/certs and generate a self-signed certificate with the following command:
```
cd /etc/certs
openssl req -newkey rsa:4096 -nodes -sha256 -keyout ca.key -x509 -days 365 -out ca.crt
```
Provide all details as shown below to generate the certificate:
```
Generating a RSA private key
....................................++++
......++++
writing new private key to 'ca.key'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields, there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:IN
State or Province Name (full name) [Some-State]:GUJ
Locality Name (eg, city) []:JUNAGADH
Organization Name (eg, company) [Internet Widgits Pty Ltd]:IT
Organizational Unit Name (eg, section) []:IT
Common Name (e.g. server FQDN or YOUR name) []:registry-server
Email Address []:admin@example.com
```
Once the certificate is generated, start the registry container from the downloaded image using the self-signed certificate with the following command:
```
docker run -d -p 5000:5000 --restart=always --name registry -v /etc/certs:/etc/certs -e
REGISTRY_HTTP_TLS_CERTIFICATE=/etc/certs/ca.crt -e
REGISTRY_HTTP_TLS_KEY=/etc/certs/ca.key registry
```
Next, verify the running container by running the following command:
```
docker ps
```
You should get the following output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS
PORTS NAMES
90f4155f3926 registry "/entrypoint.sh /etc…" 4 seconds ago Up 2 seconds
0.0.0.0:5000->5000/tcp registry
```
At this point, your registry server is installed and running.
## Step 4 – Create a Custom Image on Registry Client
For this tutorial, we will download Ubuntu 20.04 server image on the client machine, create a new container, install the Apache server inside the container, build the new image and upload this image to the registry server.
First, download the Ubuntu 20.04 server image and create a container with the following command:
```
docker container run -it ubuntu:20.04 /bin/bash
```
This will download the Ubuntu 20.04 image from the Docker hub, create a new container, and attach it to the bash shell:
```
Unable to find image 'ubuntu:20.04' locally
20.04: Pulling from library/ubuntu
6a5697faee43: Already exists
ba13d3bc422b: Already exists
a254829d9e55: Already exists
Digest: sha256:fff16eea1a8ae92867721d90c59a75652ea66d29c05294e6e2f898704bdb8cf1
Status: Downloaded newer image for ubuntu:20.04
root@ee2cc97397fb:/#
```
Next, run the following command to update the system and install the apache webserver:
```
root@ee2cc97397fb:/#apt-get update -y
root@ee2cc97397fb:/#apt-get install apache2 -y
```
Next, exit from the running container with the following command:
```
root@ee2cc97397fb:/#exit
```
Next, you will need to rename or tag the Ubuntu 20.04 image in “**registryserver:portnumber/image name:tag**” format.
You can tag it with the following command:
```
docker tag ubuntu:20.04 registry-server:5000/ubuntu:apachev1.0
```
Next, verify your new image with the following command:
```
docker images
```
You should get the following output:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu 20.04 d70eaf7277ea 13 days ago 72.9MB
registry-server:5000/ubuntu apachev1.0 d70eaf7277ea 13 days ago 72.9MB
```
## Step 5 – Upload New Image to Registry Server
First, you will need to create a new certificate directory on the client machine and copy the ca.crt file from the registry server:
First, create a cert directory with the following command:
```
mkdir -p /etc/docker/certs.d/registry-server:5000
```
Next, copy the ca.crt file from the registry server to the client machine:
```
scp root@registry-server:/etc/certs/ca.crt /etc/docker/certs.d/registry-server:5000/
```
Next, restart the Docker service to use this certificate:
```
systemctl restart docker
```
Next, upload your newly created image to the registry server with the following command:
```
docker push registry-server:5000/ubuntu:apachev1.0
```
You should get the following output:
The push refers to repository [registry-server:5000/ubuntu]
```
cc9d18e90faa: Pushed
0c2689e3f920: Pushed
47dde53750b4: Pushed
apachev1.0: digest: sha256:1d7b639619bdca2d008eca2d5293e3c43ff84cbee597ff76de3b7a7de3e84956 size: 943
```
## Conclusion
Congratulations! You have successfully set up the Docker registry server and client on Ubuntu 20.04. You can now download and upload your own customized images to and from the registry server. Give it a shot on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to install Brotli Module for Nginx on Ubuntu
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-brotli-module-for-nginx-on-ubuntu/ | Published: 2020-11-30 | Updated: 2025-05-23 | Author: Hitesh Jethva
Nginx is a free, open-source, high-performance web server and proxy server used around the world. Brotli is a compression algorithm developed by Google. It can be used as an alternative to other compression methods such as Gzip, Zopfli, and Deflate. By default, Nginx does not support Brotli compression, so you will need to compile Nginx with Brotli support. Brotli works well for the compression of static resources like HTML, JS, CSS, and JSON.
In this tutorial, we will show you how to install the Brotli module with Nginx on Ubuntu 24.04.
## Step 1 – Install Required Dependencies
Before starting, you will need to install some dependencies required to compile Nginx in your system. You can install all of them with the following command:
```
apt-get install dpkg-dev build-essential gnupg2 git gcc cmake libpcre3 libpcre3-dev zlib1g zlib1g-
dev openssl libssl-dev curl unzip libbrotli-dev -y
```
Once all the packages are installed, you can proceed to the next step.
## Step 2 – Add Nginx Repository
Next, you will need to add the Nginx official repository to download the latest version of the Nginx source.
First, import the Nginx GPG key with the following command:
```
curl -L https://nginx.org/keys/nginx_signing.key | apt-key add -
```
Next, add the Nginx repository with the following command:
```
nano /etc/apt/sources.list.d/nginx.list
```
Add the following lines:
```
deb http://nginx.org/packages/ubuntu/ noble nginx
deb-src http://nginx.org/packages/ubuntu/ noble nginx
```
Save and close the file when you are finished. Next, update the repository with the following command:
```
apt-get update -y
```
Once your repository is updated, you can proceed to the next step.
## Step 3 – Install Nginx with Brotli Support
First, download the latest version of the Nginx source with the following command:
```
cd /usr/local/src
apt-get source nginx
```
Next, install the required dependencies to build Nginx:
```
apt-get build-dep nginx -y
```
Next, download the latest version of Brotli from the Git repository using the following command:
```
git clone --recursive https://github.com/google/ngx_brotli.git
```
Next, change the directory to the Nginx source and edit the rules file:
```
cd /usr/local/src/nginx-*/
nano debian/rules
```
Find the **‘config.env.nginx**‘ and **‘config.env.nginx_debug’** section and add the following line within **./configure** line:
```
--add-module=/usr/local/src/ngx_brotli
```
Save and close the file, then compile and build the nginx package with the following command:
```
dpkg-buildpackage -b -uc -us
```
The above command will generate Nginx .deb files inside /usr/local/src directory.
You can list them with the following command:
```
ls /usr/local/src/*.deb
```
You should see both files in the following output:
```
/usr/local/src/nginx_1.28.0-1~noble_amd64.deb /usr/local/src/nginx-dbg_1.28.0-1~noble_amd64.deb
```
Next, install the Nginx by running the both *.deb file:
```
dpkg -i /usr/local/src/*.deb
```
## Step 4 – Configure Nginx to Use Brotli
Next, you will need to configure Nginx to use Brotli module. You can do it by editing the Nginx main configuration file:
```
nano /etc/nginx/nginx.conf
```
Add the following lines inside the http { section:
```
brotli on;
brotli_comp_level 6;
brotli_static on;
brotli_types text/plain text/css application/javascript application/x-javascript text/xml
application/xml application/xml+rss text/javascript image/x-icon
image/vnd.microsoft.icon image/bmp image/svg+xml;
```
Save and close the file, then verify the Nginx for any syntax errors:
```
nginx -t
```
You should get the following output:
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Next, start the Nginx service using the following command:
```
systemctl start nginx
```
You can verify the status of the Nginx service with the following command:
```
systemctl status nginx
```
You should get the following output:
```
● nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Fri 2025-05-23 11:06:17 UTC; 3s ago
Docs: https://nginx.org/en/docs/
Process: 56231 ExecStart=/usr/sbin/nginx -c ${CONFFILE} (code=exited, status=0/SUCCESS)
Main PID: 56232 (nginx)
Tasks: 5 (limit: 9440)
Memory: 4.6M (peak: 4.8M)
CPU: 16ms
CGroup: /system.slice/nginx.service
├─56232 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
├─56233 "nginx: worker process"
├─56234 "nginx: worker process"
├─56235 "nginx: worker process"
└─56236 "nginx: worker process"
```
## Step 5 – Verify Brotli Module
At this point, Nginx is installed and configured with Brotli support. Now, verify whether the Brotli module is enabled or not by running the following command:
```
curl -H 'Accept-Encoding: br' -I http://localhost
```
You should get the “Content-Encoding: br” in the following output:
```
HTTP/1.1 200 OK
Server: nginx/1.28.0
Date: Fri, 23 May 2025 11:06:40 GMT
Content-Type: text/html
Last-Modified: Wed, 23 Apr 2025 11:48:54 GMT
Connection: keep-alive
ETag: W/"6808d3a6-267"
Content-Encoding: br
```
## Conclusion
In the above guide, you learned how to compile Nginx with Brotli support on Ubuntu 24.04. Compared to other compression methods, Brotli compression ratios are up to 26% smaller than current methods, with less CPU usage. Start using Brotli today on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to Install OpenProject on Ubuntu 20.04
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-openproject-on-ubuntu-20-04/ | Published: 2020-12-01 | Updated: 2023-11-17 | Author: Hitesh Jethva
OpenProject is free, open-source project management software that helps you manage your entire project life cycle. It is written in Ruby on Rails and AngularJS. OpenProject provides a simple and easy-to-use web interface that allows you to collaborate on projects using features such as a WYSIWYG text editor, intelligent workflows, conditional formatting, team collaboration, Kanban, Agile & Scrum, project planning and scheduling, time tracking, product roadmaps, and release planning.
In this tutorial, we will show you how to install OpenProject on Ubuntu 20.04.
## Step 1 – Install OpenProject
By default, the OpenProject package is not available in the Ubuntu 20.04 default repository, so you will need to add the OpenProject repository to your system.
First, install some required dependencies with the following command:
```
apt-get update -y
apt-get install apt-transport-https gnupg2 -y
```
Next, import the GPG key and add the OpenProject repository with the following command:
```
wget -qO- https://dl.packager.io/srv/opf/openproject/key | apt-key add -
wget -O /etc/apt/sources.list.d/openproject.list
https://dl.packager.io/srv/opf/openproject/stable/10/installer/debian/10.repo
```
Once the repository is added, update the repository and install the OpenProject package with the following command:
```
apt-get update -y
apt-get install openproject -y
```
Once OpenProject is installed, you should get the following output:
```
==============
The openproject package provides an installer. Please run the following command to finish the
installation:
sudo openproject configure
==============
Processing triggers for libc-bin (2.31-0ubuntu9) ...
Processing triggers for man-db (2.9.1-1) ...
Processing triggers for mime-support (3.64ubuntu1) ...
```
## Step 2 – Configure OpenProject
After installing OpenProject, you will need to configure it. You can configure it with the following command:
```
openproject configure
```
You will be asked to install or use the database as shown below:
Select the second option and hit **Enter**. You will be asked to install the Webserver:
Select Apache webserver and hit **Enter**. You will be asked to set a fully qualified domain name:
Provide your fully qualified domain name and hit **Enter**. You will be asked to set the installation path:
Leave it blank and hit **Enter**. You will be asked to enable SSL:
Select no and hit **Enter**. You will be asked to install SVN:
Select your desired option and hit **Enter**. You will be asked to specify the SVN repo path:
Provide your SVN repo path or leave it default and hit **Enter**. You will be asked to set up Git:
Select skip and hit **Enter**. You will be asked to set up sendmail:
Select skip and hit **Enter**. You will be asked to install a memcached server:
Select skip and hit **Enter** to finish the configuration.
## Step 3 – Manage OpenProject Service
At this point, OpenProject is installed and running. You can verify the status of OpenProject with the following command:
```
systemctl status openproject
```
You should get the following output:
- ```
openproject.service
Loaded: loaded (/etc/systemd/system/openproject.service; enabled; vendor preset: enabled)
Active: active (running) since Fri 2020-10-30 05:22:46 UTC; 1min 33s ago
Main PID: 18299 (sleep)
Tasks: 1 (limit: 4691)
Memory: 148.0K
CGroup: /system.slice/openproject.service
└─18299 /bin/sleep infinity
```
```
Oct 30 05:22:46 ubuntu2004 systemd[1]: Started openproject.service.
```
You can also start and stop OpenProject with the following command:
```
systemctl start openproject
systemctl stop openproject
```
## Step 4 – Access OpenProject Web UI
Now, open your web browser and access the OpenProject admin interface using the URL **http://openproject.example.com/admin**. You will be redirected to the OpenProject login page:
Provide the default admin username and password as admin / admin, then click on the **Sign** **in** button. You should see the default admin password reset screen:
Set your new password and click on the **Save** button. You should see the OpenProject dashboard in the following screen:
## Conclusion
Congratulations! You have successfully installed and configured OpenProject on Ubuntu 20.04 server. You can now explore OpenProject and start creating your first project. Try OpenProject today on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# Dockerizing Python Django Application on Ubuntu 20.04
> URL: https://www.atlantic.net/dedicated-server-hosting/dockerizing-python-django-application-on-ubuntu-20-04/ | Published: 2020-12-02 | Updated: 2023-11-13 | Author: Hitesh Jethva
Docker is a free and open-source platform that allows you to build, package, and run applications in a lightweight container. It helps you to separate your applications from your infrastructure so you can deliver software quickly.
Django is an open-source web application framework that follows the Model-View-Controller architecture. Written in Python, it is used for rapidly developed, pragmatically designed, and secure websites.
In this tutorial, we will explain how to deploy Python Django web application in the Docker environment.
## Step 1 – Install Docker and Docker Compose
First, you will need to install Docker and Docker Compose in your system. By default, the latest version of Docker is not available in the Ubuntu 20.04 default repository, so you will need to add the repository for that.
First, install all dependencies with the following command:
```
apt-get install apt-transport-https curl gnupg2 software-properties-common tree -y
```
Once all the dependencies are installed, import the GPG key with the following command:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
```
Next, add the Docker official repository with the following command:
```
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -
cs) stable"
```
Once the repository has been added, install the Docker and Docker Compose with the following command:
```
apt-get install docker-ce docker-compose -y
```
Once both packages are installed, verify the installed version of Docker with the following command:
```
docker -v
```
Output:
```
Docker version 19.03.13, build 4484c46d9d
```
You can also check the Docker Compose version using the following command:
```
docker-compose -v
```
Output:
```
docker-compose version 1.25.0, build unknown
```
## Step 2 – Create a Dockerfile
Next, you will need to create a Dockerfile to build a container image for your Django application.
First, create a project directory named myapp with the following command:
```
mkdir ~/myapp
```
Next, change the directory to myapp and create a new Dockerfile with the following command:
```
cd ~/myapp
nano Dockerfile
```
Add the following lines:
```
FROM python:3
ENV PYTHONUNBUFFERED=1
RUN mkdir /code
WORKDIR /code
COPY requirements.txt /code/
RUN pip install -r requirements.txt
COPY . /code/
```
Save and close the file when you are finished.
The above file will pull the official Python image from Dockerhub, create a code directory inside the container, and install the requirements listed in the requirements.txt file.
Next, create a requirements.txt file and add the required modules:
```
nano requirements.txt
```
Add the following lines:
```
Django==3.0.7
psycopg2-binary==2.8.5
```
Save and close the file when you are finished.
## Step 3 – Create a Docker-compose.yml File
Docker compose is a tool used for defining and running multi-container Docker applications. You can create a docker-compose.yml file with the following command:
```
nano ~/myapp/docker-compose.yml
```
Add the following lines:
```
version: "3.7"
services:
db:
image: postgres
environment:
- POSTGRES_DB=postgres
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
web:
build: .
command: python manage.py runserver 0.0.0.0:8000
volumes:
- .:/code
ports:
- "8000:8000"
depends_on:
- db
```
Save and close the file when you are finished.
The above file will create the database service named db using the PostgreSQL image and create our python Django container using the custom docker images generated from our Dockerfile.
## Step 4 – Create a Django Project
Next, you will need to download the sample Django project named composeexample inside your project directory.
First, change the directory to ~/myapp and run the following command:
```
cd ~/myapp
docker-compose run web django-admin startproject composeexample
```
This will download the composeexample project in the current directory.
Next, copy the required directory and files from the downloaded directory with the following command:
```
mv composeexample /opt/
mv /opt/composeexample/* .
```
Your project directory structure will look like the following:
```
tree
```
Output:
```
.
├── composeexample
│ ├── asgi.py
│ ├── __init__.py
│ ├── __pycache__
│ │ ├── __init__.cpython-39.pyc
│ │ ├── settings.cpython-39.pyc
│ │ ├── urls.cpython-39.pyc
│ │ └── wsgi.cpython-39.pyc
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── docker-compose.yml
├── Dockerfile
├── manage.py
└── requirements.txt
```
Next, you will need to edit the settings.py file and define your database settings and allowed hosts:
```
nano composeexample/settings.py
```
Change the following lines:
```
ALLOWED_HOSTS = ['your-server-ip']
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'postgres',
'USER': 'postgres',
'PASSWORD': 'postgres',
'HOST': 'db',
'PORT': 5432,
}
}
```
Save and close the file when you are finished.
## Step 5 – Build and Run the Docker Image
Next, change the directory to your project and build the image with the following command:
```
docker-compose build
```
This will download the required images to your system:
```
---> ad21d53c5de1
Step 7/7 : COPY . /code/
---> 0d912d4c215b
Successfully built 0d912d4c215b
Successfully tagged myapp_web:latest
```
Next, start the all containers by running the following command:
```
docker-compose up -d
```
You should get the following output:
```
Pulling db (postgres:)...
latest: Pulling from library/postgres
bb79b6b2107f: Pull complete
e3dc51fa2b56: Pull complete
f213b6f96d81: Pull complete
2780ac832fde: Pull complete
ae5cee1a3f12: Pull complete
95db3c06319e: Pull complete
475ca72764d5: Pull complete
8d602872ecae: Pull complete
c4fca31f2e3d: Pull complete
a00c442835e0: Pull complete
2e2305af3390: Pull complete
6cff852bb872: Pull complete
25bb0be11543: Pull complete
4738c099c4ad: Pull complete
Digest: sha256:8f7c3c9b61d82a4a021da5d9618faf056633e089302a726d619fa467c73609e4
Status: Downloaded newer image for postgres:latest
Creating myapp_db_1 ... done
Creating myapp_web_1 ... done
```
Now, you can verify the running containers with the following command:
```
docker-compose ps
```
You should get the following output:
```
Name Command State Ports
-----------------------------------------------------------------------------
myapp_db_1 docker-entrypoint.sh postgres Up 5432/tcp
myapp_web_1 python manage.py runserver ... Up 0.0.0.0:8000->8000/tcp
```
You can also list all downloaded images with the following command:
```
docker-compose images
```
You should get the following output:
```
Container Repository Tag Image Id Size
-----------------------------------------------------------
myapp_db_1 postgres latest c96f8b6bc0d9 314.1 MB
myapp_web_1 myapp_web latest 0d912d4c215b 928.6 MB
```
If you have any problem running the container, you can verify the container log with the following command:
```
docker-compose logs
```
## Step 6 – Access Django Web UI
At this point, the Django container is started and running on port 8000. You can access it using the URL **http://your-server-ip:8000**. You should see your Django application dashboard on the following screen:
## Conclusion
Congratulations! You have successfully deployed the Django application with Docker on Ubuntu 20.04. You should now be able to deploy your Python application easily with Docker. Try it today on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# Manage Docker Containers with Rancher
> URL: https://www.atlantic.net/dedicated-server-hosting/manage-docker-containers-with-rancher/ | Published: 2020-12-03 | Updated: 2023-11-18 | Author: Hitesh Jethva
Rancher is a free and open-source platform that can be used to manage the Docker containers through a web-based interface. You can deploy and manage containers, manage clusters, manage centralized policy and workloads, and much more with Rancher. It includes different technologies from the Docker environment like orchestration and scheduling frameworks Swarm and Kubernetes in one application.
Rancher can be deployed as a set of Docker containers with one container as the management server and another container on a node as an agent. In this tutorial, we will show you how to install Rancher on Ubuntu 20.04 VPS.
## Step 1: Install Docker
First, you will need to install Docker dependencies on **both nodes**. You can install them using the following command:
```
apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common -y
```
Once all the dependencies are installed, download and add the GPT key with the following command:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
```
Next, add the Docker repository using the following command:
```
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs)
stable"
```
Now, run the following command to install the latest version of Docker:
```
apt-get install docker-ce docker-ce-cli containerd.io -y
```
Once the installation has been completed, start the Docker service and enable it to start at system reboot with the following command:
```
systemctl start docker
systemctl enable docker
```
You can now verify the status of Docker with the following command:
```
systemctl status docker
```
You should get the following output:
**Note**: Run all commands on both nodes.
## Step 2: Install the Rancher Container
Next, you will need to install the Rancher container on the master node. You can deploy the Rancher container by running the following command:
```
docker run -d --restart=unless-stopped -p 8080:8080 rancher/server:stable
```
This will download the Rancher image and start the container on port 8080 as shown below:
At this point, The Rancher is installed and listening on port 8080.
## Step 3: Configure Rancher
Now, access the Rancher container using the URL http://rancher-server-ip:8080/. You will be redirected to the Rancher dashboard, as shown below:
Next, you will need to configure Rancher’s Access Control to manage users. Rancher supports many access controls including Active Directory, Azure AD, Github, OpenLDAP, SAML, and Local Authentication.
To configure the local authentication for Rancher, click on the **ADMIN => Access Control**. You should see the following screen:
Select Local Access Control, provide username and password, and click on the **Enable** **Local** **Auth** button. Once the LOCAL authentication is enabled, you should see the following screen:
## Step 4: Add Rancher Agent to Rancher Server
In this section, we will add a Rancher agent to the Rancher server.
On the Rancher server Dashboard, click on **INFRASTRUCTURE** => **HOSTS**. You should see the following screen:
Click on **Add** **Host**. You should see the following screen:
Now, click on the **Save** button. You should see the following screen:
Select Custom host type, provide your Rancher agent IP, and copy the Docker command from the box.
Now, login to the Rancher agent node (node 2) and paste the command which you have copied earlier:
```
docker run -e CATTLE_AGENT_IP="rancher-agent-ip" --rm --privileged -v
/var/run/docker.sock:/var/run/docker.sock -v /var/lib/rancher:/var/lib/rancher rancher/agent:v1.2.11
http://rancher-server-
ip:8080/v1/scripts/8744892631BE33B2E14D:1577750400000:ItvCtcS7fG3WeRIChGqxfhhM
```
This will deploy the new container on the Rancher client node. Once the container has been deployed, you should see the following output:
On the Rancher server dashboard, click on the Close button. You should see the newly added Rancher agent in the following page:
## Step 5: Deploy WordPress Container with Rancher
Now, you can easily deploy any container through the Rancher server dashboard. In this section, we will deploy a WordPress container.
On the Rancher Dashboard, click on the **INFRASTRUCTURE** => **Containers**. You should see the following screen:
Now, click on the **Add** **Container** button. You should see the following screen:
Provide your container name, port number, and image and click on the **Create** button. Once the container has been created successfully, you should see your WordPress container in the following screen:
You can view your Docker WordPress image by entering your Rancher Client IP and the port you configured, e.g. 185.50.60.70:80
## Conclusion
In the above guide, you learned how to install Rancher server and Rancher agent on Ubuntu 20.04 VPS. You have also deployed new WordPress container with Rancher. You can now easily manage and deploy containers using the Rancher web interface. Get started with Rancher on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to Install Kubernetes with Minikube on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-kubernetes-with-minikube-on-centos-8/ | Published: 2020-12-04 | Updated: 2023-11-25 | Author: Hitesh Jethva
Minikube is an open-source software written in Go and used for setting up a Kubernetes cluster on your local machine. Developers or administrators mainly use Minikube for testing purposes. This cross-platform software can be run on macOS, Linux, and Windows.
In this tutorial, we will learn how to install Kubernetes with Minikube on CentOS 8.
## Step 1: Install Docker
By default, the Docker package is not available in the CentOS 8 default repo, so you will need to add the Docker repo in your system.
You can add it with the following command:
```
dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
```
After adding the Docker repo, install Docker by running the following command:
```
dnf install docker-ce --nobest -y
```
Once the installation is completed, start the Docker service and enable it to start at system reboot:
```
systemctl start docker
systemctl enable docker
```
You can also verify the installed version of Docker using the following command:
```
docker -v
```
You should see the following output:
```
Docker version 19.03.12, build 48a66213fe
```
## Step 2: Install Kubectl
Before starting, you will need to install the required dependencies in your system. You can install them with the following command:
```
dnf install curl conntrack -y
```
Next, you will need to install Kubectl in your system. By default, kubectl is not included in CentOS 8, so you will need to install it using the curl command:
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s
https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
```
Next, give the execution permission to the downloaded binary and move it to the /usr/local/bin directory:
```
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl
```
You can now verify the Kubectl version with the following command:
```
kubectl version --client
```
You should see the following output:
```
Client Version: version.Info{Major:"1", Minor:"18", GitVersion:"v1.18.5",
GitCommit:"e6503f8d8f769ace2f338794c914a96fc335df0f", GitTreeState:"clean",
BuildDate:"2020-06-26T03:47:41Z", GoVersion:"go1.13.9", Compiler:"gc",
Platform:"linux/amd64"}
```
## Step 3: Install Minikube
First, download the Minikube binary package using the curl command:
```
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
```
Next, give the execution permission to the downloaded binary with the following command:
```
chmod +x minikube
```
Next, install Minikube by running the following command:
```
install minikube /usr/local/bin/
```
You can now start Minikube using the following command:
```
minikube start --driver=none
```
Once Minikube is started successfully, you should get the following output:
The above command will download and start the Docker containers for setting up a single node Kubernetes cluster.
You can also verify the status of the Kubernetes cluster with the following command:
```
minikube status
```
You should see the following output:
```
minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured
```
You can also view the cluster information using the following command:
```
kubectl cluster-info
```
You should see the following output:
```
Kubernetes master is running at https://your-server-ip:8443
KubeDNS is running at https://your-server-ip:8443/api/v1/namespaces/kube-system/services/kube-
dns:dns/proxy
To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
```
You can also view the cluster nodes using the following command:
```
kubectl get nodes
```
You should get the following output:
```
NAME STATUS ROLES AGE VERSION
minicube Ready master 2m v1.18.3
```
## Step 4: Verify Kubernetes Cluster
Now, deploy a k8s using echoserver image to test the Kubernetes cluster.
```
kubectl create deployment test-minikube --image=k8s.gcr.io/echoserver:1.10
```
You should see the following output:
```
deployment.apps/test-minikube created
```
Now, expose your deployment on port 8080 using the following command:
```
kubectl expose deployment test-minikube --type=NodePort --port=8080
```
You should see the following output:
```
service/test-minikube exposed
```
Next, get the information about your exposed deployment using the following command:
```
kubectl get pod
```
You should see the following output:
```
NAME READY STATUS RESTARTS AGE
test-minikube-f4df69575-7m2pl 1/1 Running 0 33s
```
Next, get the URL of your deployment using the following command:
```
minikube service test-minikube --url
```
You should see the following output:
```
http://your-server-ip:31186
```
Now, open your web browser and access the above URL http://your-server-ip:31186. You should see the following screen:
## Step 5: Enable Kubernetes Dashboard
Kubernetes comes with a web dashboard that can be used to manage your cluster through a web browser. By default, the dashboard is disabled in Minikube.
You can list all Minikube addons using the following command:
```
minikube addons list
```
You should see the following output:
```
|-----------------------------|----------|--------------|
| ADDON NAME | PROFILE | STATUS |
|-----------------------------|----------|--------------|
| ambassador | minikube | disabled |
| dashboard | minikube | disabled |
| default-storageclass | minikube | enabled ✅ |
| efk | minikube | disabled |
| freshpod | minikube | disabled |
| gvisor | minikube | disabled |
| helm-tiller | minikube | disabled |
| ingress | minikube | disabled |
| ingress-dns | minikube | disabled |
| istio | minikube | disabled |
| istio-provisioner | minikube | disabled |
| logviewer | minikube | disabled |
| metallb | minikube | disabled |
| metrics-server | minikube | disabled |
| nvidia-driver-installer | minikube | disabled |
| nvidia-gpu-device-plugin | minikube | disabled |
| olm | minikube | disabled |
| registry | minikube | disabled |
| registry-aliases | minikube | disabled |
| registry-creds | minikube | disabled |
| storage-provisioner | minikube | enabled ✅ |
| storage-provisioner-gluster | minikube | disabled |
|-----------------------------|----------|--------------|
```
Now, enable the Minikube dashboard and get the URL of the dashboard with the following command:
```
minikube dashboard --url
```
This will enable the Minikube dashboard as shown below:
```
* Enabling dashboard ...
* Verifying dashboard health ...
* Launching proxy ...
* Verifying proxy health ...
http://127.0.0.1:42939/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-
dashboard:/proxy/
```
Now, you can access the Minikube dashboard locally using the above URL.
## Conclusion
Congratulations! You have successfully installed Kubernetes cluster with Minikube on CentOS 8. You can now start experimenting with Kubernetes locally. Get started with Kubernetes and Minikube on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Install Matrix Synapse on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-matrix-synapse-on-ubuntu-20-04/ | Published: 2020-12-05 | Updated: 2023-11-25 | Author: Hitesh Jethva
Matrix is an open-source Python project for decentralized real-time communication used for messaging and VoIP services. It allows one user to communicate with other users on a different service provider via voice-over-IP and chat. Matrix is an open standard and lightweight protocol and allows you to create your own home server, store all user personal info, and create a personal room.
In this tutorial, we will show you how to install Matrix Synapse with Nginx as a reverse proxy on Ubuntu 20.04.
## Prerequisites
- A fresh Ubuntu 20.04 [VPS](https://www.atlantic.net/vps-hosting/)
- A valid domain name pointed to your server IP
- A root password configured on your server
## Step 1 – Install Matrix Synapse
By default, Matrix synapse package is not available in the Ubuntu 20.04 default repository, so you will need to add the Matrix repository to your system.
First, install the required dependencies with the following command:
```
apt-get install curl wget gnupg2 apt-transport-https -y
```
Once all the dependencies are installed, download and add the GPG key with the following command:
```
wget -qO /usr/share/keyrings/matrix-org-archive-keyring.gpg
https://packages.matrix.org/debian/matrix-org-archive-keyring.gpg
```
Next, add the Matrix repository to the APT with the following command:
```
echo "deb [signed-by=/usr/share/keyrings/matrix-org-archive-keyring.gpg]
https://packages.matrix.org/debian/ $(lsb_release -cs) main" | tee /etc/apt/sources.list.d/matrix-
org.list
```
Next, update the repository and install the latest version of Matrix with the following command:
```
apt-get update -y
apt-get install matrix-synapse-py3 -y
```
During the installation, you will be asked to provide your domain name as shown below:
Provide your domain and click on the **Ok** button. You should see the following page:
Select your desired option and hit Enter to start the installation. Once Matrix has been installed, start the Matrix service and enable it to start at system reboot with the following command:
```
systemctl start matrix-synapse
systemctl enable matrix-synapse
```
By default, Matrix synapse listens on port 8008. You can check it with the following command:
```
ss -tunelp | grep 8008
```
You should get the following output:
```
tcp LISTEN 0 50 127.0.0.1:8008 0.0.0.0:*
users:(("python",pid=102359,fd=13)) uid:109 ino:594551 sk:a <->
tcp LISTEN 0 50 [::1]:8008 [::]:*
users:(("python",pid=102359,fd=12)) uid:109 ino:594550 sk:d v6only:1 <->
```
## Step 2 – Configure Matrix Synapse
The Matrix Synapse default configuration file is located at /etc/matrix-synapse/homeserver.yaml. Before editing it, create a secret password with the following command:
```
cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1
```
You should get the following output:
```
2VHeHAwjGlMlqpEGBNMhfEbb5BOmp6qE
```
Next, edit the Matrix configuration file:
```
nano /etc/matrix-synapse/homeserver.yaml
```
Change the following lines:
```
listeners:
- port: 8008
tls: false
type: http
x_forwarded: true
bind_addresses: ['127.0.0.1']
resources:
- names: [client, federation]
compress: false
enable_registration: false
registration_shared_secret: "2VHeHAwjGlMlqpEGBNMhfEbb5BOmp6qE"
```
Save and close the file, then restart the Matrix synapse service to apply the changes.
```
systemctl restart matrix-synapse
```
At this point, Matrix Synapse is configured to listen on localhost.
## Step 3 – Create a New Matrix User
Next, you will need to create a new user for Matrix Synapse. You can use this user on the Matrix client to connect to the Matrix server.
Run the following command to create a new user:
```
register_new_matrix_user -c /etc/matrix-synapse/homeserver.yaml http://localhost:8008
```
You will be asked to set a username and password as shown below:
```
New user localpart [root]: admin
Password:
Confirm password:
Make admin [no]: yes
Sending registration request...
Success!
```
Once the user is created, you can proceed to the next step.
## Step 4 – Configure Nginx for Matrix Synapse
Next, you will need to install and configure Nginx as a reverse proxy for Matrix Synapse so you can access the Matrix Synapse from the external network using port 80.
First, install the Nginx server with the following command:
```
apt-get install nginx -y
```
Once installed, create an Nginx virtual host configuration file with the following command:
```
nano /etc/nginx/sites-available/matrix.conf
```
Add the following lines:
```
server {
listen 80;
server_name matrix.example.com;
location / {
proxy_pass http://localhost:8008;
proxy_set_header X-Forwarded-For $remote_addr;
}
}
```
Save and close the file, then enable the Nginx virtual host with the following command:
```
ln -s /etc/nginx/sites-available/matrix.conf /etc/nginx/sites-enabled/
```
Next, verify Nginx for any syntax errors with the following command:
```
nginx -t
```
You should get the following output:
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Next, restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
If you get any errors, then you will need to edit the Nginx default server configuration file and set server_names_hash_bucket_size:
```
nano /etc/nginx/nginx.conf
```
Add the following line below http {:
```
server_names_hash_bucket_size 64;
```
Save and close the file, then restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 5 – Access Matrix Synapse
Now, open your web browser and access the Matrix Synapse web interface using the URL **http://matrix.example.com**/. You should see the following page:
As you can see, Matrix Synapse is now running.
## Conclusion
Congratulations! You have successfully installed Matrix Synapse with Nginx as a reverse proxy on Ubuntu 20.04. You can now install the Matrix client on your mobile device or desktop computer and communicate with other users. Get started with Matrix on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Install WordPress with EasyEngine on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-wordpress-with-easyengine-on-ubuntu-20-04/ | Published: 2020-12-06 | Updated: 2024-06-30 | Author: Hitesh Jethva
EasyEngine is a collection of Linux shell scripts that makes it easier to install and manage Nginx, MariaDB, PHP and WordPress using the command line. It can be installed on any Debian-based distributions and allows you to deploy single and multisite WordPress installations, including WP Super Cache, W3 Total Cache, Redis Cache, and ngx_fastcgi_cache.
If you are a WordPress developer, then you may need to install it on several systems for testing purposes. There are several ways to install WordPress. Installing WordPress manually is a bit time-consuming process. EasyEngine is the easiest way to install WordPress automatically within a minute.
In this tutorial, we will show you how to install WordPress with EasyEngine on Ubuntu 20.04.
## Step 1 – Install EasyEngine
EasyEngine provides an installer script to install EasyEngine in your system automatically. You can download and run the EasyEngine installer script by running the following command:
```
apt-get update -y
wget -qO ee https://rt.cx/ee4 && bash ee
```
This script will install Docker and all images required to host WordPress website as shown below:
```
Status: Downloaded newer image for easyengine/redis:v4.1.4
docker.io/easyengine/redis:v4.1.4
+-------------------+---------------------------------------------------------------------------+
| OS | Linux 5.4.0-29-generic #33-Ubuntu SMP Wed Apr 29 14:32:27 UTC 2020 x86_64 |
| Shell | /bin/bash |
| PHP binary | /usr/bin/php7.3 |
| PHP version | 7.3.23-1+ubuntu20.04.1+deb.sury.org+1 |
| php.ini used | /etc/php/7.3/cli/php.ini |
| EE root dir | phar://ee.phar |
| EE vendor dir | phar://ee.phar/vendor |
| EE phar path | /root |
| EE packages dir | |
| EE global config | |
| EE project config | |
| EE version | 4.1.5 |
+-------------------+---------------------------------------------------------------------------+
-----> Run "ee help site" for more information on how to create a site.
```
Next, verify the installed version of EasyEngine using the following command:
```
ee --version
```
You should get the following output:
```
EE 4.1.5
```
Next, you can list all downloaded docker images with the following command:
```
docker images
```
You should get the following output:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
easyengine/php v4.1.6 d700893ee9a0 2 weeks ago 759MB
easyengine/postfix v4.1.5 f5ac5c1276af 6 weeks ago 475MB
easyengine/nginx v4.1.4 502705ab18a2 8 weeks ago 85.2MB
easyengine/redis v4.1.4 8df6607d58ef 8 weeks ago 104MB
easyengine/nginx-proxy v4.1.4 e62b5bc02d07 8 weeks ago 163MB
easyengine/mariadb v4.1.3 580f7d75d8d5 3 months ago 407MB
easyengine/cron v4.0.0 e86e4f2e4e9a 22 months ago 8.83MB
easyengine/mailhog v4.0.0 789b9de98747 22 months ago 19.3MB
```
## Step 2 – Install WordPress with EasyEngine
At this point, EasyEngine is installed in your server. Now, you can use “ee site create” command followed by your domain name to install the WordPress in your system.
```
ee site create wordpress.example.com --wp --cache
```
This script will start Nginx, MariaDB, PHP, and Redis container, create a database, and configure WordPress as shown below:
```
Starting site creation.
Configuring project.
Creating WordPress site wordpress.example.com
Copying configuration files.
Starting site's services.
Downloading and configuring WordPress.
Moved /var/www/htdocs/wp-config.php to /var/www/wp-config.php successfully
Success: Host entry successfully added.
Checking and verifying site-up status. This may take some time.
Installing WordPress site.
Success: http://wordpress.example.com has been created successfully!
Site entry created.
Creating cron entry
Success: Cron created successfully
+--------------------+---------------------------------------------+
| Site | http://wordpress.example.com |
+--------------------+---------------------------------------------+
| Site Root | /opt/easyengine/sites/wordpress.example.com |
+--------------------+---------------------------------------------+
| Site Title | wordpress.example.com |
+--------------------+---------------------------------------------+
| WordPress Username | epic-bose |
+--------------------+---------------------------------------------+
| WordPress Password | LbWdvLk1cS7ng4iQkK |
+--------------------+---------------------------------------------+
| Alias Domains | None |
+--------------------+---------------------------------------------+
| DB Host | global-db |
+--------------------+---------------------------------------------+
| DB Name | wordpress_example_com |
+--------------------+---------------------------------------------+
| DB User | wordpress.example.com-YuhM29 |
+--------------------+---------------------------------------------+
| DB Password | qO3oq8HM5E77 |
+--------------------+---------------------------------------------+
| E-Mail | admin@wordpress.example.com |
+--------------------+---------------------------------------------+
| SSL | Not Enabled |
+--------------------+---------------------------------------------+
| Cache | Enabled |
+--------------------+---------------------------------------------+
| Proxy Cache | Off |
+--------------------+---------------------------------------------+
```
In the above output, you can see all the information about your WordPress website including WordPress site URL, admin username, password, database name, username, password and email address.
You can list all running containers using the following command:
```
docker ps
```
You should get the following output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c418ec63de84 easyengine/cron:v4.0.0 "/usr/bin/ofelia dae…" 20 seconds ago Up 16
seconds ee-cron-scheduler
20b5374e5ad9 easyengine/nginx:v4.1.4 "/usr/bin/openresty …" About a minute ago Up
About a minute 80/tcp wordpressexamplecom_nginx_1
5c73654233a4 easyengine/php:v4.1.6 "docker-entrypoint.s…" About a minute ago Up
About a minute 9000/tcp wordpressexamplecom_php_1
c5cb0cb15a03 easyengine/postfix:v4.1.5 "postfix start-fg" About a minute ago Up
About a minute 25/tcp wordpressexamplecom_postfix_1
f7856139ae4c easyengine/mariadb:v4.1.3 "docker-entrypoint.s…" About a minute ago
Up About a minute 3306/tcp services_global-db_1
1f1f7c7f4f22 easyengine/redis:v4.1.4 "docker-entrypoint.s…" About a minute ago Up
About a minute 6379/tcp services_global-redis_1
068ff0967f13 easyengine/nginx-proxy:v4.1.4 "/app/docker-entrypo…" 2 minutes ago
Up About a minute 0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp services_global-nginx-proxy_1
```
If you forgot the WordPress login username and password, then you can run the following command to see all the information for your website:
```
ee site info wordpress.example.com
```
## Step 3 – Access WordPress Website
Now, open your web browser and access your WordPress admin page using the URL wordpress.example.com/wp-admin. You should see the WordPress login page:
Provide your WordPress admin username, password and click on the **Log in** button. You should see your WordPress dashboard in the following screen:
## Step 4 – Working with EasyEngine
In this section, we will show you some useful EasyEngine commands that will help you to manage the WordPress website.
To list all websites created with Easyengine, run the following command:
```
ee site list
```
You should get the following output:
```
+-----------------------+---------+
| site | status |
+-----------------------+---------+
| wordpress.example.com | enabled |
+-----------------------+---------+
```
To restart your website, run the following command:
```
ee site restart wordpress.example.com
```
You should get the following output:
```
nginx: the configuration file /usr/local/openresty/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/openresty/nginx/conf/nginx.conf test is successful
Restarting nginx
Restarting wordpressexamplecom_nginx_1 ... done
Restarting php
Restarting wordpressexamplecom_php_1 ... done
```
To disable or enable the WordPress website, run the following command:
```
ee site disable wordpress.example.com
ee site enable wordpress.example.com
```
If you want to delete your website, run the following command:
```
ee site delete wordpress.example.com
```
You should get the following output:
```
Are you sure you want to delete wordpress.example.com? [y/n] y
[wordpress.example.com] Docker Containers removed.
[wordpress.example.com] site root removed.
Removed database entry.
Success: Site wordpress.example.com deleted.
```
## Conclusion
As you can see, EasyEngine is a very handy tool for system administrators or developers to automate the website deployment process. You can also install phpMyAdmin, Let’s Encrypt and many other administration utilities using EasyEngine. For more information, you can visit the EasyEngine’s official [documentation](https://easyengine.io/docs/) page. Get started with EasyEngine on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Install Tiki Wiki on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-tiki-wiki-on-ubuntu-20-04/ | Published: 2020-12-06 | Updated: 2023-11-18 | Author: Hitesh Jethva
Tiki Wiki is a free and open-source wiki content management system that allows you to host your own Wiki within a minute. It is written in PHP and uses MariaDB/MySQL as a database backend. Tiki Wiki is made from four components including content creation and management tools, communication tools, content organization tools and navigation aids, and configuration and administration tools. It comes with very useful features including wiki pages, blogs, forums, and file and image galleries.
In this tutorial, we will show you how to install Tiki Wiki on Ubuntu 20.04.
## Step 1 – Install LAMP Server
First, install the Apache web server and MariaDB server with the following command:
```
apt-get install apache2 mariadb-server unzip git gnupg -y
```
After installing the above packages, you will need to install PHP and the required extensions to your system. Tiki Wiki supports only PHP version 7.0 to 7.2. By default, Ubuntu 20.04 ships with PHP 7.4 version, so you will need to add the Ondrej PHP repository in your server.
You can add it with the following command:
```
apt-get install software-properties-common gnupg2 -y
add-apt-repository ppa:ondrej/php
```
Once the repository is added, update the repository and install PHP with required extensions by running the following command:
```
apt-get install php7.2 php7.2-tidy php7.2-gd php7.2-xmlrpc php7.2-mbstring libapache2-mod
-php7.2 php7.2-mysql php-apcu php7.2-curl php7.2-intl php7.2-sqlite3 php7.2-zip php-memcache
php7.2-pspell php7.2-zip php7.2-memcached php-pear php7.2-common php7.2-opcache php7.2
-xml php7.2-zip -y
```
Once all packages are installed, edit the php.ini file and make some changes:
```
nano /etc/php/7.2/apache2/php.ini
```
Change the following lines:
```
memory_limit = 256M
upload_max_filesize = 100M
max_execution_time = 300
date.timezone = Asia/Kolkata
```
At this point, a LAMP stack is installed in your server.
## Step 2 – Create a Database for Tiki Wiki
Next, you will need to create a database and user for Tiki WIki. First, log in to MariaDB shell with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
CREATE DATABASE tiki CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'tiki'@'localhost' IDENTIFIED BY 'yourpassword';
```
Next, grant all the privileges to tiki database with the following command:
```
GRANT ALL ON tiki.* TO 'tiki'@'localhost' WITH GRANT OPTION;
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Download Tiki Wiki
Next, you will need to download the latest version of Tiki Wiki from the Sourceforge website. You can download it with the following command:
```
wget https://sourceforge.net/projects/tikiwiki/files/latest/download --no-check-certificate
```
Once the download is completed, extract the downloaded file with the following command:
```
unzip download
```
Next, move the extracted directory to the Apache root directory:
```
mv tiki-21.2 /var/www/html/tikiwiki
```
Next, change the ownership and permissions of the tikiwiki directory:
```
chown -R www-data:www-data /var/www/html/tikiwiki/
chmod -R 755 /var/www/html/tikiwiki/
```
At this point, Tiki Wiki is downloaded and configured.
## Step 4 – Configure Apache for Tiki Wiki
Next, create an Apache virtual host configuration file for Tiki Wiki with the following command:
```
nano /etc/apache2/sites-available/tikiwiki.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
DocumentRoot /var/www/html/tikiwiki
ServerName tiki.example.com
Options FollowSymlinks
AllowOverride All
Require all granted
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
```
Save and close the file when you are finished, then activate the Apache virtual host with the following command:
```
a2ensite tikiwiki.conf
```
Next, enable the Apache rewrite module and restart the Apache service using the following command:
```
a2enmod rewrite
systemctl restart apache2
```
## Step 5 – Access Tiki Wiki
Now, open your web browser and access the Tiki Wiki web interface using the URL
**http://tiki.example.com/tiki-install.php**. You should see the following page:
Select your language and click on the **Continue** button. You should see the following page:
Click on the **Continue** to agree the license agreement. You should see the following page:
Make sure all tests are green, then click on **Continue**. You should see the following page:
Provide your database details and click on the **Continue** button. You should see the following page:
Choose your Database engine and click on the **Install** button. Once the installation has been completed, you should see the following page:
Review the installation click on the **Continue** button. You should see the following page:
Configure Tiki Wiki and click on the **Continue** button. You should see the following page:
Click on the **Continue** button. You should see the admin user creation page:
Click on the “**Enter Tiki and Lock Installer**“. You should see the following page:
Click on the **Log** **in** button. You should see the following page:
Provide default username as “admin” and password as “admin” and click on the **Log In** button. You should see the following page:
Set your admin password and click on the **Apply** button. You should see the Tiki Wiki dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed Tiki Wiki on Ubuntu 20.04 server. You can now host your own Wiki using Tiki Wiki. For more information, you can visit the Tiki Wiki [documentation](https://doc.tiki.org/) page. Get started with Tiki Wiki on [VPS Hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Install OpenNebula on Debian
> URL: https://www.atlantic.net/vps-hosting/how-to-install-opennebula-on-debian/ | Published: 2020-12-07 | Updated: 2025-09-03 | Author: Hitesh Jethva
OpenNebula is a free and open-source cloud computing platform that can be used to build and manage Enterprise Clouds. It is easy to install, update and operate by administrators. OpenNebula is specially designed for data center virtualization and cloud deployments based on the KVM hypervisor. It combines containers from Kubernetes or Docker Hub and integrates multiple virtualization technologies to meet your workload needs.
In this tutorial, we will show you how to install and configure OpenNebula on Debian 12.
## Step 1 – Install MariaDB Server
OpenNebula uses MariaDB as a database backend, so you will need to install it in your server. You can install it with the following command:
```
apt-get install mariadb-server curl gnupg2 -y
```
Once installed, login to MariaDB shell with the following command:
```
mysql
```
Once login, create a database and user with the following command:
```
CREATE DATABASE opennebula;
GRANT ALL PRIVILEGES ON opennebula.* TO 'oneadmin' IDENTIFIED BY 'password';
```
Next, flush the privileges and exit from the MariaDB with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 2 – Install OpenNebula
By default, OpenNebula is not available in the Debian 12 default repository, so you will need to add the OpenNebula repository to your system.
First, download and add the GPG key with the following command:
```
curl -fsSL https://downloads.opennebula.io/repo/repo2.key| gpg --dearmor -o /etc/apt/trusted.gpg.d/opennebula.gpg
```
Next, add the OpenNebula repository with the following command:
```
echo "deb https://downloads.opennebula.io/repo/6.10/Debian/12 stable opennebula" | tee /etc/apt/sources.list.d/opennebula.list
```
Next, update the repository and install OpenNebula with the following command:
```
apt-get update -y
apt-get install opennebula opennebula-sunstone opennebula-gate opennebula-flow -y
```
Once OpenNebula has been installed, run the following command to install other required dependencies:
```
/usr/share/one/install_gems
```
You should get the following output:
```
Execution continues in 15 seconds ...
Distribution "debian" detected.
About to install these dependencies:
* gcc
* rake
* libxml2-dev
* libxslt1-dev
* patch
* g++
* libsqlite3-dev
* libcurl4-openssl-dev
* libssl-dev
* default-libmysqlclient-dev
* postgresql-server-dev-all
* libzmq5
* libzmq3-dev
* libaugeas-dev
* ruby-dev
* make
Press enter to continue...
```
Press Enter to install the required dependencies.
## Step 3 – Configure OpenNebula
Next, you will need to edit the file /etc/one/oned.conf and define your database settings.
```
nano /etc/one/oned.conf
```
Find the following lines:
```
DB = [ BACKEND = "sqlite",
TIMEOUT = 2500 ]
```
And replace them with the following lines:
```
DB = [ BACKEND = "mysql",
SERVER = "localhost",
PORT = 0,
USER = "oneadmin",
PASSWD = "password",
DB_NAME = "opennebula",
CONNECTIONS = 25,
COMPARE_BINARY = "no" ]
```
Save and close the file, then generate the oneadmin password with the following command:
```
cat /var/lib/one/.one/one_auth
```
You should see the following output:
```
oneadmin:cask7QuowHym
```
**Note**: Please remember the above password, as you will need this password to log in OpenNebula.
## Step 4 – Verify OpenNebula Installation
Now, start the OpenNebula service and enable it to start at system reboot with the following command:
```
systemctl start opennebula opennebula-sunstone
systemctl enable opennebula opennebula-sunstone
```
Next, connect the OpenNebula daemon and verify the installation with the following command:
```
su - oneadmin -c "oneuser show"
```
You should get the following output:
## Step 5 – Access OpenNebula Web UI
Now, open your web browser and access the OpenNebula web interface using the URL **http://your-server-ip:9869**. You should see the OpenNebula login page:
Provide your admin username and password and click on the **Login** button. You should see the OpenNebula dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed and configured OpenNebula on Debian 12 server. Now, you can install KVM on another system, add KVM node to the OpenNebula and start creating your first virtual machine from the OpenNebula dashboard. Try OpenNebula on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# Ubersmith Brings Together 50 Disparate Business Operations Systems at Atlantic.Net
> URL: https://www.atlantic.net/press-releases/ubersmith-brings-together-50-disparate-business-operations-systems-at-atlantic-net/ | Published: 2020-12-08 | Updated: 2024-06-11 | Author: Editorial Team
**Ubersmith Brings Together 50 Disparate Business Operations Systems at Atlantic.Net**
*Greatly improves efficiency, more precise billing, better overall customer service*
NEW YORK, December 8, 2020 – Atlantic.Net Inc., a global cloud services provider, replaced or integrated more than 50 different subscription billing, device management and customer support systems into one. Ubersmith business management software has improved business processes from seven to fourteen days to one day, quickened response to support issues by enabling resolution in half of the previous time and realized a 55% improvement in billing for customers’ overage usage.
“By consolidating all our previous systems into Ubersmith, customer information related to billing, products and service is centralized in one place, making it readily accessible,” said Marty Puranik, Founder and CEO, Atlantic.Net. “Plus, we’ve eliminated the need for training our staff on different systems, which saves countless hours and streamline resources.”
“We can automatically tie support tickets to information regarding to specific devices and customers, and as a result, our support ticket times have dropped in half,” said Puranik. “Also, we have better capabilities to monitor customer usage and bill accordingly, which is a net positive for revenue growth.”
Atlantic.Net has achieved tremendous operational efficiencies and substantial cost savings by eliminating many redundant systems.
Started in 1994 in Gainesville, Florida, Atlantic.Net quickly expanded to other cities with new office openings and acquisitions of service providers. Today, it operates out of five data centers in the U.S., one in Canada, and one in the U.K., with plans to expand services in Amsterdam and Singapore next year. Atlantic.Net is a global cloud services provider, providing more than 15,000 customers with business-class dedicated and cloud hosting solutions backed by 24/7/365 support.
Ubersmith is an easily customizable, integrated and modular software suite for subscription billing, quoting, order management, infrastructure management and ticketing. A plug-in system provides flexibility for extending and integrating other software used as part of business operations. Ubersmith provides an application programming interface (API) and software development kit (SDK) to enable customers and partners to easily integrate other systems and programs with the Ubersmith suite.
“We make extensive use of Ubersmith APIs to integrate with other systems that we use for payments, accounting, domain registration, security certificates and more,” said Puranik.
Deep integrations with the Ubersmith software enable Atlantic.Net to achieve high levels of efficiency in operations, helping to improve [employee productivity](https://blog.hubstaff.com/employee-productivity/) and ultimately provide higher levels of customer service. Atlantic.Net is known for delivering outstanding products, service and high customer satisfaction with one of the lower customer churn rates in the VPS hosting industry.
With Ubersmith’s plans to soon add support for Salesforce, Atlantic.Net will be able to tie in its sales and prospecting activities, along with customer quotes, in its systems.
“Atlantic.Net has done an impressive job at leveraging the capabilities we provide in Ubersmith’s business management, infrastructure and operations software,” said Kurt Daniel, CEO of Ubersmith. “We’re pleased to be an important partner for their business as they continue to grow and expand in the cloud services and hosting arenas.”
**About Atlantic.Net**
Atlantic.Net is a global cloud services provider with over 25 years of experience, specializing in managed and non-managed Windows, Linux, and FreeBSD server hosting solutions and HIPAA compliant hosting. With a focus on security, compliance, and simplifying the user experience, Atlantic.Net provides business-class dedicated and cloud hosting solutions, backed by 24/7/365 support through their global data centers located in New York, London, San Francisco, Toronto, Dallas, Ashburn, and Orlando. For more information, please visit [Atlantic.Net](https://www.atlantic.net/).
**About Ubersmith**
Ubersmith is a leader in subscription management software for the cloud and beyond. Headquartered in New York, Ubersmith provides billing, infrastructure and ticketing solutions that are open, scalable and integrated. Organizations worldwide rely on Ubersmith to better serve their customers and better run their businesses. For more, please visit [Ubersmith.com](https://ubersmith.com).
Media Contact:
Glenn Rossman
Acorn PR, for Ubersmith
(914) 623-8354
[glenn@theacornpr.com](mailto:glenn@theacornpr.com)
---
# How to Install Passbolt Password Manager on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-passbolt-password-manager-on-ubuntu-18-04/ | Published: 2020-12-09 | Updated: 2024-06-30 | Author: Hitesh Jethva
Passbolt is an open-source, self-hosted password manager that can be used to store and share the login credentials for websites securely. If your business is organized into teams, then Passbolt will help you to store and share the password across those teams. Passbolt comes with a simple and user-friendly interface and uses GnuPG to authenticate users and verify secrets server side.
In this tutorial, we will show you how to install the Passbolt password manager on Ubuntu 18.04.
## Step 1 – Download Passbolt Installation Script
The simplest way to install Passbolt using the Passbolt installation script. To download the installation script, run the following command:
```
wget -O passbolt-ce-installer-ubuntu-18.04.tar.gz
https://www.passbolt.com/ce/download/installers/ubuntu/latest
```
Next, check the installer checksum with the following command:
```
wget -O passbolt-installer-checksum
https://www.passbolt.com/ce/download/installers/ubuntu/latest-checksum
sha512sum -c passbolt-installer-checksum
```
You should see the following output:
```
passbolt-ce-installer-ubuntu-18.04.tar.gz: OK
```
Next, extract the downloaded installer with the following command:
```
tar -xzf passbolt-ce-installer-ubuntu-18.04.tar.gz
```
Once the installer is extracted, you can proceed with the installation.
## Step 2 – Install Passbolt
Now, run the following command to install Passbolt in your system:
```
./passbolt_ce_ubuntu_installer.sh
```
You will be asked to install MariaDB on your system as shown below:
```
================================================================
____ __ ____
/ __ \____ _____ ____/ /_ ____ / / /_
/ /_/ / __ `/ ___/ ___/ __ \/ __ \/ / __/
/ ____/ /_/ (__ |__ ) /_/ / /_/ / / /_
/_/ \__,_/____/____/_,___/\____/_/\__/
The open source password manager for teams
(c) 2020 Passbolt SA
https://www.passbolt.com
================================================================
IMPORTANT NOTE: This installation scripts are for use only
on FRESH installed debian >= 9.0 | ubuntu 18.04 | CentOS >= 7.0
================================================================
==============================================================
Do you want to install a local mariadb server on this machine?
==============================================================
1) yes
2) no
#? 1
```
Type **1**and hit **Enter** to continue. You will be asked to set MariaDB root password as shown below:
```
=======================================================
Please enter a new password for the root database user:
=======================================================
MariaDB Root Password:
MariaDB Root Password (verify):
```
Next, you will be asked to provide a name for the Passbolt database, a database username, and a password as shown below:
```
======================================================
Please enter a name for the passbolt database username
======================================================
Passbolt database user name:passbolt
=======================================================
Please enter a new password for the mysql passbolt user
=======================================================
MariaDB passbolt user password:
MariaDB passbolt user password (verify):
==============================================
Please enter a name for the passbolt database:
==============================================
Passbolt database name:passboltdb
```
Next, you will be asked to create a GnuPG key as shown below:
```
================================================================================
On virtualized environments GnuPG happen to find not enough entropy
to generate a key. Therefore, Passbolt will not run properly.
Do you want to install Haveged to speed up the entropy generation on
your system? Please check https://help.passbolt.com/faq/hosting/why-haveged-
virtual-env
==================================================================
==============
1) yes
2) no
#? 1
=================================================================
===============
```
Type **1** and hit **Enter** to continue. You will be asked to provide a domain name or the IP address of your server as shown below:
```
Setting hostname...
Please enter the domain name under which passbolt will run.
Note this hostname will be used as server_name for nginx
and as the domain name to register a SSL certificate with
let's encrypt.
If you don't have a domain name and you do not plan to use
let's encrypt please enter the ip address to access this machine
===============================================================
=================
Hostname:your-server-ip
===============================================================
=================
```
Provide your server IP address or domain name and hit **Enter**. You will be asked to set up an SSL certificate as shown below:
```
Setting up SSL...
Do you want to set up a SSL certificate and enable HTTPS now?
- manual: Prompts for the path of user uploaded ssl certificates and set up
nginx
- auto: Will issue a free SSL certificate with https://www.letsencrypt.org
and set up nginx
- none: Do not setup HTTPS at all
================================================================================
1) manual
2) auto
3) none
#? 3
```
Type **3** and hit **Enter** to start the installation. Once the installation has been completed successfully, you should see the following output:
```
Installation is almost complete. Please point your browser to
http://your-server-ip to complete the process
==============================================================
==================
```
At this point, Passbolt is now installed on your server.
## Step 3 – Access Passbolt Configuration Wizard
Next, you will need to configure Passbolt via a web browser.
Open your web browser and type the URL http://your-server-ip. You will be redirected to the following page:
Click on the **Start the wizard** button. You should see the following page:
Click on the **Start configuration** to configure Passbolt as shown below:
Under Database configuration, Set the host as **localhost.**
Leave port as **3306**
Provide your database details *created earlier* and click on the **Next** button. You should see the following page:
Give your server a **name**, **email**and click on the **Next** button to create a new server key. You should see the following page:
Provide your SMTP server settings and click on the **Next** button. You should see the following page:
Provide your server URL and click on the **Next** button. You should see the following page:
Provide your admin user details and click on the **Next** button. You should see the following page:
Click on the **“Download it here”** to download Passbolt chrome extension and click on the **retry** button. You should see the following page:
Provide your server IP and click on the **Next** button. You should see the following page:
Provide the owner name and owner email and click on the **Next** button to create a new key. You should see the following page:
Set your passphrase and click on the **Next** button. You should see the following page:
Click on the **Next** button. You will be redirected to the Passbolt login page as shown below:
Provide your username, password and click on the **login** button. You should see the Passbolt dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed and configured Passbolt password manager on Ubuntu 18.04. You can now share your login credentials across your team using Passbolt. Set up Passbolt on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# Creating a Cloud Server from an ISO
> URL: https://www.atlantic.net/vps-hosting/creating-a-cloud-server-from-an-iso/ | Published: 2020-12-09 | Updated: 2026-03-02 | Author: Josh Simon
## Introduction
There are times when you may have a need for a Cloud Server with an operating system, virtual appliance, application, partition scheme, filesystems, packages, etc. that are not offered by one of the standard operating systems or One-click applications offered by Atlantic.Net. To answer this need, Atlantic.Net offers the ability for you to create a Cloud Server using the ISO image of your choice in addition to our standard operating systems and one-click applications.
**Some highlights offered when creating a Cloud Server from an ISO**
- All non-Windows Operating Systems or Application ISOs are currently supported (Windows support coming soon).
- Freedom and flexibility to choose any Cloud plan or Cloud location for your custom Cloud Server.
- Complete control to choose your operating system, virtual application, partition scheme, filesystems, packages, etc. for your Cloud Server.
- Great solution for customers that need customized solutions, specific compliance and regulatory requirements, and/or have specialized applications.
## **What you will learn in this guide**
Creating a Cloud Server from an ISO
Accessing the Cloud Server Console to perform the install of the Cloud Server
Detaching an ISO from the Cloud Server
## Creating a Cloud Server from an ISO
**Menu Navigation** – click on *Server* in the https://cloud.atlantic.net control panel
**Visit the Add Server Page** – click on the *Add Server* button
**Create your Cloud Sever using an ISO**
- Click on the *ISOs* tab in the *Type* section
- Enter the URL to your ISO (example: https://releases.ubuntu.com/20.04.1/ubuntu-20.04.1-live-server-amd64.iso)
- Proceed with selecting the rest of your desired Cloud Server options and press the *Create Server* button
## Accessing the Cloud Server Console to perform the install of the Cloud Server
On the *Server Details* page, you will see instructions to complete the install/configuration of your Cloud Server using the Cloud Server Console.
You will also see information regarding the ISO that is attached to your Cloud Server.
Click on the *Start Console* button to launch the *Cloud Server Console*.
*Note: While an ISO is attached to your Cloud Server the actions you can take through the control panel and API on that server are restricted to certain allowed actions. Additionally, you will only be able to boot from the ISO. When you are done with the installation/configuration of your Cloud Server you will need to detach the ISO to boot into your configured Cloud Server.*
Once the page is done loading you should see the console of your Cloud Server and be able to begin install/setup of your operating system, virtual appliance, or application.
*Note: It may take some time for your ISO to finish downloading and load for use. The time it takes will largely depend on the bandwidth of the site providing the ISO and the size of the ISO.*
## Detaching an ISO from the Cloud Server
Once you are done with the installation/setup of your operating system, virtual appliance, or application, you will need to detach the ISO from your Cloud Server to boot from your installed/configured Cloud Server.
Click on the D*etach ISO and boot up Cloud Server* option to detach the ISO from your Cloud server.
Once the ISO is done detaching from your Cloud Server it will be booted automatically from storage instead of the ISO.
You will also see that the ISO is not longer attached to your Cloud Server in the Control Panel and that you have additional actions available to you that were not available when the ISO was attached.
Your Cloud Server is now ready for normal use. Enjoy!
---
# How to Install PandoraFMS Server on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-pandorafms-server-on-centos-8/ | Published: 2020-12-10 | Updated: 2023-11-26 | Author: Hitesh Jethva
Pandora FMS is free and open-source monitoring software that allows you to monitor thousands of systems and devices from a central location. It is highly scalable, suitable for complex and large environments. You can monitor the status and performance of web servers, databases, routers, firewalls, and many more types of devices using Pandora FMS.
Pandora FMS uses TCP, UDP, ICMP, SNMP and HTTP protocol and agents to collect metrics from the client system. It is cross-platform and supports Windows and Linux operating systems.
In this tutorial, we will show how to install and configure Pandora FMS server on CentOS 8.
## Step 1 – Install Apache and MariaDB Server
Pandora FMS runs on a web server and uses MariaDB as a database backend. Therefore, you will need to install Apache and MariaDB server in your system. You can install them with the following command:
```
dnf update -y
dnf install httpd mariadb-server -y
```
After installing both packages, start the Apache and MariaDB service and enable them to start at system reboot:
```
systemctl start httpd
systemctl start mariadb
systemctl enable httpd
systemctl enable mariadb
```
## Step 2 – Create a Database for Pandora FMS
First, you will need to set the MariaDB root password. You can set it with the following command:
```
mysql_secure_installation
```
Answer all questions as shown below:
```
Enter current password for root (enter for none):
Set root password? [Y/n] Y
New password:
Re-enter new password:
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
```
Next, log in to MariaDB with the following command:
```
mysql -u root -p
```
Provide your root password and create a database and user for Pandora FMS:
```
CREATE DATABASE pandora;
GRANT ALL PRIVILEGES ON pandora.* to pandora@'localhost' IDENTIFIED BY 'password';
```
Next, flush the privileges and exit from MariaDB with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Install Pandora FMS
By default, Pandora FMS is not available in the CentOS default repository, so you will need to add the Pandora repository to your system.
You can create a Pandora repo with the following command:
```
nano /etc/yum.repos.d/pandorafms.repo
```
Add the following lines:
```
[artica_pandorafms]
name=CentOS6 - PandoraFMS official repo
baseurl=http://firefly.artica.es/centos7
gpgcheck=0
enabled=1
```
Save and close the file, then install the Pandora FMS with the following command:
```
dnf install pandorafms_console -y
```
Once the installation has been completed, give proper permissions and ownership to the pandora directory:
```
chown -R apache:apache /var/www/html/pandora_console/
chmod -R 775 /var/www/html/pandora_console/
```
Next, restart the Apache service to apply the changes:
```
systemctl restart httpd
```
## Step 4 – Access Pandora FMS
Now, open your web browser and access the Pandora FMS web interface using the URL **http://your-server-ip/pandora_console**. You should see the following screen:
Click on the **Next** button. You should see the license agreement page:
Accept the license agreement. You should see the following page:
Make sure all the dependencies are installed, then click on the **Next** button. You should see the following page:
Provide your root username, MariaDB root password, database name, and the path of the application and click on the **Next** button. You should see the following page:
Click on the **Next** button. You should see the following page:
Now, open your terminal and delete the install.php file:
```
rm -rf /var/www/html/pandora_console/install.php
```
Next, edit the config.php file and define your database details:
```
nano /var/www/html/pandora_console/include/config.php
```
Change the following lines as per your database settings:
```
// Begin of automatic config file
$config["dbtype"] = "mysql"; //DB type (mysql, postgresql...in future others)
$config["mysqli"] = true;
$config["dbname"]="pandora"; // MySQL DataBase name
$config["dbuser"]="pandora"; // DB User
$config["dbpass"]="password"; // DB Password
$config["dbhost"]="localhost"; // DB Host
```
Save and close the file, then go to the Pandora web installation screen and click on the **Click here to access to your Pandora FMS console**. You should see the Pandora login page:
Provide the default user as admin and password as pandora and click on the **Login** button. You should see the Pandora FMS dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed and configured Pandora FMS on CentOS 8. You can now install an agent package on the client system and start monitoring from the Pandora dashboard. Get started with Pandora FMS on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# What Is Malware? How It Works and How to Remove It
> URL: https://www.atlantic.net/hipaa-compliant-hosting/what-is-malware-how-it-works-and-how-to-remove-it/ | Published: 2020-12-10 | Updated: 2026-03-01 | Author: Brandon Schroth
The word malware is a short form of two words put together; malicious and software. It refers to a program designed to infiltrate a system without the victim’s knowledge and damage it. Once the cybercriminals have access to a computer network, the victim remains oblivious to the fact that his/her computer has been compromised. Malware is a huge cybersecurity threat, as it may result in loss of data and identity theft, among other unpleasant results.
## **How Does Malware Work?**
Overall, malware is intended to bring profits for hackers. After infecting the computer, it steals the victim’s information, such as passwords and usernames, locations, contacts, and so much more. This information is usually sold to the dark web.
With the help of certain types of [malware, i.e., ransomware](https://www.atlantic.net/vps-hosting/how-to-prepare-for-ransomware-malware-network-and-file-vulnerabilities/) , hackers access the victim’s computer and lock all the data stored on it. They then ask for a ransom to be paid in order for them to decrypt the data.
## **Different Types of Malware**
Malware is a general term that refers to different types of threats. In this section, we’ll have a look at the different [types of malware and what they do](https://softwaretested.com/malware/) .
### **Viruses and worms**
These two classes of malware are quite contagious. They’re both designed to replicate easily and move from one computer to another.
Viruses mostly infect legitimate software and get into the computer when the victim uses the software. The viruses then perform malicious acts, such as destroying or corrupting data.
On the other hand, worms spread from one computer to another without requiring any action from the user. They take advantage of any vulnerability they find in existing security tools or the operating system.
### **Trojans and rootkits**
This second classification of malware involves a concealed attack on an unsuspecting user’s computer. Trojans disguise themselves by pretending to be harmless software. Most users download them unknowingly, thinking that they’re installing useful programs.
Rootkits mask harmful viruses in such a way that they go unnoticed by antivirus programs.
### **Spyware and keyloggers**
These two types of malware are used to monitor the victims’ actions, such as web browsing habits and the most frequently used applications. The data collected is used to commit [identity theft-related fraud](https://www.aura.com/learn/how-to-protect-yourself-from-identity-theft), such as stealing money from the victim’s bank account.
### **Ransomware**
[Ransomware](https://www.tetradefense.com/incident-response/understanding-ransomware-how-it-works-and-how-to-avoid-it/) encrypts the victim’s data and sends a ransom note demanding that payment be made in Bitcoin, [Ethereum](https://paybis.com/ethereum-calculator/), or another cryptocurrency. The victim is threatened that if he/she doesn’t pay on time, either the ransom will increase or all their data will be permanently erased. This type of malware can be especially damaging for organizations who have a responsibility to maintain data security, such as those covered by the requirements of [HIPAA compliance](https://www.atlantic.net/hipaa-compliant-hosting/).
The perpetrators promise that a decryption key will be sent to them after the payment has been made. However, this does not necessarily happen – once the money has been paid, a cybercriminal might ignore the victim.
### **Adware**
Adware is designed for the sole purpose of making money through advertising. It’s intended to get the user to watch as many ads as possible. Every time the user clicks on the ad, the cybercriminal gets some money. In most cases, these ads also steal the user’s information.
## **How Malware Spreads**
Long ago, before the numerous technological advancements that we see today and before the pervasive spread of the Internet, malware was transferred from one computer to another manually. This happened through floppy discs or CD-ROMs. Today, malware may still be spread through physical means, but the vector is USB sticks or flash drives.
However, this dubious software is more commonly delivered through other means. For example, infected attachments are distributed via email. When users click on the links, their personal information and other types of data are left vulnerable, especially if they don’t have any sort of [PC repair](https://softwaretested.com/pc-repair/) software tools installed.
Some hackers deliver malware using complicated alerts in the hope of tricking unsuspecting victims into participating. For example, the victim may be made to believe that he/she has won a contest, missed a delivery or tax payment, or has received some money in their bank account. In this instance, the victim’s attention is fully drawn, and he/she is bound to follow that up with an action to try and get more information. Doing this activates the malware.
Whenever the hackers have a specific target in mind, they can customize the false message to lure an individual or a particular organization.
It’s worth knowing that malware may spread through means other than those described here. Some ways do not even require any action from the end-users. These techniques take advantage of software vulnerabilities in the system.
## **What Does Malware Do to Victims’ Devices?**
How can one tell if their device has a malware infection considering that the damage is internal and not physical? It’s quite simple to figure this out, since malicious software usually performs repeated tasks that take up resources on your computer.
Since malware is quite difficult to detect, some devices may be infected without the user ever noticing it. Here are some of the signs that are huge indicators showing that your device may have malware:
- The computer becomes too slow.
- Applications take too long to load.
- The battery drains a lot faster than usual.
- There are many annoying popup ads.
- You start noticing apps that you didn’t download/install.
- There’s a huge spike in data usage that you cannot explain.
To further confirm your doubts, you should run an [anti-malware scan](https://www.atlantic.net/vps-hosting/). Make sure that you use the most comprehensive product in the market to keep your device safe.
## **How to Remove Malware**
Malicious software sneaks into peoples’ computers when they least expect it. If your device has already been infected, you should remove the malware as soon as possible to prevent any further damage.
The easiest way to remove malware from your computer is by using your antivirus program. If you’re having trouble removing the threats in a normal boot environment, try going into Safe Mode and tackle the infection from there. Keep your antivirus database updated at all times to prevent new malware from sneaking into your device.
Although macOS and Windows both have their own malware scanners, some new viruses, like rootkit malware, are so complex that you need extra help. This type of virus can’t be dealt with using your regular malware removal techniques, so don’t hesitate to ask for professional help.
But the best way to deal with malware is to not get infected in the first place. Having a foolproof cybersecurity strategy in place ensures that your data and your devices are protected from all types of threats.
## **How to Protect Your Computer from Malware Infections**
Even though all devices that connect to the Internet are prone to malware attacks, there are some actions that you can take to stay protected. These include:
- Always making sure that your OS is up-to-date.
- Keeping all your data backed up.
- Scanning all executable files before you run them.
- Avoiding opening unfamiliar emails and clicking on suspicious links.
- Investing in reliable security software to protect your computer.
**Conclusion**
The threat of malware attacks keeps getting more serious with each passing day. Malware gets installed onto the victims’ computers without their consent and steals their personal information, usually for profit-making purposes. The attacks may happen on all types of devices, including PCs, tablets, and smartphones. Malware attacks also affect all types of operating systems ranging from Windows, Android, Linux, macOS, and iOS.
---
# Install Ntopng to Monitor Network Traffic on Ubuntu
> URL: https://www.atlantic.net/vps-hosting/install-ntopng-to-monitor-network-traffic-on-ubuntu/ | Published: 2020-12-11 | Updated: 2024-07-02 | Author: Hitesh Jethva
Ntopng is software for monitoring network traffic. This free, open-source software provides a web interface for enabling real-time monitoring. Ntopng is essentially the next-generation version of the original ntop. It shows the network usage similar to the way popular UNIX commands do, but ntopng supports various operating systems, such as Windows, BSD, Mac OS, Linux, and UNIX.
Ntopng is best described as a passive network monitoring tool. It is focused on statistics and flows that are obtained from the traffic that the server captures. While professional and enterprise editions of Ntopng have licensing requirements, the community edition has none.
In this tutorial, we will show you how to install NtopNG on Ubuntu 20.04.
## Step 1 – Add ntopng Repository
By default, the ntopng package is not available in the Ubuntu 20.04 default repository, so you will need to add the ntopng repository to your system.
First, install the required dependencies to your server with the following command:
```
apt-get install wget gnupg -y
```
Next, download the ntopng repository package with the following command:
```
wget http://apt.ntop.org/18.04/all/apt-ntop.deb
```
Once the package is downloaded, install the downloaded package with the following command:
```
dpkg -i apt-ntop.deb
```
Once the repository is installed, update it with the following command:
```
apt-get update -y
```
## Step 2 – Install and Configure ntopng
Now, you can install the ntopng package with other packages using the following command:
```
apt-get install pfring-dkms nprobe ntopng n2disk cento -y
```
After installing ntopng, you will need to edit the ntopng configuration file and define your Network Interface, Port, and Location of the PID.
```
nano /etc/ntopng/ntopng.conf
```
Change the following lines per your requirements:
```
-G=/var/run/ntopng.pid
-i=eth0
-w=3000
```
Save and close the file when you are finished. Next, create a new configuration file and define your Network IP range:
```
nano /etc/ntopng/ntopng.start
```
Add the following lines as per your Network IP:
```
--local-networks "0.0.0.0/24" ## give your local IP Ranges here.
--interface 1
```
Save and close the file when you are finished. Then, start the ntopng service and enable it to start at system reboot with the following command:
```
systemctl start ntopng
systemctl enable ntopng
```
You can also verify the status of the ntopng with the following command:
```
systemctl status ntopng
```
You should get the following output:
- ```
ntopng.service - ntopng high-speed web-based traffic monitoring and analysis tool
```
```
Loaded: loaded (/etc/systemd/system/ntopng.service; enabled; vendor preset: enabled)
Active: active (running) since Thu 2020-10-01 09:10:02 UTC; 8min ago
Main PID: 31314 (ntopng)
Tasks: 52 (limit: 2353)
Memory: 291.4M
CGroup: /system.slice/ntopng.service
└─31314 /usr/local/bin/ntopng /run/ntopng.conf
Oct 01 09:10:06 ubuntu2004 ntopng[31314]: 01/Oct/2020 09:10:06 [startup.lua:226] Startup
completed
```
## Step 3 – Access ntopng Web Interface
At this point, ntopng is started and listening on port 3000. You can check it with the following command:
```
ss -plunt | grep 3000
```
You should get the following output:
```
tcp LISTEN 0 4096 0.0.0.0:3000 0.0.0.0:*
users:(("ntopng",pid=31314,fd=33))
```
Now, open your web browser and access the NtopNG dashboard using the URL **http://your-server-ip:3000**.
Provide the default username and password as **admin**/**admin** and click on the **Login** button. You will be redirected to the password reset screen:
Provide your new password and click on the **Change** **Password** button. You should see the ntopng dashboard on the following page:
Click on the **Hosts** button in the left pane. You should see your system information in the following page:
Click on the **Interface** button in the left pane. You should see your network information in the following page:
## Conclusion
Congratulations! You have successfully installed and configured ntopng on Ubuntu 20.04. You can now easily monitor your network usage in real-time. Get started with ntopng on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Setup Nginx Cache on LEMP Server
> URL: https://www.atlantic.net/vps-hosting/how-to-setup-nginx-cache-on-lemp-server/ | Published: 2020-12-12 | Updated: 2023-11-25 | Author: Hitesh Jethva
Nginx is free, open-source web server, not to mention one of the most widely used web servers in the world. It can be used as a reverse proxy, mail proxy, load balancer and caching server. Nginx is highly scalable and specially designed for maximum performance and stability. It uses an event-driven architecture and handles every incoming request in a single thread.
Nginx comes with a FastCGI module that can be used to cache dynamic content served from the PHP backend. You don’t need to set up other caching solutions such as Redis, Varnish, Memcache after setting up Nginx with FastCGI cache.
In this tutorial, we will show you how to set up Nginx FastCGI cache with LEMP on Ubuntu 18.04.
```
```
## Step 1 – Install LEMP Server
Let’s start with installing LEMP (Nginx, PHP, PHP-FPM) on your server.
```
apt-get install nginx php php-cli php-fpm -y
```
The above command will also install Apache web server in your system, so you will need to stop and disable the Apache service.
```
systemctl stop apache2
systemctl disable apache2
```
Next, start the Nginx and PHP-FPM service with the following command:
```
systemctl start nginx
systemctl start php7.2-fpm
```
Once you are finished, you can proceed to the next step.
## Step 2 – Create a Sample Website
First, create a directory for your website with the following command:
```
mkdir /var/www/html/example.com
```
Next, create a sample info.php file inside your website directory:
```
nano /var/www/html/example.com/info.php
```
Add the following lines:
```
```
Save and close the file. Then, change the ownership of your website to www-data user:
```
chown -R www-data:www-data /var/www/html/example.com
chmod -R 755 /var/www/html/example.com
```
Once you are finished, you can proceed to the next step.
## Step 3 – Configure Nginx with FastCGI Cache
Next, you will need to create a new Nginx virtual host configuration file to serve your website and enable the FastCGI cache.
```
nano /etc/nginx/sites-available/example.com.conf
```
Add the following lines:
```
# Enable FastCGI Support
fastcgi_cache_path /etc/nginx/cache levels=1:2 keys_zone=nginxcache:150m max_size=1g
inactive=60m use_temp_path=off;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
add_header X-Cache $upstream_cache_status;
server {
listen 80;
root /var/www/html/example.com;
client_max_body_size 256M;
index info.php;
server_name example.com;
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
location = /favicon.ico { access_log off; log_not_found off; }
#Disable caching for login session, user cookie, POST request, query string, site map and feeds
set $skip_cache 0;
if ($request_method = POST) {
set $skip_cache 1;
}
if ($query_string != "") {
set $skip_cache 1;
}
# Enable caching for your website.
location ~ \.php$ {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass unix:/var/run/php/php7.2-fpm.sock;
fastcgi_index info.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_intercept_errors off;
fastcgi_buffer_size 16k;
fastcgi_buffers 4 16k;
fastcgi_connect_timeout 600;
fastcgi_send_timeout 600;
fastcgi_read_timeout 600;
fastcgi_cache nginxcache;
fastcgi_cache_valid 200 301 302 60m;
fastcgi_cache_use_stale error timeout updating invalid_header http_500 http_503;
fastcgi_cache_min_uses 1;
fastcgi_cache_lock on;
}
}
```
Save and close the file when you are finished, then check Nginx for any syntax errors with the following command:
```
nginx -t
```
You should get the following output:
Next, enable the Nginx virtual host file with the following command:
```
ln -s /etc/nginx/sites-available/example.com.conf /etc/nginx/sites-enabled/
```
Finally, reload the Nginx service to apply the changes:
```
systemctl restart nginx
```
A brief explanation of each directive in the above configuration file is shown below:
- **fastcgi_cache_path** creates a FastCGI cache and specifies the cache location, memory zone name (nginxcache) with size (150M), max_size (1G), and defines the key for cache lookup.
- **add_header** is used to validate whether the request has been served from the FastCGI cache or not.
- **fastcgi** specifies the path of the php-fpm socket.
- **fastcgi_cache** enables caching, which we have specified using the memory zone in fastcgi_cache_path directive.
- **fastcgi_cache_valid** sets the cache time with status code 200, 301, 302 will be cached for 60 minutes.
- **fastcgi_cache_lock** allows only first request through the upstream PHP-FPM server.
## Step 4 – Test Nginx FastCGI Cache
At this point, Nginx is installed and configured with FastCGI Cache support. It’s time to verify whether the caching is working or not.
Open your web browser, access your Nginx web server using the URL [http://example.com](https://example.com/), and reload the page a few times.
Next, open your terminal and run the following command to fetch the http response header.
```
curl -I http://example.com
```
You should get the following output:
```
HTTP/1.1 200 OK
Server: nginx/1.14.0 (Ubuntu)
Date: Fri, 24 Apr 2020 16:07:24 GMT
Content-Type: text/html; charset=UTF-8
Connection: keep-alive
X-Cache: HIT
```
From the above output, X**-Cache: HIT**indicates that the response was served from the cache.
## Conclusion
Congratulations! You have successfully configured Nginx with FastCGI Cache support. After enabling caching, you should notice a huge improvement in performance because pages are loaded without having to be rendered by PHP. Try out FastCGI Cache on Nginx today with Atlantic.Net’s [VPS hosting](https://www.atlantic.net/vps-hosting/) service.
---
# How to Setup Nginx Cache on a LAMP Server
> URL: https://www.atlantic.net/vps-hosting/how-to-setup-nginx-cache-on-a-lamp-server/ | Published: 2020-12-13 | Updated: 2023-11-27 | Author: Hitesh Jethva
Apache is one of the most reliable and powerful web servers available. Apache is open-source, highly customizable, and comes with many modules that allow you to add additional functionality. It is known for its power and is specially designed for small-to-medium-sized websites.
Using Apache in parallel with Nginx and FastCGI Cache allows you to get the best of both worlds. This setup will improve your web server performance using the strengths of both web server applications. Nginx FastCGI cache works by storing copies of files in a cache so that they can be accessed more quickly.
In this tutorial, we will show you how to setup Nginx FastCGI cache with LAMP Server on Ubuntu 18.04. We will configure Apache as a backend server and Nginx as a frontend server with FastCGI Cache.
## Step 1 – Install LAMP Server
First, install the Apache web server, PHP, PHP-FPM and other modules with the following command:
```
apt-get update -y
apt-get install apache2 php php-fpm libapache2-mod-php7.2 libapache2-mod-fcgid -y
```
Once all the packages are installed, you will need to enable some required Apache modules so that Apache can work with PHP-FPM.
You can enable them with the following command:
```
a2enmod actions fcgid alias proxy_fcgi
```
Next, restart the Apache service to apply the changes.
```
systemctl restart apache2
```
## Step 2 – Create a Sample Website
First, create a directory for your website with the following command:
```
mkdir /var/www/html/example.com
```
Next, create a sample info.php file inside your website directory:
```
nano /var/www/html/example.com/info.php
```
Add the following lines:
```
```
Save and close the file, then change the ownership of your website to www-data user:
```
chown -R www-data:www-data /var/www/html/example.com
chmod -R 755 /var/www/html/example.com
```
Once you are finished, you can proceed to the next step.
## Step 3 – Configure Apache Web Server
By default, the Apache web server listens on port 80. Here, we will use Apache as a backend server, so *change the Apache default port from 80 to **8088***.
```
nano /etc/apache2/ports.conf
```
Change the line from “Listen 80” to “Listen 8088”:
```
Listen 8088
```
Save and close the file when you are finished, then disable the Apache default virtual host file with the following command:
```
a2dissite 000-default.conf
```
Next, restart the Apache web server to implement the changes.
```
systemctl restart apache2
```
Next, create a new virtual host configuration file to serve your website:
```
nano /etc/apache2/sites-available/example.com.conf
```
Add the following content:
```
ServerName 127.0.0.1
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html/example.com
DirectoryIndex info.php
# 2.4.10+ can proxy to unix socket
SetHandler "proxy:unix:/run/php/php7.2-fpm.sock|fcgi://localhost"
Options FollowSymLinks Includes ExecCGI
AllowOverride All
Require all granted
CustomLog /var/log/apache2/access.log combined
ErrorLog /var/log/apache2/error.log
```
Save and close the file when you are finished, then enable the Apache virtual host configuration file with the following command:
```
a2ensite example.com.conf
```
Next, restart the Apache service to apply the changes:
```
systemctl restart apache2
```
At this point, the Apache web server is configured and listening on localhost on port 8088.
## Step 4 – Configure Nginx as a Reverse Proxy with FastCGI Cache
In this section, we will configure Nginx as a reverse proxy for Apache web server and enable FastCGI Cache.
First, install the Nginx web server with the following command:
```
apt-get install nginx -y
```
Once installed, create a new Nginx virtual host configuration file:
```
nano /etc/nginx/sites-available/example.com.conf
```
Add the following content:
```
# Enable FastCGI Support
proxy_cache_path /etc/nginx/cache levels=1:2 keys_zone=nginxcache:100m max_size=1g inactive=60m use_temp_path=off;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
add_header X-Cache $upstream_cache_status;
server {
listen 80;
server_name example.com;
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
location = /favicon.ico { access_log off; log_not_found off; }
set $skip_cache 0;
#Disable caching for login session, user cookie, POST request, query string, site map and feeds
if ($request_method = POST) {
set $skip_cache 1;
}
if ($query_string != "") {
set $skip_cache 1;
}
# Enable caching for your website.
location / {
proxy_pass http://127.0.0.1:8088;
proxy_set_header Host $host;
proxy_buffering on;
proxy_cache nginxcache;
proxy_cache_use_stale error timeout invalid_header updating http_500 http_502
http_503 http_504;
proxy_cache_valid 200 301 302 60m;
proxy_cache_min_uses 1;
proxy_cache_lock on;
}
}
```
Save and close the file when you are finished, then enable the Nginx virtual host file with the following command:
```
ln -s /etc/nginx/sites-available/example.com.conf /etc/nginx/sites-enabled/
```
Next, restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 5 – Test Nginx FastCGI Cache
At this point, Nginx is installed and configured as a reverse proxy for Apache with FastCGI Cache support. It’s time to verify whether the caching is working or not.
Open your web browser and access your Nginx web server using the URL [http://example.com](https://example.com/) and reload the page for a few times.
Next, open your terminal and run the following command to fetch the http response header.
```
curl -I http://example.com
```
You should get the following output:
```
HTTP/1.1 200 OK
Server: nginx/1.14.0 (Ubuntu)
Date: Fri, 24 Apr 2020 17:01:42 GMT
Content-Type: text/html; charset=UTF-8
Connection: keep-alive
Vary: Accept-Encoding
X-Cache: HIT
```
From the above output, **X-Cache: HIT** indicates that the response was served from the cache.
## Conclusion
In the above guide, we have installed and configured the Apache web server as a backend server and Nginx as a frontend server with FastCGI caching. Hopefully, this setup will dramatically improve the performance of your webserver. Get started with FastCGI caching on your LAMP server with [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# Netstat Command Line Tips and Tricks
> URL: https://www.atlantic.net/vps-hosting/netstat-command-line-tips-and-tricks/ | Published: 2020-12-14 | Updated: 2023-11-27 | Author: Hitesh Jethva
Netstat, which stands for “network statistics,” is a network command-line utility that displays network connections, routing tables, network interface and network protocol statistics. It is very useful for checking your network configuration and activity. You can also get detailed information of which services are listening on which port and the details of any connections currently made to them. This tool is available in most versions of Windows, Linux, Unix, Solaris and BSD. Netstat helps a system administrator troubleshoot network-related problems and determine network traffic performance.
In this tutorial, we will show you some useful netstat command-line tips and tricks.
## Install Netstat
By default, the netstat utility comes pre-installed in most Linux operating systems. If not installed, you can install it by running the following command:
```
apt-get install net-tools -y
```
## List All Connection
You can list all TCP and UDP connections with listening and non-listening ports by using the option -a:
```
netstat -a
```
You should see the following screen:
## List Only TCP Connections
To list only TCP connections, use the option -at as shown below:
```
netstat -at
```
You should see the following screen:
## List Only UDP Connections
To list only UDP connections, use the option -ut as shown below:
```
netstat -ut
```
You should see the following screen:
## List All Listening Connections
You can print only listening connections using the option -l as shown below:
```
netstat -l
```
You should see the following screen:
## List Only TCP Listening Connections
To list only active TCP connections, use the option -lt as shown below:
```
netstat -lt
```
You should see the following screen:
## List Only UDP Listening Connections
To list only active UDP connections, use the option -lu as shown below:
```
netstat -lu
```
You should see the following screen:
## List Only Unix Listening Connection
To list only listening UNIX Ports, use the option -lx as shown below:
```
netstat -lx
```
You should see the following screen:
## List All Connections with PID and Process Name
If you want to get a list of all connections with PID and process name, use the option -ap as shown below:
```
netstat -ap
```
You should see the following screen:
## Display Service Name with PID and UID
To display service name with PID and UID, use the option -tp as shown below:
```
netstat -nlpt
```
You should see the following screen:
## Display Interface Statistics
To display statistics about the network interface, use option -i as shown below:
```
netstat -i
```
You should see the following screen:
You can also print information about your network interface using the option -ie as shown below:
```
netstat -ie
```
You should see the following screen:
## Display Routing Information
To display information about network routing, use the option -r as shown below:
```
netstat -r
```
You should see the following screen:
## Display IPv4 and IPv6 information
To display multicast information for both IPv4 and IPv6 protocols, use the option -g as shown below:
```
netstat -g
```
You should see the following screen:
## Disable Hostname Lookup
When you run a netstat command, it will try to find the hostname of each connection. This will slow down your output. You can disable hostname lookup and display only IP address by running the following command:
```
netstat -ant
```
You should see the following screen:
## Display Help Information
You can display all options available with netstat utility using the following command:
```
netstat --help
```
You should see the following screen:
## Conclusion
In the above guide, you learned how to use netstat command to find active and inactive connections with TCP and UDP ports. This can help you to troubleshoot network related problems. Try netstat today on your [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
---
# How to Install PowerDNS and PowerAdmin on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-powerdns-and-poweradmin-on-centos-8/ | Published: 2020-12-15 | Updated: 2023-11-25 | Author: Hitesh Jethva
PowerDNS is a powerful and high-performance authoritative nameserver written in C++. It is an alternative to BIND DNS and uses MariaDB, MySQL, Oracle, and MariaDB to store records. PowerDNS runs on most UNIX-based operating systems and is used to host domains using DNSSEC. It uses a separate program called PowerDNS Recursor as the resolving DNS server. PowerDNS-Admin is an advanced web interface for PowerDNS used for managing zones and records through a web browser.
In this tutorial, we will show you how to install PowerDNS and PowerAdmin with MariaDB backend on CentOS 8.
## Step 1 – Install LAMP Server
First, install the Apache and MariaDB server with the following command:
```
dnf install httpd mariadb-server -y
```
Once installed, start the MariaDB and Apache services and enable them to start at system reboot with the following command:
```
systemctl start httpd
systemctl start mariadb
systemctl enable httpd
systemctl enable mariadb
```
Next, you will need to install the latest version of PHP in your system. By default, the latest version of PHP is not available in CentOS 8, so you will need to add the Remi repository in your system. You can add it with the following command:
```
dnf install http://rpms.remirepo.net/enterprise/remi-release-8.rpm -y
```
Next, disable the default PHP module and enable the PHP Remi module with the following command:
```
dnf module reset php
dnf module enable php:remi-7.4
```
Next, install PHP and other required modules with the following command:
```
dnf install php php-devel php-gd php-imap php-ldap php-mysql php-odbc php-pear php-xml php-
xmlrpc php-mbstring php-mcrypt php-mhash gettext php-pear -y
```
Once all the packages are installed, you can proceed to the next step.
```
systemctl start php-fpm
systemctl enable php-fpm
```
## Step 2 – Configure MariaDB Database
Next, you will need to create a database and user for PowerDNS. First, log in to MariaDB with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
create database powerdnsdb;
create user 'powerdns' identified by 'password';
```
Next, grant all the privileges to the powerdnsdb with the following command:
```
grant all privileges on powerdnsdb.* to 'powerdns'@'localhost' identified by 'password';
```
Next, flush the privileges with the following command:
```
flush privileges;
```
Next, change the database to powerdnsdb and create table structures with the following command:
```
use powerdnsdb;
CREATE TABLE domains (
id INT AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
master VARCHAR(128) DEFAULT NULL,
last_check INT DEFAULT NULL,
type VARCHAR(6) NOT NULL,
notified_serial INT DEFAULT NULL,
account VARCHAR(40) DEFAULT NULL,
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE UNIQUE INDEX name_index ON domains(name);
CREATE TABLE records (
id BIGINT AUTO_INCREMENT,
domain_id INT DEFAULT NULL,
name VARCHAR(255) DEFAULT NULL,
type VARCHAR(10) DEFAULT NULL,
content VARCHAR(64000) DEFAULT NULL,
ttl INT DEFAULT NULL,
prio INT DEFAULT NULL,
change_date INT DEFAULT NULL,
disabled TINYINT(1) DEFAULT 0,
ordername VARCHAR(255) BINARY DEFAULT NULL,
auth TINYINT(1) DEFAULT 1,
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE INDEX name_index ON domains(name);
CREATE INDEX nametype_index ON records(name,type);
CREATE INDEX domain_id ON records(domain_id);
CREATE INDEX recordorder ON records (domain_id, ordername);
CREATE TABLE supermasters (
ip VARCHAR(64) NOT NULL,
nameserver VARCHAR(255) NOT NULL,
account VARCHAR(40) NOT NULL,
PRIMARY KEY (ip, nameserver)
) Engine=InnoDB;
CREATE TABLE comments (
id INT AUTO_INCREMENT,
domain_id INT NOT NULL,
name VARCHAR(255) NOT NULL,
type VARCHAR(10) NOT NULL,
modified_at INT NOT NULL,
account VARCHAR(40) NOT NULL,
comment VARCHAR(64000) NOT NULL,
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE INDEX comments_domain_id_idx ON comments (domain_id);
CREATE INDEX comments_name_type_idx ON comments (name, type);
CREATE INDEX comments_order_idx ON comments (domain_id, modified_at);
CREATE TABLE domainmetadata (
id INT AUTO_INCREMENT,
domain_id INT NOT NULL,
kind VARCHAR(32),
content TEXT,
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE INDEX domainmetadata_idx ON domainmetadata (domain_id, kind);
CREATE TABLE cryptokeys (
id INT AUTO_INCREMENT,
domain_id INT NOT NULL,
flags INT NOT NULL,
active BOOL,
content TEXT,
PRIMARY KEY(id)
) Engine=InnoDB;
CREATE INDEX domainidindex ON cryptokeys(domain_id);
CREATE TABLE tsigkeys (
id INT AUTO_INCREMENT,
name VARCHAR(255),
algorithm VARCHAR(50),
secret VARCHAR(255),
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE UNIQUE INDEX namealgoindex ON tsigkeys(name, algorithm);
```
You can now list all tables with the following command:
```
show tables;
```
You should see the following output:
Next, exit from the MariaDB with the following command:
```
exit;
```
## Step 3 – Install PowerDNS
Before installing PowerDNS, you will need to disable systemd-resolve service. You can disable it with the following command:
```
systemctl disable systemd-resolved
systemctl stop systemd-resolved
```
Next, add new name server entry with the following command:
```
ls -lh /etc/resolv.conf
echo "nameserver 8.8.8.8" | tee /etc/resolv.conf
```
Finally, install PowerDNS with other required packages using the following command:
```
dnf install pdns pdns-backend-mysql bind-utils -y
```
After installing PowerDNS, you will need to configure PowerDNS to use MySQL as backend instead of BIND. You can do it by editing the file /etc/pdns/pdns.conf:
```
nano /etc/pdns/pdns.conf
```
Remove the launch=bind line and add the following lines:
```
launch=gmysql
gmysql-host=localhost
gmysql-user=powerdns
gmysql-password=password
gmysql-dbname=powerdnsdb
```
Save and close the file, then start PowerDNS service and enable it to start on boot.
```
systemctl start pdns
systemctl enable pdns
```
## Step 4 – Install PowerAdmin
First, download the latest version of PowerAdmin with the following command:
```
wget http://downloads.sourceforge.net/project/poweradmin/poweradmin-2.1.7.tgz
```
Once downloaded, extract the downloaded file with the following command:
```
tar xvf poweradmin-2.1.7.tgz
```
Next, move the extracted directory to the Apache root directory:
```
mv poweradmin-2.1.7 /var/www/html/poweradmin/
```
Next, change the ownership of the poweradmin directory to apache with the following command:
```
chown -R apache:apache /var/www/html/poweradmin
```
## Step 5 – Access PowerAdmin Web Interface
Now, open your web browser and access the PowerAdmin web interface using the URL http://your-server-ip/poweradmin/install. You should see the following page:
Select your desired language and click on “**Go to step 2.**” You should see the following page:
Now, click on “**Go to step 3.**” You should see the following page:
Provide your PowerDNS database details and administrator password and click on “**Go to step 4.**” You should see the following page:
Provide the PowerDNS user, password, host, and nameserver and click on “**Go to step 5.**” You should see the following page:
Now, open your terminal, log in to MySQL, and grant the new user all required permissions with the following command:
```
GRANT SELECT, INSERT, UPDATE, DELETE ON powerdnsdb.* TO 'user1'@'localhost'
IDENTIFIED BY 'password';
```
Next, click on “**Go to step 6.**” You should see the following page:
Now, create a new file named config.inc.php as shown below:
```
nano /var/www/html/poweradmin/inc/config.inc.php
```
Paste the content from the web page:
```
URL: https://www.atlantic.net/vps-hosting/how-to-install-vestacp-control-panel-on-debian-9/ | Published: 2020-12-17 | Updated: 2025-12-12 | Author: Hitesh Jethva
VestaCP is a powerful, free, open-source control panel that helps you to create and manage a website, email, database, and DNS from its web-based interface. You can manage a website, domain, FTP, SSL, and backups with the help of VestaCP. It has a built-in Softaculous auto-installer that allows you to install more than 439 apps with one click. If you are looking for a cost-effective alternative to cPanel, then VestaCP is the best solution for you.
In this tutorial, we will show you how to install VestaCP on Debian 9.
## Step 1 – Install Required Dependencies
Before starting, you will need to install some dependencies on your server. You can install all of them with the following command:
```
apt-get update -y
apt-get install nano wget curl unzip gnupg -y
```
Once all the packages are installed, you can proceed to the next step.
## Step 2 – Install VestaCP
VestaCP provides an auto-installer script to install the VestaCP in your server. You can download it with the following command:
```
curl -O http://vestacp.com/pub/vst-install.sh
```
Once the download is completed, give proper permissions with the following command:
```
chmod +x vst-install.sh
```
Next, start the VestaCP installation by running the script as shown below:
```
bash vst-install.sh --force
```
You will be asked to provide a valid email address and domain name as shown below:
```
_| _| _|_|_|_| _|_|_| _|_|_|_|_| _|_|
_| _| _| _| _| _| _|
_| _| _|_|_| _|_| _| _|_|_|_|
_| _| _| _| _| _| _|
_| _|_|_|_| _|_|_| _| _| _|
Vesta Control Panel
The following software will be installed on your system:
- Nginx Web Server
- Apache Web Server (as backend)
- Bind DNS Server
- Exim Mail Server
- Dovecot POP3/IMAP Server
- MariaDB Database Server
- Vsftpd FTP Server
- Softaculous Plugin
- Iptables Firewall + Fail2Ban
Would you like to continue [y/n]: y
Please enter admin email address: admin@example.com
Please enter FQDN hostname [centos]: vesta.example.com
```
Provide your email, domain name and hit Enter to start the installation. Once the installation has been completed, you should see the following output:
```
Installation backup directory: /root/vst_install_backups/1602913863
=======================================================
_| _| _|_|_|_| _|_|_| _|_|_|_|_| _|_|
_| _| _| _| _| _| _|
_| _| _|_|_| _|_| _| _|_|_|_|
_| _| _| _| _| _| _|
_| _|_|_|_| _|_|_| _| _| _|
Congratulations, you have just successfully installed Vesta Control Panel
https://vesta.example.com:8083
username: admin
password: OkF1MklD0p
We hope that you enjoy your installation of Vesta. Please feel free to contact us anytime if you have
any questions.
Thank you.
--
Sincerely yours
vestacp.com team
```
At this point, VestaCP is installed and listening on port 8083. Please remember the admin username and password as shown above.
## Step 3 – Access VestaCP Web Interface
Now, open your web browser and type the URL **https://vesta.example.com:8083**. You should see the VestaCP login page:
Provide your admin username, password and click on the **Log in** button. You should see the VestaCP dashboard in the following page:
## Step 4 – Add a New Website
To create a new website, click on **WEB**. You should see the following page:
Click on the **+**button. You should see the following page:
Provide your website domain name and IP address and click on the **Add** button. Once the website is created, you should see the following page:
Now, open your web browser and access your new website using the URL **http://web1.example.com**. You should see your website default page in the following screen:
You can now FTP to your server and add your site to the public_html folder. Your public_html file should be located in the following directory:
```
/web/your-ip-domain-name/public_html
```
In our example, it is:
```
/web/web1.example.com/public_html
```
You can get a simple FTP client called [Filezilla here if you need one.](https://filezilla-project.org/)
Congratulations! You have just created a website on the Vesta control panel. Thank you for following this guide! Be sure to check back here for updates.
## Conclusion
Congratulations! You have successfully installed VestaCP on a Debian 9 server. You can now explore and VestaCP dashboard for more functionality and start managing your database, domain, email and DNS from a central location. Get started with VestaCP on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How VPS is Giving a Competitive Edge to Forex Trading
> URL: https://www.atlantic.net/vps-hosting/how-vps-is-giving-a-competitive-edge-to-forex-trading/ | Published: 2020-12-18 | Updated: 2026-03-03 | Author: Alexander Wise
Improving your Forex trading speed while cutting costs is an important factor for all traders. Securing a competitive edge and preventing theft from cyber criminals has never been more vital than in today’s current landscape. In the wake of COVID-19, we have seen a real push towards internet-based trading in the majority of financial industries. Fintech has exploded in the last year, providing anyone with an internet connection the ability to complete a trade at their fingertips.
However, in the world of Forex, we’ve seen a range of different developments favoring a more secure and faster approach. One of the most interesting developments is the [increasing use of Virtual Private Servers](https://www.atlantic.net/vps-hosting/how-to-choose-the-right-vps-plan-for-your-business/) , or VPS, to circumnavigate the need for a traditional internet connection when trading. The low latency provided by VPS as well as the increased security result in Forex traders experiencing less negative slippage and avoiding wasting time with requotes and off-quotes.
This article will look into VPS and explore the benefits it provides for Forex traders as well as its impact on latency. We’ll also discuss how it can help your Forex trading reach new heights and secure you a competitive edge.
## VPS & Forex
Forex, or foreign currency exchange, has been in a real state of flux since the beginning of the pandemic, and has presented traders with [several opportunities](https://www.reuters.com/article/us-health-coronavirus-fx/explosion-in-forex-volatility-cheers-some-bruises-others-as-virus-fears-drive-swings-idUSKBN20Y3B4) . However, these opportunities can also come with additional risks. Two currencies can produce great profits or bad losses if judged incorrectly. More importantly, working with a computer that lags behind in response time (referred to as high latency) can prove disastrous for a time sensitive deal.
While speed is a concern for most Forex traders, another main concern is protection from hackers. A VPS, or Virtual Private Server, gives you an added layer of security. Running your trading through this type of server is much safer and faster than working from your own stationary server and can also [be more affordable](https://www.atlantic.net/vps-hosting/how-vps-saves-hosting-costs/) as well.
### What Is a VPS?
A VPS is essentially the hosting equivalent of a subscription service such as Netflix. As opposed to owning, you are basically renting your space on the server. VPS servers can also be [partitioned for each individual trader](https://www.accuwebhosting.com/blog/speed-profits-understanding-vps-works-forex-trading/) , with specific IPs given to traders sustaining specific service. This provides protection from hackers similar to that offered by VPNs. Regardless of where you are, you can access your VPS and it’s available around the clock, even in the event of a power outage.
Like all subscription services, once you quit your VPS service your partitioned space on the server is wiped, with a new subscriber being given a new IP. VPS gives you your own RAM, data limits, OS, etc, so it is different from other websites that make you share resources. In addition, virtual private servers are more flexible than dedicated servers.
Forex markets hit a high of [$6.6 trillion per day](https://tokenist.com/investing/forex-trading-guide/) in 2019, so despite what cynics say, it’s a huge industry that has been growing year on year. Security and speed will continue to be a driving factor behind the success of many current and future traders.
## Latency & VPS
The bane of many a trader’s existence, latency is the delay between your computer’s command being sent and the server (trading exchange in this case) receiving the command, known to the gaming community as a ‘lag’. In the Forex world, this [can be the difference](https://www.cnbc.com/2020/01/27/latency-arbitrage-trading-costs-investors-5-billion-a-year-study.html) between making a successful or failed trade.
### What Is Latency?
Latency, in layman’s terms, is the amount of time a command takes to travel a computer network. It is generally quantified in milliseconds. A [latency level below 100 milliseconds](https://susedefines.suse.com/definition/lower-latency/) (ms) is considered decent, whereas a latency level below 50 ms is very good and ideal for Forex trading.
Normal cable internet or DSL connections have latencies that hover below 100 ms, while satellite connections have latencies of 500 ms or even higher. What difference does a few milliseconds make? Depending on the volume of trading you are doing, this can add up to thousands of dollars lost over the course of a year, not to mention wasted time dealing with requotes.
### How a VPS Can Help
Virtual private servers can alleviate these issues by providing traders with a secure, speedy, and reliable platform to conduct their trades. While more expensive than other hosting options such as shared hosts, VPS platforms still [offer greater power](https://hostingcanada.org/#top-hosting-types-for-canadians:~:text=costs%20a%20bit%20more%20but%20also%20has%20more%20power) and speed. This is why the importance of having a VPS shouldn’t be overlooked for any trader, be that a beginner or a seasoned veteran.
## Why Virtualization Matters
From a technical standpoint, another way in which high latency is prevented is through [direct market access (DMA)](https://blackwellglobal.com/latency-forex-trading/) , an account type which directly connects the buying trader with the order book before an exchange. This reduces the amount of steps needed to complete a trade. Until recently, most retail traders did not have access to this technology, meaning this advantage was almost entirely with institutional traders. However, DMA is only as good as the latency levels within which they operate.
Virtualization has brought positive changes to the majority of industries it has affected, but with the move to the digitalization of wealth, online traders can be at risk from cybercriminals. Therefore, protecting yourself when trading is more important than ever, especially when even the top trading platforms [have significant vulnerabilities](https://www.networkcomputing.com/network-security/trading-online-steps-take-avoid-getting-phished) that can be easily exploited.
### How Does Virtualization Help with Forex Trading?
In the context of Forex trading, virtualization creates compartmentalized virtual servers, which gives traders specific space at a price you can afford, and scalable to whatever you need. This helps avoid fees associated with the trading engines that are commonly used by Forex traders.
Using a VPS, you can affect trades from wherever you want, because the software on the VPS doesn’t require a traditional internet connection to make trades. Cutting out infrastructural costs are a great way to improve your trading success and margins. Utilizing VPS is a viable place to start, and can help develop your competitive edge.
## Creating a Competitive Edge
With minimal barriers to entry, there has been a real influx of traders in recent years, which in turn has an impact on the market. To be successful with all the competition, limiting your costs and improving your trading is key. As most people will tell you in the Forex game, there are seven major currency pairs, which each [have different extraneous variables](https://www.investopedia.com/terms/forex/m/majors.asp) affecting them. Finding ways to create a competitive edge for your trading portfolio is vital.
With the use of VPS, traders can benefit from locational access and cutting overall costs. Furthermore, with VPS they have the ability to trade automatically any time of day or night, which can reduce stress and save a lot of valuable time.
Unsurprisingly, Forex and VPS work incredibly well together, creating a 24/7 trading capability that is uninterrupted and available worldwide. With reduced latency and the availability of scalable options, it’s pretty easy to see how the benefits can affect traders in a number of ways.
Having near 100% uptime for traders backed by Atlantic.Net’s SLA makes VPS options a great addition to their portfolio. The seamless remote execution of automated trading strategies opens up a plethora of new opportunities to make better trades.
## A Viable Direction for Forex Trading
In short, VPS runs remotely and allows you to be completely independent of unforeseeable problems that can arise when working with your own server. For most traders, security and speed is one of the major factors in investment decisions, so having a VPS that can give you robust security is a must. This will not only keep your system safe by preventing data from being broadcasted across a larger internet network, but also [utilizes the cloud to transport data](https://www.atlantic.net/vps-hosting/what-can-you-do-with-a-vps-and-cloud-server/) , making it more secure.
Ultimately, whether COVID-19 was a catalyst or just a coincidence for the rise in FX traders using VPS remains unclear. However, the simple fact remains that [VPS services](https://www.atlantic.net/vps-hosting/) have become very popular in recent months and years for more reasons than one.
---
# How to Install Elgg Social Network on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-elgg-social-network-on-ubuntu-20-04/ | Published: 2020-12-21 | Updated: 2024-03-04 | Author: Hitesh Jethva
Elgg is an open-source and highly customizable framework used for building an online social environment. It provides a simple and powerful user interface that helps to manage and build your content through a web browser. Elgg offers a rich set of features including messaging, microblogging, file-sharing, RSS support, access control, groups, and many more.
In this tutorial, we will show you how to install and configure Elgg social networking platform on Ubuntu 20.04.
## Prerequisites
• A fresh Ubuntu 20.04 on the Atlantic.Net Cloud Platform
• A valid domain name pointed to your server IP
• A root password configured on your server
## Step 1 – Install Apache, MariaDB and PHP
Elgg runs on Apache web server, is written in PHP, and uses MySQL/MariaDB as a database backend, so you will need to install the Apache, MariaDB, PHP and other required PHP extensions to your server. You can install all of them with the following command:
```
apt-get install apache2 mariadb-server php libapache2-mod-php php-common php-sqlite3 php-curl
php-intl php-mbstring php-xmlrpc php-mysql php-gd php-xml php-cli php-zip unzip wget -y
```
After installing all the packages, edit the php.ini file and change some recommended settings.
```
nano /etc/php/7.4/apache2/php.ini
```
Change the following values:
```
max_execution_time = 300
memory_limit = 512M
upload_max_filesize = 100M
date.timezone = Asia/Kolkata
```
Save and close the file, then restart the Apache service to apply the configuration changes.
```
systemctl restart apache2
```
## Step 2 – Create a Database for Elgg
Next, you will need to create a database and user for Elgg. First, log in to MySQL shell with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
CREATE DATABASE elgg;
CREATE USER 'elgg'@'localhost' IDENTIFIED BY 'secure-password';
```
Next, grant all the privileges to the elgg database with the following command:
```
GRANT ALL ON elgg.* TO 'elgg'@'localhost' IDENTIFIED BY 'secure-password' WITH GRANT
OPTION;
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
At this point, the MariaDB database is created for Elgg.
## Step 3 – Install Elgg
First, download the latest version of Elgg from its official website using the following command:
```
wget https://elgg.org/download/elgg-3.3.13.zip
```
Once the download is completed, unzip the downloaded file with the following command:
```
unzip elgg-3.3.13.zip
```
Next, move the extracted directory to the Apache root directory:
```
mv elgg-3.3.13 /var/www/html/elgg
```
Next, create a data directory and set proper ownership and permissions to the Elgg directory:
```
mkdir /var/www/html/data
chown -R www-data:www-data /var/www/html/elgg
chown -R www-data:www-data /var/www/html/data
chmod -R 755 /var/www/html/elgg
```
Once you are finished, you can proceed to the next step.
## Step 4 – Configure Apache for Elgg
Next, you will need to configure Apache to serve Elgg. You can configure it by creating a new Apache virtual host configuration file:
```
nano /etc/apache2/sites-available/elgg.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
DocumentRoot /var/www/html/elgg/
ServerName elgg.example.com
Options FollowSymLinks
AllowOverride All
ErrorLog /var/log/apache2/elgg-error_log
CustomLog /var/log/apache2/elgg-access_log common
```
Save and close the file, then enable the virtual host and Apache rewrite module with the following command:
```
a2ensite elgg.conf
a2enmod rewrite
```
Finally, restart the Apache service to apply the changes:
```
systemctl restart apache2
```
## Step 5 – Access Elgg Web Interface
Now, open your web browser and access the Elgg web interface using the URL http://elgg.example.com. You should see the Elgg welcome screen:
Click on the Next button. You should see the PHP requirement check page:
Once all checks are passed, click on the Next button. You should see the database configuration page:
Provide your database information, data directory, and site URL and click on the Next button. You should see the site configuration page:
Provide your database table prefix, data directory, site URL, and timezone and click on the Next button. You should see the site creation page:
Provide your site name and email and click on the Next button. You should see the following page:
Provide your admin username, password, email and click on the Next button. You should see the following page:
Click on Go to site. You should see the Elgg login page:
Provide your admin username and password and click on the Log in button. You should see the Elgg dashboard in the following page:
## Conclusion
In the above guide, you learned how to install and configure the Elgg social networking platform on Ubuntu 20.04. You can now deploy your own social networking platform in your internal network or live environment. Get started with Elgg today on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to install Hugo Website Generator on Ubuntu
> URL: https://www.atlantic.net/vps-hosting/how-to-install-hugo-website-generator-on-ubuntu/ | Published: 2020-12-22 | Updated: 2023-11-22 | Author: Hitesh Jethva
Hugo is an open-source static website generator designed for small projects and informative sites. It is written in Go language, making it very secure and extremely fast. Hugo provides a great writing experience and is optimized for website viewing. You don’t need to install any dependencies such as PHP, Python, or databases to run Hugo sites.
In this tutorial, we will show you how to install and use the Hugo site generator on Ubuntu 20.04.
## Step 1 – Install Hugo
By default, Hugo is not available in the Ubuntu 20.04 default repository, so you will need to download the latest version of Hugo package from the Git repository. You can download it with the following command:
```
wget https://github.com/gohugoio/hugo/releases/download/v0.79.0/hugo_0.79.0_Linux-64bit.deb
```
Once the package is downloaded, you can install it with the following command:
```
dpkg -i hugo_0.79.0_Linux-64bit.deb
```
If you see any dependency errors, you can resolve them with the following command:
```
apt-get install -f
```
After installing Hugo, verify the installed version of Hugo with the following command:
```
hugo version
```
You should get the following output:
```
Hugo Static Site Generator v0.79.0-1415EFDC linux/amd64 BuildDate: 2020-11-27T09:09:02Z
```
## Step 2 – Create a Website Using Hugo
First, create a new website named web1.doamin.com using the hugo command, as shown below:
```
hugo new site web1.domain.com
```
You should get the following output:
```
Congratulations! Your new Hugo site is created in /root/web1.domain.com.
Just a few more steps and you're ready to go:
1.Download a theme into the same-named folder.
Choose a theme from https://themes.gohugo.io/ or
create your own with the "hugo new theme " command.
2. Perhaps you want to add some content. You can add single files
with "hugo new /.".
3. Start the built-in live server via "hugo server".
```
```
Visit https://gohugo.io/ for quickstart guide and full documentation.
```
You can see the list of all files and directories generated by Hugo with the following command:
```
ls web1.domain.com
```
Output:
```
archetypes config.toml content data layouts static themes
```
## Step 3 – Create Your First Page
Now, change the directory to your website and create a new page named main.md with the following command:
```
cd web1.domain.com
hugo new main.md
```
You should get the following output:
```
/root/web1.domain.com/content/main.md created
```
Next, edit the main.md page and add some content:
```
nano content/main.md
```
Add the following lines at the end of file:
```
# Test Page
This is my first test page.
```
Save and close the file when you are finished.
## Step 4 – Download and Install a Theme
First, change the directory to themes and download the Hugo theme with the following command:
```
cd web1.domain.com/themes
wget https://github.com/digitalcraftsman/hugo-strata-theme/archive/master.zip
```
Once downloaded, unzip the downloaded file with the following command:
```
unzip master.zip
```
Next, rename the extracted directory with the following command:
```
mv hugo-strata-theme-master hugo-strata-theme
```
Next, copy the sample content from the config.toml file located inside themes directory to the default config.toml file:
```
cat hugo-strata-theme/exampleSite/config.toml > ../config.toml
```
Next, edit the config.toml file with the following command:
```
nano ../config.toml
```
Change the base URL and define your page name as shown below:
```
baseurl = "/"
[[menu.main]]
name = "main"
url = "main"
weight = 5
```
Save and close the file, then create a landing page layout file with the following command:
```
nano /root/web1.domain.com/layouts/index.html
```
Add the following lines:
```
{{ define "main" }}
{{ if not .Site.Params.about.hide }}
{{ partial "about" . }}
{{ end }}
{{ if not .Site.Params.portfolio.hide }}
{{ partial "portfolio" . }}
{{ end }}
{{ if not .Site.Params.recentposts.hide }}
{{ partial "recent-posts" . }}
{{ end }}
{{ if not .Site.Params.contact.hide }}
{{ partial "contact" . }}
{{ end }}
{{ end }}
```
Save and close the file.
## Step 5 – Build Your Website
Now, change the directory to your website and build your Hugo website using the following command:
```
cd /root/web1.domain.com
hugo
```
You should get the following output:
```
Start building sites …
WARN 2020/12/06 09:21:44 Page.Hugo is deprecated and will be removed in a future release.
Use the global hugo function.
WARN 2020/12/06 09:21:44 Page.RSSLink is deprecated and will be removed in a future release.
Use the Output Format's link, e.g. something like:
{{ with .OutputFormats.Get "RSS" }}{{ .RelPermalink }}{{ end }}
| EN
-------------------+-----
Pages | 7
Paginator pages | 0
Non-page files | 0
Static files | 26
Processed images | 0
Aliases | 2
Sitemaps | 1
Cleaned | 0
```
Next, start the Hugo server by specifying your server IP as shown below:
```
hugo server --bind=0.0.0.0 --baseUrl=http://your-server-ip -D -F
```
You should get the following output:
```
Start building sites …
WARN 2020/12/06 09:22:02 Page.Hugo is deprecated and will be removed in a future release.
Use the global hugo function.
WARN 2020/12/06 09:22:02 Page.RSSLink is deprecated and will be removed in a future release.
Use the Output Format's link, e.g. something like:
{{ with .OutputFormats.Get "RSS" }}{{ .RelPermalink }}{{ end }}
| EN
-------------------+-----
Pages | 11
Paginator pages | 0
Non-page files | 0
Static files | 26
Processed images | 0
Aliases | 3
Sitemaps | 1
Cleaned | 0
Built in 35 ms
Watching for changes in /root/web1.domain.com/{archetypes,content,data,layouts,static,themes}
Watching for config changes in /root/web1.domain.com/config.toml
Environment: "development"
Serving pages from memory
Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender
Web Server is available at http://69.87.216.179:1313/ (bind address 0.0.0.0)
Press Ctrl+C to stop
```
## Step 6 – Access Hugo Web UI
Now, open your web browser and type the URL **http://your-server-ip:1313**. You should see the Hugo dashboard in the following screen:
Click on **main** in the left pane. You should see your page in the following screen:
## Conclusion
In the above guide, you learned how to install Hugo and generate a static website on Ubuntu 20.04. You should now have enough knowledge to build your own static website easily with Hugo; try it today on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# Top 10 Healthcare Marketing Agencies
> URL: https://www.atlantic.net/hipaa-compliant-hosting/top-10-healthcare-marketing-agencies/ | Published: 2020-12-22 | Updated: 2025-12-05 | Author: Dr. Rachael Bailey
The marketing and advertising sector is highly competitive, so businesses must ensure that they stay ahead of their adversaries. Cloud computing can provide agencies with the competitive edge needed to thrive.
## Why are healthcare marketing agencies turning towards the cloud?
Cloud-based services can offer significant benefits to many creative agencies, including marketing agencies, web developers, and advertising agencies. Cloud computing can:
- Help businesses to increase their productivity and efficiency by providing 24/7 access to hosted applications, tools, and data from any location
- Enhance a business’s reach and engagement with its audience, improving both communication and collaboration
- Reduce costs by negating the need for expensive infrastructure, as many cloud providers offer a pay-as-you-go structure
- Level the playing field so that smaller marketing companies can compete with their larger competitors
- Improve analysis of real-time, actionable data to allow the success of marketing campaigns to be continuously monitored
- Provide access to reliable insight that helps businesses to tailor their content to best suit the needs of their clients
- Increase data security and provide access to automatic and constant backups
- Provide clients with on-demand scalability and the ability to allocate and optimize resources to meet the needs of the business.
- Ensure complete freedom for creativity in content, social media, and [SMS marketing](https://dexatel.com/sms-marketing/) strategies for better results.
- Enable marketing agencies to shift towards inbound marketing techniques, such as blog posts, [online podcasts](https://podcastle.ai/blog/audio-chat-online-podcast-or-radio), video tutorials, and e-books, as opposed to traditional outbound approaches, such as cold calls, trade shows, and advertising
- Ensure full HIPAA compliance for those healthcare marketing agencies dealing with sensitive patient information
- Provide [marketing automation](https://www.engagebay.com/marketing/marketing-automation) to improve productivity and precision
Here, we take a closer look at some of the leading marketing agencies, highlighting our top 10 choices:
## 1. Signify Digital
With over 15 years of experience providing marketing solutions for the healthcare industry, Signify offers its clients a tailored, multi-platform marketing approach that maximizes public awareness and online presence and generates new business leads. Signify’s clients include health tech startups, private consultants, national hospitals, and healthcare charities.
## 2. Wisevu
[Wisevu](https://www.wisevu.com/) is a trusted healthcare marketing agency with more than a decade of experience helping medical organizations grow online. The team understands the unique challenges of healthcare marketing, including compliance requirements, competitive markets, and local search complexities.
Wisevu offers a full suite of healthcare-specific services, including **SEO, PPC management, website development, and online reputation solutions**. These strategies are designed to improve your online visibility, attract new patients, and deliver measurable growth.
With a proven track record of success, Wisevu has helped specialty medical practices increase **organic traffic, lead volume, and appointment bookings** through data-driven strategies. If you’re looking for a reliable partner to enhance your digital presence and consistently drive revenue, Wisevu is an excellent choice.
## 3. LEVO Health
Levo Health provides healthcare branding, patient engagement platforms, and direct to patient medical marketing solutions to physician groups, surgery centers, medical practices, and hospitals on a global scale. This full-service advertising and consulting agency is passionate about helping its clients to grow and strengthen their healthcare brand, accelerate business outcomes, and increase patient acquisition and engagement.
## 4. Distill Health
Distill Health is a boutique healthcare and communications marketing agency that provides its clients with a full spectrum of services, including brand development, digital marketing, strategic storytelling, and brand activation. The team at Distill Health delivers a 3-step system that transforms their client’s healthcare technology innovations into relatable brands. This system combines a synthesis of key clinical data and market intelligence with the development of a strong strategy to deliver a compelling brand story to customers.
## 5. McCann Health
McCann Health is a global leader in marketing, employing over 1,900 staff with offices in 20 countries and across 6 continents. The company specializes in strategic consulting, healthcare professional marketing, medical communications, global health, and HCP communication. McCann Health delivers a bespoke service to their clients, constructing high-performing teams that are perfectly matched to their specific goals.
## 6. Medico Digital
[Medico Digital](https://www.medicodigital.co.uk/) is a forward-thinking, digital marketing agency, specializing in helping healthcare organizations to build their brand using data-driven marketing and tailored digital strategy. Clients have access to leading medical website designers and healthcare marketing experts who are focused on delivering results and supporting companies to reach their business objectives.
## 7. Intrepy
Intrepy is an award-winning, patient-centric healthcare marketing agency that helps medical practices, healthcare businesses, and hospitals to attract, engage, and convert their ideal patients. Intrepy uses its industry-specific knowledge to implement strategies that drive significant growth, expanded reach, and accelerated revenue for their clients. The services offered by this healthcare marketing agency include healthcare digital advertising, medical SEO, medical website design, telemedicine marketing, and graphic design.
## 8. Audacity Health
Audacity Health is a diverse brand strategy and activation agency that specializes in branding, communications, advertising, and marketing services for organizations within the health and science sectors. The industry-recognized company adopts a human approach to their work, creating content that triggers a customer’s emotions and provokes a meaningful response.
## 9. Razorfish Health
As a member of Publicis Health, one of the world’s leading healthcare communications networks, Razorfish Health has helped some of the top healthcare brands to realize their business goals and maximize their audience engagement. Setting them apart from many of their rivals, Razorfish Health boasts one of the largest in-house clinical teams, including medical doctors and scientists.
## 10. Dobies Health Marketing
Established in 1992, Dobies Health Marketing specializes in providing healthcare providers with a strategy-first approach to deliver top-level marketing, branding, and advertising. Dobies works with healthcare organizations of all sizes and types, including hospitals, medical device manufacturers and distributors, certifying boards and associations, physician practices, and health information technology firms.
## 11. Activate Health
Activate Health is a boutique marketing and public relations agency that works with leading health insurers, pharmaceutical companies, hospitals, and health information technology firms. Activate Health’s team boasts decades of combined experience, providing them with unrivaled industry-specific knowledge that can be transformed into creative work that exceeds its clients’ expectations. The agency follows a standard approach when completing its projects, ensuring continuity and quality; this approach involves research, strategy, creativity, results, and refinement.
## How can Atlantic.Net help?
Are you on the lookout for a leading managed service provider to handle your cloud networking needs? As a leading healthcare marketing agency, you need to find a managed service provider that can ensure any sensitive patient data is always fully protected, aligning with the relevant HIPAA regulations.
With over 30 years of industry-leading experience, Atlantic.Net offers fully customizable hosting solutions. If you are seeking a reliable and dependable, secure [HIPAA compliant cloud hosting](https://www.atlantic.net/hipaa-compliant-hosting/) service, then Atlantic.Net is a perfect choice. Contact our sales team to find out how our easy-to-use cloud infrastructure and services can help to launch and scale your agency.
---
# How to install Let’s Chat on an Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-lets-chat-on-an-ubuntu-20-04/ | Published: 2020-12-23 | Updated: 2024-01-18 | Author: Hitesh Jethva
Let’s Chat is a persistent messaging application designed for small teams. It is an open-source and self-hosted chat application that runs on Node.js and MongoDB. Let’s Chat supports private and password-protected rooms, multiple rooms, notifications. Giphy search, Kerberos and LDAP authentication, multi-user chat, and more.
In this tutorial, we will show you how to install Let’s Chat with Nginx as a reverse proxy on Ubuntu 20.04.
## Step 1 – Install Nodejs
First, install the necessary dependencies using the following command.
```
apt-get install -y ca-certificates curl gnupg
```
Next, download the Node.js GPG key.
```
mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
```
Next, add the NodeSource repo to the APT source list.
```
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_18.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
```
Then, update the repository index and install the Ndoe.js with the following command.
```
apt update
apt-get install -y nodejs
```
Next, verify the Node.js version using the following command.
```
node -v
```
Output.
```
v18.19.0
```
## Step 2 – Install MongoDB
Let’s Chat uses MongoDB as a database backend, so you will need to install it in your server. By default, the latest version of MongoDB is not available in the Ubuntu 20.04 default repository, so you will need to add the MongoDB repository to your system.
First, download and add the GPG key with the following command:
```
curl -fsSL https://www.mongodb.org/static/pgp/server-4.4.asc | apt-key add -
```
Next, add the MongoDB repository with the following command:
```
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4
multiverse" | tee /etc/apt/sources.list.d/mongodb-org-4.4.list
```
Next, update the repository and install MongoDB with the following command:
```
apt-get update -y
apt-get install mongodb-org -y
```
After installing the MongoDB, start the MongoDB service and enable it to start at system reboot:
```
systemctl start mongod
systemctl enable mongod
```
## Step 3 – Install Let’s Chat
First, download the latest version of Let’s Chat from the Git repository with the following command:
```
git clone https://github.com/sdelements/lets-chat.git
```
Next, change the directory to the downloaded directory and install all required dependencies with the following command:
```
cd lets-chat
npm install
```
Next, copy the sample configuration file and start the Node server with the following command:
```
cp settings.yml.sample settings.yml
npm start
```
Once the server is started successfully, you should get the following output:
Now, press **CTRL+C** to stop the server.
## Step 4 – Create a Systemd Service File for Let’s Chat
Next, you will need to create a systemd service file for Let’s Chat. You can create it with the following command:
```
nano /etc/systemd/system/letschat.service
```
Add the following lines:
```
[Unit]
Description=Let's Chat Server
Wants=mongodb.service
After=network.target mongod.service
[Service]
Type=simple
WorkingDirectory=/root/lets-chat
ExecStart=/usr/bin/npm start
User=root
Group=root
Restart=always
RestartSec=9
[Install]
WantedBy=multi-user.target
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the Let’s Chat service and enable it to start at system reboot with the following command:
```
systemctl start letschat
systemctl enable letschat
```
You can now check the status of the Let’s Chat with the following command:
```
systemctl status letschat
```
You should get the following output:
At this point, Let’s Chat service is started and listening on port 5000. You can check it with the following command:
```
ss -antpl | grep 5000
```
You should get the following output:
```
LISTEN 0 511 127.0.0.1:5000 0.0.0.0:*
users:(("letschat",pid=31534,fd=20))
```
## Step 5 – Install and Configure Nginx for Let’s Chat
Next, you will need to install and configure Nginx as a reverse proxy for Let’s Chat. First, install the Nginx server with the following command:
```
apt-get install nginx -y
```
Once installed, create a new Nginx virtual host configuration file with the following command:
```
nano /etc/nginx/sites-available/letschat.conf
```
Add the following lines:
```
server {
server_name letschat.example.com;
listen 80;
access_log /var/log/nginx/lets_chat-access.log;
error_log /var/log/nginx/lets_chat-error.log;
location / {
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $host;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_cache_bypass $http_upgrade;
proxy_pass http://127.0.0.1:5000;
}
}
```
Save and close the file, then activate the Nginx virtual host with the following command:
```
ln -s /etc/nginx/sites-available/letschat.conf /etc/nginx/sites-enabled/
```
Next, you will need to set hash_bucket size in the Nginx main configuration file.
```
nano /etc/nginx/nginx.conf
```
Add the following line below http {:
```
server_names_hash_bucket_size 64;
```
Save and close the file, then restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 6 – Access Let’s Chat Web Interface
Now, open your web browser and access the Let’s Chat web interface using the URL **http://letschat.example.com**. You will be redirected to the following page:
Click on “**I need an account**” button. You should see the following page:
Provide your username, email, and password and click on the **Register** button. You should see the following page:
Click on the **OK** button. You should see the Let’s Chat login page:
Provide your username and password and click on the **Sign** **in** button. You should see the Let’s Chat dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed Let’s Chat with Nginx as a reverse proxy on Ubuntu 20.04. You can now create a new chat room and invite users to join this room. Get started with Let’s Chat on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net now!
---
# How to Install Live Helper Chat on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-live-helper-chat-on-ubuntu-20-04/ | Published: 2020-12-28 | Updated: 2023-11-18 | Author: Hitesh Jethva
Live Helper Chat is an open-source chat application that supports web and desktop clients, co-browsing, XMPP notifications, GTalk, Jabber, and more. It can be embedded easily in your website and provide live chat service with multiple departments, multiple locations, and more. Live Helper Chat is based on PHP and uses MySQL or MariaDB as a database backend. It provides many useful features including multiple chats, online tracking, file upload, archive chat, user screenshots, and more.
In this tutorial, we will show you how to install Live Helper Chat on Ubuntu 20.04.
## Step 1 – Install LAMP Server
Before starting, you will need to install the Apache webserver, MariaDB, PHP and other PHP libraries to your server. You can install all of them with the following command:
```
apt-get install apache2 mariadb-server php libapache2-mod-php php-common php-gmp php-curl
php-intl php-mbstring php-xmlrpc php-mysql php-gd php-bcmath php-xml php-cli php-zip php-
sqlite3 unzip git -y
```
After installing all the packages, edit the php.ini file and set some values as below:
```
nano /etc/php/7.4/apache2/php.ini
```
Change the following lines:
```
memory_limit = 256M
upload_max_filesize = 100M
max_execution_time = 360
max_input_vars = 1500
date.timezone = America/Chicago
```
Save and close the file when you are finished.
## Step 2 – Create a Database for Live Helper Chat
Next, you will need to create a user and database for Live Helper Chat. First, log in to the MariaDB shell with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
CREATE DATABASE livehelperchat;
CREATE USER 'livehelperchat'@'localhost' IDENTIFIED BY 'password';
```
Next, grant all the privileges to the livehelperchat database with the following command:
```
GRANT ALL ON livehelperchat.* TO 'livehelperchat'@'localhost' WITH GRANT OPTION;
```
Next, flush the privileges and exit from the MariaDB with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Download Live Helper Chat
Next, download the latest version of the Live Helper Chat from the Git repository with the following command:
```
wget https://github.com/remdex/livehelperchat/archive/master.zip
```
Once the download is completed, unzip the downloaded file with the following command:
```
unzip master.zip
```
Next, copy the extracted directory to the Apache root directory:
```
mv livehelperchat-master /var/www/html/livehelperchat
```
Next, set proper ownership and permissions with the following command:
```
chown -R www-data:www-data /var/www/html/livehelperchat/
chmod -R 755 /var/www/html/livehelperchat/
```
## Step 4 – Configure Apache for Live Helper Chat
Next, you will need to create an Apache virtual host configuration file to serve Live Helper Chat. You can create it with the following command:
```
nano /etc/apache2/sites-available/livehelperchat.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
DocumentRoot /var/www/html/livehelperchat/lhc_web
ServerName livehelper.example.com
Options +FollowSymlinks
AllowOverride All
Require all granted
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
```
Save and close the file, then enable the Apache virtual host with the following command:
```
a2ensite livehelperchat.conf
```
Next, enable the Apache rewrite and headers module with the following command:
```
a2enmod rewrite
a2enmod headers
```
Next, restart the Apache service to apply the changes:
```
systemctl restart apache2
```
## Step 5 – Access Live Helper Chat Web Interface
Now, open your web browser and access the Live Helper Chat using the URL **http://livehelper.example.com**. You will be redirected to the following page:
Make sure all the PHP extensions are installed, then click on the **Next** button. You should see the database configuration page:
Provide your database details and click on the **Next** button. You should see the application settings page:
Provide your admin username, password, and email and click on the **Finish** **installation** button. Once the installation has been completed, you should get the following page:
Click on **Login**. You will be redirected to the Live Helper Chat login page:
Provide your admin username, password and click on the **Login** button. You should see the Live Helper Chat dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed Live Helper Chat on Ubuntu 20.04. You can now explore the dashboard for more functionality and integrate it with your existing website. Get started with Live Helper Chat on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today.
---
# How To Install & Configure MEAN Stack On Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-configure-mean-stack-on-ubuntu-20-04/ | Published: 2020-12-29 | Updated: 2024-01-18 | Author: Hitesh Jethva
A MEAN Stack is a free, open-source, popular JavaScript software stack used for developing dynamic websites and web applications. It is made from four components: MongoDB, Express, Angular, and Node.js. Angular is used for frontend development, while Node.js, Express, and MongoDB are used for backend development. A MEAN stack is based on JavaScript language so it can handle all aspects of an application.
In this tutorial, we will show you how to install a MEAN Stack on Ubuntu 20.04.
## Prerequisites
- A fresh Ubuntu 20.04 [VPS](https://www.atlantic.net/vps-hosting/) on the Atlantic.Net Cloud Platform
- A valid domain name pointed to your server IP
- A root password configured on your server
## Step 1 – Install MongoDB
First, you will need to install a MongoDB database in your server. By default, the latest version of MongoDB is available in the Ubuntu 20.04 default repository, so you can install it easily with the following command:
```
apt-get install mongodb -y
```
Once MongoDB is installed, start the MongoDB service and enable it to start at system reboot with the following command:
```
systemctl start mongodb
systemctl enable mongodb
```
## Step 2 – Install Node.js
First, install the necessary dependencies using the following command.
```
apt-get install -y ca-certificates curl gnupg
```
Next, download the Node.js GPG key.
```
mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
```
Next, add the NodeSource repo to the APT source list.
```
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_18.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
```
Then, update the repository index and install the Ndoe.js with the following command.
```
apt update
apt-get install -y nodejs
```
Next, verify the Node.js version using the following command.
```
node -v
```
Output.
```
v18.19.0
```
Next, install other required packages including yarn, gulp, and pm2 with the following command:
```
npm install -g yarn
npm install -g gulp
npm install pm2 -g
```
Once all the packages are installed, you can proceed to the next step.
## Step 3 – Install and Configure MEAN Stack
First, download the latest version of MEAN with the following command:
```
git clone https://github.com/meanjs/mean
```
Once the download is completed, change the directory to mean and install all required dependencies with the following command:
```
cd mean
yarn install
```
Next, edit the server.js file with the following command:
```
nano server.js
```
Replace all the lines with the following:
```
const express = require('express');
const MongoClient = require('mongodb').MongoClient;
const app = express();
app.use('/', (req, res) => {
MongoClient.connect("mongodb://localhost:27017/test", function(err, db){
db.collection('Example', function(err, collection){
collection.insert({ pageHits: 'pageHits' });
db.collection('Example').count(function(err, count){
if(err) throw err;
res.status(200).send('Page Hits: ' + Math.floor(count/2));
});
});
});
});
app.listen(3000);
console.log('Server running at http://localhost:3000/');
module.exports = app;
```
Save and close the file when you are finished, then start the server with the following command:
```
pm2 start server.js
```
You should get the following output:
Next, enable server.js to start at system reboot with the following command:
```
pm2 startup
```
At this point, the MEAN Stack is installed and listening on port 3000. You can check it with the following command:
```
ss -antpl | grep 3000
```
You should get the following output:
```
LISTEN 0 511 *:3000 *:* users:(("node",pid=26014,fd=20))
```
## Step 4 – Configure Nginx as a Reverse Proxy For MEAN
Next, you will need to install and configure Nginx as a reverse proxy to access the MEAN application.
First, install the Nginx web server with the following command:
```
apt-get install nginx -y
```
Once installed, create a new Nginx virtual host configuration file with the following command:
```
nano /etc/nginx/sites-available/mean
```
Add the following lines:
```
server {
listen 80;
server_name mean.example.com;
access_log /var/log/nginx/mean-access.log;
error_log /var/log/nginx/mean-error.log;
location / {
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Server $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://localhost:3000/;
}
}
```
Save and close the file when you are finished, then enable the virtual host with the following command:
```
ln -s /etc/nginx/sites-available/mean /etc/nginx/sites-enabled/
```
Next, edit the Nginx main configuration file and set the hash_bucket_size:
```
nano /etc/nginx/nginx.conf
```
Add the following line below http {
```
server_names_hash_bucket_size 64;
```
Save and close the file, then verify the Nginx for syntax errors with the following command:
```
nginx -t
```
You should get the following output:
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Finally, restart the Nginx service to apply the configuration changes:
```
systemctl restart nginx
```
## Step 5 – Access MEAN Application
Now, open your web browser and access the MEAN application using the URL **http://mean.example.com**. You should see your MEAN application in the following screen:
In the above screen, the number will be increased automatically when you refresh the page.
## Conclusion
Congratulations! You have successfully installed MEAN Stack with Nginx as a reverse proxy on Ubuntu 20.04 server. You can now easily deploy your own dynamic application with a MEAN Stack on your [VPS hosting](https://www.atlantic.net/vps-hosting/) account with Atlantic.Net.
---
# How to Setup Mantis Bug Tracker on Debian 12
> URL: https://www.atlantic.net/vps-hosting/how-to-setup-mantis-bug-tracker-on-debian-12/ | Published: 2021-01-04 | Updated: 2025-09-07 | Author: Hitesh Jethva
Mantis is one of the most popular web-based bug tracking systems used to track software defects. It also supports release and issues tracking for managing various releases of a project. Mantis is written in PHP and supports several databases including MySQL, PostgreSQL, and MS SQL. It comes with a lot of built-in tools that help you to collaborate with teams to resolve bugs easily from a web-based interface.
If you are looking for a self-hosted bug tracking system, then MantisBT is the best choice for you.
In this tutorial, we will show you how to install and configure the Mantis bug tracking system on Debian 12.
## Step 1 – Install Nginx, MariaDB and PHP
First, you will need to install the Nginx web server, MariaDB, PHP and other PHP extensions to your server. You can install all required packages with the following command:
```
apt-get update -y
apt-get install nginx mariadb-server php php-fpm php-mysql php-cli php-ldap php-zip php-curl php
php-cli php-mbstring php-xmlrpc php-soap php-gd php-xml php-intl php-pear php-bcmath unzip -y
```
After installing all the packages, tweak the PHP settings by editing the file php.ini:
```
nano /etc/php/8.2/fpm/php.ini
```
Change the following settings:
```
file_uploads = On
allow_url_fopen = On
short_open_tag = On
cgi.fix_pathinfo = 0
memory_limit = 512M
upload_max_filesize = 100M
max_execution_time = 300
max_input_vars = 1600
date.timezone = America/Chicago
```
Save and close the file when you are finished.
## Step 2 – Configure MariaDB Database
Mantis uses MariaDB as a database backend, so you will need to create a database and user for Mantis.
First, log in to MariaDB with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
CREATE DATABASE mantisdb;
GRANT ALL PRIVILEGES ON mantisdb.* TO 'mantisuser'@'localhost' IDENTIFIED BY 'secure-
password';
```
Next, flush the privileges and exit from the MariaDB shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Download MantisBT
First, visit the Sourceforge website and download the latest version of MantisBT with the following command:
```
wget https://sourceforge.net/projects/mantisbt/files/mantis-stable/2.27.1/mantisbt-2.27.1.zip
```
Once the download is completed, unzip the downloaded file with the following command:
```
unzip mantisbt-2.27.1.zip
```
Next, move the extracted directory to the Nginx root directory with the following command:
```
mv mantisbt-2.27.1 /var/www/html/mantisbt
```
Next, set proper permissions and ownership to the mantisbt directory:
```
chown -R www-data:www-data /var/www/html/mantisbt
chmod -R 755 /var/www/html/mantisbt
```
## Step 4 – Configure Nginx for MantisBT
Next, you will need to create an Nginx virtual host configuration file to host Mantis. You can create it with the following command:
```
nano /etc/nginx/sites-available/mantisbt
```
Add the following lines:
```
server {
listen 80;
server_name mantisbt.example.com;
root /var/www/html/mantisbt;
index index.php;
access_log /var/log/nginx/example.com.access.log;
error_log /var/log/nginx/example.com.error.log;
client_max_body_size 100M;
autoindex off;
location / {
index index.html index.php;
try_files $uri /index.php$is_args$args;
}
location ~ \.php$ {
include snippets/fastcgi-php.conf;
fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
include fastcgi_params;
fastcgi_intercept_errors on;
}
}
```
Save and close the file, then enable the Mantis virtual host with the following command:
```
ln -s /etc/nginx/sites-available/mantisbt /etc/nginx/sites-enabled/
```
Next, verify Nginx for any syntax errors using the following command:
```
nginx -t
```
You should get the following output:
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Finally, restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 5 – Access Mantis Web UI
Now, open your web browser and access the Mantis web interface using the URL **http://mantisbt.example.com**. You should see the following page:
Provide your database information and timezone and click on the **Install/Upgrade Database** button. You should see the following page:
Now, click on the **Continue** button. You should see the Mantis login page:
Provide default username as **administrator** and click on the **Login** button. You should see the following page:
Provide default password as **root** and click on the **Login** button. You should see the following page:
Change your current password and click on the **Update** **User** button. You should see the following page:
## Conclusion
In the above guide, you learned how to install Mantis bug tracking system on Debian 12. You can now start implementing Mantis in the development environment and manage your project and code from the central location. Try out Mantis on your [VPS Hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# How to Install Memcached on Debian 12
> URL: https://www.atlantic.net/vps-hosting/how-to-install-memcached-on-debian-12/ | Published: 2021-01-05 | Updated: 2025-09-05 | Author: Hitesh Jethva
Memcached is an open-source, high-performance, general-purpose distributed memory object caching system. It helps to speed up dynamic websites by caching data, user authentication tokens, and API calls in RAM. Memcached also provides a mechanism to share the data across multiple application instances. Generally, it is used to speed up php-based applications including Joomla, WordPress, Drupal, and Python.
In this tutorial, we will show you how to install and configure Memcached on Debian 12.
## Step 1 – Install Memcached
By default, Memcached is available in the Debian standard repository. You can install it by just running the following command:
```
apt-get update -y
apt-get install memcached libmemcached-tools -y
```
Once the Memcached is installed, you can check the status of Memcached with the following command:
```
systemctl status memcached
```
You should get the following output:
```
● memcached.service - memcached daemon
Loaded: loaded (/lib/systemd/system/memcached.service; enabled; preset: enabled)
Active: active (running) since Fri 2025-09-05 10:12:55 UTC; 8s ago
Docs: man:memcached(1)
Main PID: 24701 (memcached)
Tasks: 10 (limit: 2304)
Memory: 2.0M
CPU: 38ms
CGroup: /system.slice/memcached.service
└─24701 /usr/bin/memcached -m 64 -p 11211 -u memcache -l 127.0.0.1 -P /var/run/memcached/memcached.pid
Sep 05 10:12:55 debian systemd[1]: Started memcached.service - memcached daemon.
```
By default, Memcached listens on port 11211. You can verify it with the following command:
```
ss -antpl | grep 11211
```
You should get the following output:
```
LISTEN 0 128 127.0.0.1:11211 0.0.0.0:*
users:(("memcached",pid=15969,fd=26))
```
## Step 2 – Configure Memcached
The default Memcached configuration file is located at /etc/memcached.conf. You can change the Memcached default port and configure it for external access using the file:
```
nano /etc/memcached.conf
```
Change the following lines if you want to configure Memcached for external access.
```
-l your-server-ip
-p 11211
```
Save and close the file, then restart the Memcached service to apply the changes:
```
systemctl restart memcached
```
## Step 3 – Enable Memcached for PHP and Python
You will need to install a PHP extension for Memcached if you want to enable Memcached for a php-based web application. You can install it with the following command:
```
apt-get install php php-memcached -y
```
If you want to enable Memcached for Python applications, you can install the Python Memcached extension with the following command:
```
apt install python3-memcache python3-pylibmc -y
```
## Step 4 – Verify Memcached Installation
At this point, Memcached is installed and running. Now it’s time to test whether it is enabled in PHP or not.
First, install the Apache webserver with the following command:
```
apt-get install apache2 libapache2-mod-php -y
```
Next, create a new info.php file inside Apache web root directory:
```
nano /var/www/html/info.php
```
Add the following lines:
```
```
Save and close the file, then restart the Apache to apply the changes.
```
systemctl restart apache2
```
Now, open your web browser and access the info.php page using the URL **http://your-server-ip/info.php**. You should see the following page:
As you can see, Memcached is enabled in PHP.
## Conclusion
In the above guide, you learned how to install Memcached on Debian 12. You also learned how to enable Memcached in PHP and Python. You can now easily integrate your website with Memcached and speed up page loading time; give it a try on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# How to Install Piwigo Photo Gallery on Ubuntu
> URL: https://www.atlantic.net/vps-hosting/how-to-install-piwigo-photo-gallery-on-ubuntu/ | Published: 2021-01-06 | Updated: 2023-11-26 | Author: Hitesh Jethva
Piwigo is a free, open-source, web-based photo gallery application that allows you to upload your photos and videos via FTP, web uploads, and desktop applications. It is written in PHP and uses MySQL as a database backend. Piwigo is especially useful for a photographer who wants to upload their photographs to the web and show them to their client. Piwigo allows you to customize per your needs using built-in extensions.
In this tutorial, we will show you how to install Piwigo Photo Gallery on Ubuntu 20.04.
## Step 1 – Install LAMP Server
First, you will need to install the Apache web server, MariaDB, PHP and other PHP extensions to your server. You can install all of them with the following command:
```
apt-get install apache2 mariadb-server php libapache2-mod-php php-common php-mbstring php-
xmlrpc php-gd php-xml php-intl php-mysql php-cli php php-ldap php-zip php-curl unzip git -y
```
Once all the packages are installed, edit the php.ini file and tweak some settings to recommended values:
```
nano /etc/php/7.4/apache2/php.ini
```
Change the following lines:
```
memory_limit = 256M
upload_max_filesize = 100M
date.timezone = America/Chicago
```
Save and close the file, then restart the Apache service to apply the configuration.
```
systemctl restart apache2
```
## Step 2 – Create a Database for Piwigo
Piwigo uses MySQL or MariaDB as a database backend, so you will need to create a database and user for Piwigo.
First, log in to MySQL with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
CREATE DATABASE piwigo;
CREATE USER 'piwigo'@'localhost' IDENTIFIED BY 'password';
```
Next, grant all the privileges to the piwigo database with the following command:
```
GRANT ALL ON piwigo.* TO 'piwigo'@'localhost' IDENTIFIED BY 'password' WITH GRANT
OPTION;
```
Next, flush the privileges and exit from the MySQL shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Install Piwigo
First, download the latest version of Piwigo from their official website using the following command:
```
curl -o piwigo.zip http://piwigo.org/download/dlcounter.php?code=latest
```
Once the download is completed, unzip the downloaded file with the following command:
```
unzip piwigo.zip
```
Next, move the extracted directory to the Apache web root directory:
```
mv piwigo /var/www/html/piwigo
```
Next, set proper permissions and ownership with the following command:
```
chown -R www-data:www-data /var/www/html/piwigo/
chmod -R 777 /var/www/html/piwigo/
```
## Step 4 – Configure Apache for Piwigo
Next, you will need to create an Apache virtual host configuration file for Piwigo. You can create it with the following command:
```
nano /etc/apache2/sites-available/piwigo.conf
```
Add the following lines:
```
ServerAdmin admin@example.com
DocumentRoot /var/www/html/piwigo
ServerName piwigo.example.com
Options +FollowSymlinks
AllowOverride All
Require all granted
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
```
Save and close the file, then enable the Piwigo virtual host and Apache rewrite module with the following command:
```
a2ensite piwigo.conf
a2enmod rewrite
```
Finally, restart the Apache service using the following command:
```
systemctl restart apache2
```
## Step 5 – Access Piwigo
Now, open your web browser and type the URL **http://piwigo.example.com**. You will be redirected to the Piwigo setup page:
Provide your database details and admin user information and click on the **Start** **installation** button. Once the installation has been completed successfully, you should see the following page:
Now, click on the **Visit** **the** **gallery**. You should see the Piwigo dashboard in the following page:
From here, you can add your photo easily or click on “**I will find my way by myself.**” You should see the following page:
## Conclusion
Congratulations! You have successfully installed and configured Piwigo photo gallery on Ubuntu 20.04. You can now upload your photos and access them over the Internet easily – give it a try with [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# SolarWinds Orion Hack
> URL: https://www.atlantic.net/vps-hosting/solarwinds-orion-hack/ | Published: 2021-01-06 | Updated: 2024-11-14 | Author: Richard Bailey
*Atlantic.Net is providing this security advisory message as a news item; we want to reassure our customers that Atlantic.Net does not use any SolarWinds products internally or as part of any of our service offerings.*
On the 13th December 2020, [news broke from the cybersecurity organization FireEye concerning a major security breach at SolarWinds Corporation](https://www.solarwinds.com/securityadvisory?mkt_tok=eyJpIjoiWkdOaU1qRmhOamt4WXpNMiIsInQiOiJXT1ltbWJJZFJraVpnMEg4MnIrdENLa1VcL0ZGUVNCVW9RbnQ3ZGkyN01SbVwvMUl5OWlvWndueUp1NjlIMHVqU244RU55enJLQ2J5TU1lYWRBYkl6VEZBNm9pNGFhQXBBemZNY1Q5UXJUSFQxN0d3V1AwMkZ3Sm1HN01ETDB6cFBqIn0%3D). SolarWinds is a Texas-based tech giant that has become a dominant player in server monitoring and network management with its Orion line of software products. It serves [300,000 customers](https://www.theregister.com/2020/12/15/solar_winds_update/#:~:text=It%20has%20a%20long%20history,of%20more%20than%20300%2C000%20customers.) globally and is trusted by several high-profile organizations and government institutions.
## How Did the Attack Happen and Who Was Impacted?
Cybersecurity experts believe that a sophisticated, possibly Russian, state-sponsored cyberattack breached SolarWinds infrastructure and impacted many of the company’s customers. Experts believe SolarWinds was breached in the Spring of 2020, but the groundwork for the attack may have started much earlier.
Global companies such as VMware, Intel, Microsoft, and Cisco are [reportedly](https://www.bloomberg.com/news/articles/2020-12-18/cisco-latest-victim-of-russian-cyber-attack-using-solarwinds) impacted by the attack, as well as [all five branches of the US military, the national nuclear security administration, the Pentagon, the State Department, and the Office of the President of the United States](https://www.independent.co.uk/life-style/gadgets-and-tech/solarwinds-hack-how-russia-us-government-b1776034.html).
### How the Hack Worked
The hack was incredibly sophisticated. Hackers were able to gain access to SolarWinds internal systems and compromise their official Orion software updates with *“trojanized”* malware updates. This allowed the hackers to disguise compromised updates as legitimate, SolarWinds-approved Orion updates. It is believed that up to [18,000 SolarWinds customers](https://www.theregister.com/2020/12/15/solar_winds_update/) downloaded the malware. This is, undeniably, a huge, incredible, and quite shocking lapse in security to happen at a company valued at about $5 billion.
[FireEye](https://www.fireeye.com/blog/threat-research/2020/12/evasive-attacker-leverages-solarwinds-supply-chain-compromises-with-sunburst-backdoor.html), the cybersecurity company that first identified the breach, said the hack gave the intruders “the ability to transfer files, execute files, profile the system, reboot the machine, and disable system services. The malware masquerades its network traffic as the Orion Improvement Program (OIP) protocol and stores reconnaissance results within legitimate plugin configuration files, allowing it to blend in with legitimate SolarWinds activity.”
Once installed by the victims, the hackers used part of the Orion software framework, specifically an [HTTP API vulnerability in a file called SolarWinds.Orion.Core.BusinessLayer.dll](https://www.fireeye.com/blog/threat-research/2020/12/evasive-attacker-leverages-solarwinds-supply-chain-compromises-with-sunburst-backdoor.html). The exploit allowed them to execute remote ‘jobs’ on any compromised server and traverse the victim’s network using “god mode” privileges to compromise any connected server and perform data theft.
[Symantec](https://symantec-enterprise-blogs.security.com/blogs/threat-intelligence/sunburst-supply-chain-attack-solarwinds) and [Palo Alto Networks](https://unit42.paloaltonetworks.com/solarstorm-supernova/) reported that secondary payloads known as Teardrop and Supernova were deployed against “targets of interest.” Teardrop embeds the Cobalt Strike Beacon malware which attempts to steal credentials, hack Active Directory, and perform data theft.
### The Scale of the Attack
As this news only broke recently, the scale of the impact is not yet fully known, but many businesses are bracing themselves as they investigate the impact of the data breach. As of yet, no one knows exactly what data has been stolen, though the government may have some idea. This might go down as the worst cyberattack in history when the true scope of this breach and its fallout are understood.
What made this attack so insidious was the attack vector used: the SolarWinds supply chain. SolarWinds were not the end target, but they are heavily embedded in and trusted by government entities and high-profile organizations. This type of attack is known as an Advanced Persistent Threat (APT) and the method of attack is nothing more than a trojan horse; specifically, it is known as a Remote Access Trojan (RAT) because it targeted user data and company secrets.
## Recommended Actions
### Update Orion Platform
SolarWinds has identified the infected Orion updates and [published information about them here](https://www.solarwinds.com/securityadvisory). Users need to check if updated Orion Platform versions 2019.4 HF5 were installed between March and June 2020. They recommend that all Orion users should update to Orion Platform version 2020.2.1 Hot Fix 2.
### Scan for Evidence of Compromise
Users should check their networks for evidence of being compromised. Scan for two key identifiers: the use of the Teardrop in-memory malware to drop Cobalt Strike Beacon and for your organization’s hostnames. If breached, hostnames can uncover malicious IP addresses used by the attackers.
### Use a Password Manager
Atlantic.Net also offers this further advice on cybersecurity best practices: make sure you use some form of a local password manager. If you do not already, use some form of multi-factor authentication, get it installed urgently across your network. There are various options available including paid licensed versions or open source. Never use the same password throughout your organization, enforce a strict password policy, and enforce a complex password strategy.
One theory circulating concerning how the hackers managed the initial compromise posits that they achieved access by using internal usernames and passwords for SolarWinds that were found embedded into public GitHub code repositories. The “Solarwinds123” password theory may have some merit and, if true, points the finger at entrenched bad security practices inside SolarWinds.
## What to Expect Next
We can’t predict the fallout of this breach, but it is likely to have serious global ramifications. This incident will likely force US organizations to conduct a head-to-toe audit of their network environments. SolarWinds will doubtlessly lose many customers from this high-profile breach and can expect huge regulatory fines. It’s possible they may even be hit with fines for breaching GDPR, as many SolarWinds customers are located within the European Union.
We expect the US administration to revamp cybersecurity protocol in the wake of this attack, especially if it turns out to be a state-sponsored attack by Russia. The US government already has a cybersecurity platform in place that is designed to thwart this kind of attack known as [EINSTEIN 3](https://www.cisa.gov/resources-tools/resources/privacy-impact-assessment-pia-einstein-3-accelerated). It would appear this system was completely unaware of this attack.
If your business is concerned about cybersecurity, please feel welcome to reach out to Atlantic.Net. We are specialists in Managed Services, Cloud Hosting, and HIPAA Compliance. Security of our infrastructure is of paramount importance, and we work hard to ensure we have the best security processes in place. This cyberattack will go down in history as one of the worst ever, we feel concerned for our friends in the industry that might be affected by this. The clients of SolarWinds have done nothing wrong; they purchased an industry-leading server management suite from a reputable business, and now, due to unknown security incompetence, each customer has been put at risk through no fault of their own. [Get in touch today.](https://www.atlantic.net/about-us/corporate-contact/)
---
# Atlantic.Net Expands the Free G3.2GB Promo in New York and Toronto Data Centers
> URL: https://www.atlantic.net/press-releases/atlantic-net-expands-the-free-g3-2gb-promo-in-new-york-and-toronto-data-centers/ | Published: 2021-01-07 | Updated: 2024-06-11 | Author: Editorial Team
**Free G3.2GB Cloud VPS Hosting is now available in two additional data centers for one full year**
**ORLANDO, FLA. (January 7, 2021)** – [Atlantic.Net](https://www.atlantic.net/), a leading cloud services provider, expanded their offer that enables new cloud VPS customers to double their server resources at no extra cost. Atlantic.Net will upgrade all cloud plans to the capabilities of the next highest price bracket at no additional cost for new customers in their Orlando, New York, and Toronto data centers. This program also includes Atlantic.Net’s Free-to-Use for One Year Server promotion, meaning that any new free tier users will be automatically upgraded from 1GB to 2GB Cloud Server usage for one full year.
“We are pleased to have continued to assist small business with our free server offer for one full year in additional markets. This is one more way of helping the small business affected by the COVID 19 pandemic,” said Marty Puranik, CEO and Founder of Atlantic.Net. “We truly hope that this will help not only America’s small to mid-size businesses get more for less, but also our healthcare providers, who can now get audit-ready and healthcare compliant solutions for half the price!”
Initially, Atlantic.Net offered the new program in its Orlando, Florida data center, but has now expanded it to New York and Toronto, with plans to make it available at all its locations in coming weeks.
The Atlantic.Net Cloud Platform, which is engineered to provide fault-tolerant, ultra-fast performance, includes award-winning Cloud Servers, Secure Block Storage, one-click applications, DNS, dedicated private nodes, private networking, RESTful API, data backup, a full suite of managed services, 24/7/365 expert U.S.-based support, and more. This infrastructure is ideally suited to support businesses and organizations as they evolve toward a distributed remote work environment to mitigate the health risks of COVID-19 to the global workforce.
To view the latest cloud offerings and pricing structure, visit [VPS hosting](https://www.atlantic.net/vps-hosting/).
**About Atlantic.Net**
Atlantic.Net is a global [cloud services](https://www.atlantic.net/hipaa-compliant-hosting/) provider with over 25 years of experience, serving thousands of developers and small, medium, and large clients in more than one hundred countries. Atlantic.Net specializes in managed and non-managed Windows, Linux, and FreeBSD server hosting solutions and has served dynamic business clients including Lenovo, Newegg, NASA, and Hilton, among others. With a focus on security, compliance, and simplifying the user experience, Atlantic.Net provides business-class dedicated and cloud hosting solutions, backed by 24/7/365 support in New York, London, San Francisco, Toronto, Dallas, Ashburn, and Orlando. For more information, please visit [Atlantic Net/](https://www.atlantic.net/).
---
# How to Install Apache Spark on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-apache-spark-on-centos-8/ | Published: 2021-01-07 | Updated: 2023-11-22 | Author: Hitesh Jethva
Apache Spark is a data processing framework that performs processing tasks over large data sets quickly. Apache Spark can also distribute data processing tasks across several computers. It does so either on its own or in tandem with other distributed computing tools. These two qualities make it particularly useful in the world of machine learning and big data. Spark also features an easy-to-use API, reducing the programming burden associated with data crunching. It undertakes most of the work associated with big data processing and distributed computing.
## Step 1 – Install Java
Spark is a Java-based application, so you will need to install Java in your system. You can install the Java using the following command:
```
dnf install java-11-openjdk-devel -y
```
Once Java is installed, you can verify the Java version with the following command:
```
java --version
```
You should get the Java version in the following output:
```
openjdk 11.0.8 2020-07-14 LTSOpenJDK Runtime Environment 18.9 (build 11.0.8+10-LTS)
OpenJDK 64-Bit Server VM 18.9 (build 11.0.8+10-LTS, mixed mode, sharing)
```
## Step 2 – Install Spark
First, you will need to download the latest version of Spark from its official website. You can download it with the following command:
```
wget https://mirrors.estointernet.in/apache/spark/spark-3.0.1/spark-3.0.1-bin-hadoop2.7.tgz
```
Once the download is completed, extract the downloaded file with the following command:
```
tar -xvf spark-3.0.1-bin-hadoop2.7.tgz
```
Next, move the extracted directory to /opt with the following command:
```
mv spark-3.0.1-bin-hadoop2.7 /opt/spark
```
Next, create a separate user to run Spark with the following command:
```
useradd spark
```
Next, change the ownership of the /opt/spark directory to the spark user with the following command:
```
chown -R spark:spark /opt/spark
```
## Step 3 – Create a Systemd Service File for Spark
Next, you will need to create a systemd service file for the Spark master and slave.
First, create a master service file with the following command:
```
nano /etc/systemd/system/spark-master.service
```
Add the following lines:
```
[Unit]
Description=Apache Spark Master
After=network.target
[Service]
Type=forking
User=spark
Group=spark
ExecStart=/opt/spark/sbin/start-master.sh
ExecStop=/opt/spark/sbin/stop-master.sh
[Install]
WantedBy=multi-user.target
```
Save and close the file when you are finished, then create a Spark slave service with the following command:
```
nano /etc/systemd/system/spark-slave.service.service
```
Add the following lines:
```
[Unit]
Description=Apache Spark Slave
After=network.target
[Service]
Type=forking
User=spark
Group=spark
ExecStart=/opt/spark/sbin/start-slave.sh spark://your-server-ip:7077
ExecStop=/opt/spark/sbin/stop-slave.sh
[Install]
WantedBy=multi-user.target
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
## Step 4 – Start the Master Service
Now, you can start the Spark master service and enable it to start at boot with the following command:
```
systemctl start spark-master
systemctl enable spark-master
```
You can verify the status of the Master service with the following command:
```
systemctl status spark-master
```
You should get the following output:
- ```
spark-master.service - Apache Spark Master
```
```
Loaded: loaded (/etc/systemd/system/spark-master.service; disabled; vendor preset: disabled)
Active: active (running) since Fri 2020-10-02 10:40:40 EDT; 18s ago
Process: 2554 ExecStart=/opt/spark/sbin/start-master.sh (code=exited, status=0/SUCCESS)
Main PID: 2572 (java)
Tasks: 32 (limit: 12523)
Memory: 174.5M
CGroup: /system.slice/spark-master.service
└─2572 /usr/lib/jvm/java-11-openjdk-11.0.8.10-0.el8_2.x86_64/bin/java -cp
/opt/spark/conf/:/opt/spark/jars/* -Xmx1g org.apache.spar>
Oct 02 10:40:37 centos8 systemd[1]: Starting Apache Spark Master...
Oct 02 10:40:37 centos8 start-master.sh[2554]: starting org.apache.spark.deploy.master.Master,
logging to /opt/spark/logs/spark-spark-org.apac>
Oct 02 10:40:40 centos8 systemd[1]: Started Apache Spark Master.
```
You can also check the Spark log file to check the Master server.
```
tail -f /opt/spark/logs/spark-spark-org.apache.spark.deploy.master.Master-1-centos8.out
```
You should get the following output:
```
20/10/02 10:40:40 INFO Utils: Successfully started service 'MasterUI' on port 8080.
20/10/02 10:40:40 INFO MasterWebUI: Bound MasterWebUI to 0.0.0.0, and started at
http://centos8:8080
20/10/02 10:40:40 INFO Master: I have been elected leader! New state: ALIVE
```
At this point, the Spark master server is started and listening on port **8080**.
## Step 5 – Access Spark Dashboard
Now, open your web browser and access the Spark dashboard using the URL **http://your-server-ip:8080**. You should see the Spark dashboard in the following page:
In the above page, there are no workers attached to the master.
## Step 6 – Start Slave Service
Now, start the Slave service and enable it to start at boot with the following command:
```
systemctl start spark-slave
systemctl enable spark-slave
```
Next, check the status of the Slave with the following command:
```
systemctl status spark-slave
```
You should get the following output:
- ```
spark-slave.service - Apache Spark Slave
```
```
Loaded: loaded (/etc/systemd/system/spark-slave.service; disabled; vendor preset: disabled)
Active: active (running) since Fri 2020-10-02 10:45:12 EDT; 10s ago
Process: 2671 ExecStart=/opt/spark/sbin/start-slave.sh spark://45.58.32.165:7077 (code=exited,
status=0/SUCCESS)
Main PID: 2680 (java)
Tasks: 35 (limit: 12523)
Memory: 197.9M
CGroup: /system.slice/spark-slave.service
└─2680 /usr/lib/jvm/java-11-openjdk-11.0.8.10-0.el8_2.x86_64/bin/java -cp
/opt/spark/conf/:/opt/spark/jars/* -Xmx1g org.apache.spar>
Oct 02 10:45:09 centos8 systemd[1]: Starting Apache Spark Slave...
Oct 02 10:45:09 centos8 start-slave.sh[2671]: starting org.apache.spark.deploy.worker.Worker,
logging to /opt/spark/logs/spark-spark-org.apach>
Oct 02 10:45:12 centos8 systemd[1]: Started Apache Spark Slave.
```
You can also check the Spark slave log file for confirmation:
```
tail -f /opt/spark/logs/spark-spark-org.apache.spark.deploy.worker.Worker-1-centos8.out
```
You should get the following output:
20/10/02 10:45:12 INFO Worker: Spark home: /opt/spark
20/10/02 10:45:12 INFO ResourceUtils: ==============================================================
20/10/02 10:45:12 INFO ResourceUtils: Resources for spark.worker:
20/10/02 10:45:12 INFO ResourceUtils: ==============================================================
20/10/02 10:45:12 INFO Utils: Successfully started service ‘WorkerUI’ on port 8081.
20/10/02 10:45:12 INFO WorkerWebUI: Bound WorkerWebUI to 0.0.0.0, and started at http://centos8:8081
20/10/02 10:45:12 INFO Worker: Connecting to master 45.58.32.165:7077…
20/10/02 10:45:12 INFO TransportClientFactory: Successfully created connection to /45.58.32.165:7077 after 66 ms (0 ms spent in bootstraps)
20/10/02 10:45:13 INFO Worker: Successfully registered with master spark://centos8:7077
Now, go to the Spark dashboard and reload the page. You should see the worker in the following page.
You can also access the worker directly using the URL **http://your-server-ip:8081**.
## Conclusion
In this guide, you learned how to set up a single-node Spark cluster on CentOS 8. You can now configure Spark multinode cluster easily and use it for big data and machine learning processing. Set up Apache Spark on your [VPS hosting](https://www.atlantic.net/vps-hosting/) account with Atlantic.Net!
---
# How to Create an HTTP Proxy Using Squid on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-create-an-http-proxy-using-squid-on-centos-8/ | Published: 2021-01-08 | Updated: 2024-06-11 | Author: Hitesh Jethva
Squid is a free and open-source web proxy caching server that supports different protocols, such as HTTP, HTTPS, FTP, and SSL. It is mainly used as a caching proxy server and can greatly improve the server performance by caching repeated requests, filtering web traffic, and accessing geo-restricted content.
Squid can act as an intermediary between the client and web server. After connecting the Squid proxy, you will be able to anonymously access Internet services and bypass local network restrictions.
In this tutorial, we will learn how to install and configure Squid Proxy on CentOS 8.
## Step 1 – Install Squid Proxy Server
The Squid package is available in the CentOS 8 default repository. You can install it by just running the following command:
```
dnf install squid -y
```
Once installed, start the Squid proxy service and enable it to start at reboot with the following command:
```
systemctl start squid
systemctl enable squid
```
## Step 2 – Configure IP Based Authentication
There are several ways to configure Squid to accept connections and serve as an HTTP proxy. In this section, we will configure Squid to authenticate clients based on their IP addresses.
Open the Squid default configuration file at /etc/squid/squid.conf:
```
nano /etc/squid/squid.conf
```
Add the following line at the beginning of the file:
```
acl user1 src 192.168.0.10
acl user2 src 192.168.0.11
http_access allow user1 user2
```
Save and close the file when you are finished, then restart the Squid service to apply the changes:
```
systemctl restart squid
```
**In the above step, substitute your relevant information as below**:
**user1** and **user2** is the name that identifies the client computers.
**192.168.0.10** and **192.168.0.11** is the IP address of the client computer.
## Step 3 – Configure User Based Authentication
In this section, we will configure Squid to authenticate a client with usernames and passwords.
First, install the Apache utility package in your system:
```
dnf install httpd-tools -y
```
Next, create a file to store Squid users and passwords and change the ownership of the password file:
```
touch /etc/squid/squid_passwd
chown squid /etc/squid/squid_passwd
```
Next, create a new squid user with name user1 using the following command:
```
htpasswd /etc/squid/squid_passwd user1
```
You will be asked to create a password for this user as shown below:
```
New password:
Re-type new password:
Adding password for user user1
```
Next, create another user named user2 with the following command:
```
htpasswd /etc/squid/squid_passwd user2
```
Provide a password for this user as shown below:
```
New password:
Re-type new password:
Adding password for user user2
```
You can now verify both users with the following command:
```
cat /etc/squid/squid_passwd
```
You should get the following output:
```
user1:$apr1$szXO3OTj$37MuRy2V06mIAOiRpFjnr1
user2:$apr1$MCAckv0h$0VwDLLhAfMLaLm3Xvk3H/0
```
Next, edit the Squid configuration file:
```
nano /etc/squid/squid.conf
```
Add the following lines at the beginning of the file:
```
auth_param basic program /usr/lib64/squid/basic_ncsa_auth /etc/squid/squid_passwd
acl ncsa_users proxy_auth REQUIRED
http_access allow ncsa_users
```
Save and close the file, then restart the Squid proxy service to apply the changes:
```
systemctl restart squid
```
## Step 4 – Configure Combined Authentication
In this section, we will configure Squid to authenticate a client based on the IP address and username/password.
Edit the Squid default configuration file:
```
nano /etc/squid/squid.conf
```
Find the following lines which you added earlier:
```
auth_param basic program /usr/lib64/squid/basic_ncsa_auth /etc/squid/squid_passwd
acl ncsa_users proxy_auth REQUIRED
http_access allow ncsa_users
acl user1 src 192.168.0.10
acl user2 src 192.168.0.11
http_access allow user1 user2
```
And replace them with the following lines:
```
acl user1 src 192.168.0.10
acl user2 src 192.168.0.11
auth_param basic program /usr/lib64/squid/basic_ncsa_auth /etc/squid/squid_passwd
acl ncsa_users proxy_auth REQUIRED
http_access allow user1 user2 ncsa_users
```
Save and close the file, then restart the Squid proxy service to apply the changes:
```
systemctl restart squid
```
## Step 5 – Configure Squid to Anonymize Traffic
Next, you will need to add some rules to mask client IP addresses from the servers that receive traffic from your Squid HTTP proxy.
You can do it by editing the Squid default configuration file:
```
nano /etc/squid/squid.conf
```
Add the following lines at the beginning of the file:
```
forwarded_for off
request_header_access Allow allow all
request_header_access Authorization allow all
request_header_access WWW-Authenticate allow all
request_header_access Proxy-Authorization allow all
request_header_access Proxy-Authenticate allow all
request_header_access Cache-Control allow all
request_header_access Content-Encoding allow all
request_header_access Content-Length allow all
request_header_access Content-Type allow all
request_header_access Date allow all
request_header_access Expires allow all
request_header_access Host allow all
request_header_access If-Modified-Since allow all
request_header_access Last-Modified allow all
request_header_access Location allow all
request_header_access Pragma allow all
request_header_access Accept allow all
request_header_access Accept-Charset allow all
request_header_access Accept-Encoding allow all
request_header_access Accept-Language allow all
request_header_access Content-Language allow all
request_header_access Mime-Version allow all
request_header_access Retry-After allow all
request_header_access Title allow all
request_header_access Connection allow all
request_header_access Proxy-Connection allow all
request_header_access User-Agent allow all
request_header_access Cookie allow all
request_header_access All deny all
```
Save and close the file, then restart the Squid proxy service to apply the changes:
```
systemctl restart squid
```
## Step 6 – Test Squid Proxy
At this point, your Squid proxy server is configured to accept client connections based on the IP address and username/password and anonymously handle Internet traffic.
Next, you will need to configure your Client computer’s browser settings to use your Squid server as an HTTP proxy.
On the client computer, open Mozilla Firefox and click on Edit => Preferences as shown below:
Scroll down to the Network Settings section and click on **Settings**. You should see the following page:
Select the Manual proxy configuration radio button, enter your Squid server IP address in the HTTP Host field and 3128 in the Port field, select the “Use this proxy server for all protocols” check box, and click on the **OK** button to save the settings.
Now your browser is configured to browse the Internet through the Squid proxy.
To verify it, type the URL [What is my ip](https://www.whatismyip.com/). You will be asked to provide a username and password as shown below:
Provide your Squid proxy server username and password which you have created earlier and click on the **OK** button. You should see the following page:
On the above page, you should see your Squid server’s IP address IP address instead of the IP address of your client computer.
## Conclusion
In the above guide, you learned how to configure Squid as an HTTP proxy server on CentOS 8 and configure your browser to use it. You can now surf the web anonymously and keep Firefox from tracking you. Try out Squid on a [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net today!
---
# How to Install Varnish Cache with Nginx on CentOS 8
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-varnish-cache-with-nginx-on-centos-8/ | Published: 2021-01-10 | Updated: 2023-11-15 | Author: Hitesh Jethva
Varnish Cache is an HTTP accelerator and reverse proxy specially designed for heavily loaded dynamic web sites as well as APIs. It acts as a middleman between your client and server. Varnish works by handling requests before they make it to your backend. If Varnish doesn’t have a request cached, it will forward the request to your backend and then cache its output.
This process dramatically increases the performance of your web server. Varnish is famously useful and is employed by many companies such as Wired, Urban Dictionary, Zappos, Technorati, DynDNS, OpenDNS, and many more. One of the key features of Varnish is the flexibility of its configuration language (VCL) which allows you to write policies on how incoming requests should be handled.
In this tutorial, we will learn how to set up Varnish caching with Nginx on CentOS 8. We will set up Nginx to listen on port 8080 and work as a backend server, then configure Varnish to listen on default HTTP port 80.
## Step 1 – Install Varnish Cache
By default, the Varnish package is available in the CentOS 8 system. You can install it by just running the following command:
```
dnf install varnish -y
```
After installing Varnish, start the Varnish service and enable it to start after system reboot with the following command:
```
systemctl start varnish
systemctl enable varnish
```
Next, verify the status of Varnish with the following command:
```
systemctl status varnish
```
You should get the following output:
By default, Varnish listens on port **6081**. You can verify it using the following command:
```
netstat -ltnp | grep 6081
```
You should get the following output:
```
tcp 0 0 0.0.0.0:6081 0.0.0.0:* LISTEN 1508/varnishd
tcp6 0 0 :::6081 :::* LISTEN 1508/varnishd
```
## Step 2 – Install and Configure Nginx
Next, you will need to install the Nginx web server and configure it to work with the Varnish cache.
First, install the Nginx server with the following command:
```
dnf install nginx -y
```
After installing the Nginx web server, you will need to change the Nginx web server listening port from **80** to **8080**.
You can do it by editing the file /etc/nginx/nginx.conf.
```
nano /etc/nginx/nginx.conf
```
Find the following line:
```
listen 80 default_server;
listen [::]:80 default_server;
```
And replace it with the following line:
```
listen 8080 default_server;
listen [::]:8080 default_server;
```
Save and close the file, then start the Nginx service and enable it to start after system reboot:
```
systemctl start nginx
systemctl enable nginx
```
**Note:** If you are using virtual hosting, then configure the relevant configuration file.
## Step 3 – Configure Varnish to Work with Nginx
By default, Varnish is configured to listen on port 6081, so you will need to configure it to listen on port 80. You can configure it by editing varnish.service configuration file:
```
nano /usr/lib/systemd/system/varnish.service
```
Find the following line:
```
ExecStart=/usr/sbin/varnishd -a :6081 -f /etc/varnish/default.vcl -s malloc,256m
```
And replace it with the following line:
```
ExecStart=/usr/sbin/varnishd -a :80 -f/etc/varnish/default.vcl -s malloc,256m
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, restart the Varnish service to apply the changes:
```
systemctl restart varnish
```
## Step 4 – Configure Nginx as a Backend Server for Varnish
Next, you will need to configure Nginx as a backend server for the Varnish proxy.
You can configure it by editing the file /etc/varnish/default.vcl:
```
nano /etc/varnish/default.vcl
```
Check to ensure the following lines are uncommented:
```
backend default {
.host = "127.0.0.1";
.port = "8080";
}
```
Save and close the file when you are finished.
**Note:** Change the line 127.0.0.1 with your Nginx server IP address if your Nginx server resides on the other host. Change the port 8080 with the port number of your Nginx server.
## Step 5 – Verify Varnish Cache
At this point, the Varnish cache is configured to work with the Nginx webserver. It’s time to test whether caching is working or not.
You can test it using the curl command:
```
curl -I http://your-server-ip
```
You should get the HTTP header information in the following output:
Next, run this command again:
```
curl -I http://your-server-ip
```
You should get the Varnish cached response in Age header (X-Varnish):
You can also test the Varnish cache using varnishlog command with curl command to view Varnish activity as it happens:
```
varnishlog
```
You should get the following output:
## Conclusion
Congratulations! You have successfully installed and configured Varnish Cache with an Nginx web server on CentOS 8. Now your Nginx web server has a Varnish Cache server in front of it. You will need to add additional configuration to get the full benefit from it. Get started with Varnish on your Atlantic.Net [dedicated server](https://www.atlantic.net/dedicated-server-hosting/) today!
---
# What Is a VPN? Everything You Need to Know About VPNs
> URL: https://www.atlantic.net/vps-hosting/what-is-vpn/ | Published: 2021-01-11 | Updated: 2026-04-24 | Author: Richard Bailey
Most computer users have probably heard the term VPN at one time or another. Perhaps you wondered what a VPN is and why you would want to use one. Maybe you have heard that a VPN can help combat internet censorship and keep your data more secure when you want to access the Internet. You might be using a VPN now but not fully understand how it works.
In this article, we are going to tell you everything you need to know about VPNs. We’ll cover how they work, why you might want to use one, and the dangers that can present themselves if you don’t connect to the Internet via a VPN. This is especially important for those of you who make use of public Wi-Fi.
This is part of an extensive series of guides about [information security](https://www.exabeam.com/explainers/information-security/information-security-goals-types-and-applications/).
## What Is a VPN?
The acronym VPN stands for Virtual Private Network. A VPN has both a simple working explanation and a slightly more complex technical definition. From the perspective of a user, a VPN is a method of ensuring the security and privacy of their online activity. You can browse websites without worrying about being tracked by third parties.
When you use a VPN, IP addresses are hidden from everyone by the VPN provider (or your server that you created as a VPN node). Your computer’s IP address is its public identifier. You are essentially anonymous from everyone but the aforementioned parties and can therefore maintain a high degree of privacy – however, note that you can still be tracked if the VPN provider keeps track of your records.
When using a VPN, your data may also encrypted so it cannot be compromised by malicious users who may have access to the communication network, depending on the VPN you choose. Encrypting your Internet traffic makes it unusable to anyone without the encryption key. In this way, the VPN offers enhanced security when data is transferred over an Internet connection.
The technology behind a VPN is fairly straightforward. A secure point-to-point connection is established between a remote client and a VPN server. The IP addresses of the client computers are masked and replaced with IP addresses provided by the VPN server. The data to be transferred and the original IP header is encapsulated and encrypted.
A new IP header is added that allows access to the desired public network so the data can be transferred. Using the services of a VPN provider protects the identity of the client machine by hiding its IP address from the Internet and encrypting the information to safeguard it from unauthorized access. Let’s dig further into the details of how a VPN works.
## VPN Components
Three components are required to establish a VPN. They work together to provide a virtual private network over which your data can flow safely and securely.
### VPN Client
A VPN client is a computer or device that uses a VPN, or virtual private network, to obtain Internet access. In addition to desktop and laptop computers, devices such as smartphones and tablets that can access the Internet can benefit from a VPN connection. There are three basic types of VPN clients available.
- **Standalone VPN clients** require software to be installed on both endpoints of the connection. Using a commercial VPN product involves downloading and installing the client code on the device that connects to the VPN provider. Most consumer VPN solutions involve standalone clients on each customer’s machine.
- Most modern **operating systems have built-in VPN clients** that enable connectivity to be established with a remote VPN server if it uses the same VPN protocol. This type of VPN is commonly found in a corporate environment, as it is not easily configured by end-users.
- **Open source VPNs** are also available for a wide variety of operating systems. The advantages of an open-source solution are that it is free and the code can be modified to meet specific requirements.
### VPN Server
A VPN server accepts connections from VPN clients and is responsible for transforming the data packets sent from the clients into a form that can be distributed on the Internet or a local private network. Replies generated from the connected network are sent to the VPN server which in turn sends them back to the client or endpoint.
VPN servers can be physical or virtual machines that run specialized software to accomplish their tasks. The software handles communication between the server and its clients. It also performs encryption and decryption of transferred data packets. An important component of a VPN server’s software is the VPN protocol used to construct a secure tunnel through which information is transferred.
### VPN Protocols
VPN protocols are also referred to as tunneling protocols. The tunneling analogy comes from the way the VPN protects your data when you connect to the Internet. You can visualize the protection as a tunnel wrapped around your data that keeps it safe and away from prying eyes. The tunnel is formed by the masking of IP addresses and the encryption of transmitted data.
The tunnel is only as strong as the VPN protocol that is used to construct it. There are [many different VPN protocols](https://www.techradar.com/vpn/vpn-tunnels-explained-how-to-keep-your-internet-data-secure) in use that offer different levels of functionality. Here is an overview of some of the most used tunneling protocols to set up a VPN.
- **PPTP** – Point to Point Tunneling Protocol is one of the oldest protocols still in use by VPNs. It is an easy protocol to configure and only requires a username, password, and server address to establish a connection. PPTP furnishes fast connection speeds but provides a low level of encryption, making it unsuitable if you need reliable data security. Atlantic.Net does not recommend using PPTP as it is at end-of-life due to numerous security vulnerabilities.
- **SSTP** – Secure Socket Tunneling Protocol is a Windows-based protocol that transports data using Secure Sockets Layer (SSL). It is more secure than PPTP, but is limited to use with Windows machines. The fact that it does not use fixed ports makes it harder to stop SSTP connections with firewalls.
- **L2TP/IPSec** – Layer 2 Tunneling Protocol (L2TP) is used together with Internet Protocol Security (IPSec) to create a more secure connection than PPTP. The protocols provide two layers of encryption for additional protection. Strong AES-256 bit encryption is used, but fixed ports make it easier to block connections using this protocol. It is also slower than some other VPN protocols due to the double data encapsulation it performs.
- **OpenVPN** – This open-source VPN protocol also uses strong AES-256 bit encryption to protect data transmission. It can be complicated to configure, but once in place, OpenVPN can keep data safe, establish fast connections, and avoid detection from firewalls. Due to the interest of the security community, the tool is always being reviewed for potential vulnerabilities.
The choice of VPN protocol can have a substantial impact on your online activity. In some cases, you may have to balance connection speed with encryption strength. Protocols that use fixed ports can be detected by firewalls, which may limit the functionality of the VPN and affect your ability to reach sites that offer products such as streaming services. Your specific needs should be considered when selecting a VPN provider and it’s worth looking at which VPN protocol they use.
## Types of VPNs
A virtual private network can be implemented in multiple ways. A key characteristic is that both endpoints in the connection need to use the same VPN protocol.
- In a **remote client** implementation, a public network is used to connect to a private local network. The remote users have a VPN client installed that can connect to a VPN gateway on the local network. An example of this type of implementation is a business VPN that allows workers to access sensitive corporate information remotely.
- A **site-to-site VPN** enables a private network connection to be established between two sites without the need for software to be installed on all clients. Each site is connected to a VPN server which handles all clients on its end and acts as the endpoint for communication from the second site. End-users need to be connected to the VPN gateway so local network traffic can be sent through an encrypted tunnel to the alternate site.
- In a **client-to-provider**virtual private network implementation, the user needs VPN client software installed and configured to enable a connection to a VPN provider’s servers. The connection establishes a secure tunnel to the service provider. The provider receives data packets which it then encapsulates and forwards to the Internet. The VPN connection is only between the client and the server. It does not extend to the destination website. This type of VPN is very common for addressing privacy concerns and can create a secure connection when using public WiFi which is notoriously unsecured.
Each kind of VPN implementation has its uses in certain scenarios. Most individuals who are using a VPN to protect their browsing activity will use the client-to-provider method. All it requires is the installation of client software which is used to create a secure VPN connection to the provider. Remote client and site-to-site VPNs require a greater level of configuration and administration.
## What Are the Benefits of a VPN?
Many advantages come with using a VPN to connect to the Internet. Some of them straddle the line between legitimate and illegitimate forms of online activity. In some cases, the use of a VPN may be morally acceptable by society yet prohibited by a government or corporation. Here are some of the benefits of using a VPN service to provide a secure and private Internet connection.
- Using a VPN conceals your private information from websites and applications that track your online movement. The encryption capabilities of the chosen VPN will enable you to conduct secure communications and transactions over the Internet even when connected to WiFi hotspots, say, at your local coffee shop. This can be a very important factor in nations with repressive regimes that limit the ability of their citizens to freely communicate among themselves without fear of reprisal. In such cases, a secure VPN may be the only way to safely discuss sensitive subjects.
- Access to blocked websites is another common reason for connecting to a VPN. Geoblocking is the practice of restricting access to specific websites based on the location of the potential client computer. [Websites may be geoblocked based on the part of the world in which you live](https://www.geoawesomeness.com/this-map-shows-which-countries-censor-the-internet-today/). A computer’s location is determined by its IP address, and by using a VPN, the IP is modified, making it impossible to tell the origin of a request to access the Internet. This fact allows you to gain access to sites that are geoblocked in your area with the help of a VPN service.
- Corporate VPNs are commonly used to provide workers access to sensitive data from their home office or any other remote location. This will usually be in the form of a remote client implementation where the user will not be able to access the requested resources if they are not connecting through the VPN. Using a corporate encryption standard ensures the safety of enterprise data assets and can be instrumental in preventing a data breach.
## Disadvantages of Using a VPN
There are disadvantages that you should be aware of before using a VPN. In some cases, there can be serious consequences involved with using a VPN in the wrong places. Usually, the benefits or necessity of using a VPN will outweigh any disadvantages you may encounter. Here are some factors to consider when using a VPN to enable your Internet traffic.
- The use of a VPN is illegal in some countries. You should understand the laws in the country or jurisdiction in which you will establish a VPN connection. This is where the concept of Internet freedom and the law clash with each other. Using a VPN may be the only way to obtain information in authoritarian regimes that tightly control Internet access, but it can be extremely dangerous to get caught. In this situation, using a VPN is a personal decision that should not be taken lightly.
- Using a VPN may result in slower Internet speeds. This is due to the rerouting that is necessary to spoof IP addresses and the processing cycles required for the encryption and decryption of data packets.
- Configuration of the VPN client may be required, and this may be beyond the level of computer expertise of the average user.
- Tracking of online activity performed by the VPN provider may be a problem with some VPN services. Check out the privacy policies of your VPN provider before engaging in any activities that you wish to keep anonymous. Ensure that logs are not retained of user activity that may negate the benefits of masking IP addresses. Consider setting up [your own VPN](https://www.atlantic.net/vps-hosting/how-to-set-up-wireguard-vpn-on-centos-8/) to avoid this.
## When Should I Use a VPN?
Many situations that require some degree of privacy when users connect to the Internet can benefit from using a VPN service. Here are some examples of usage scenarios where the secure connection of a VPN is necessary or privacy concerning the websites you visit is desired.
In the business world, the use of a VPN is often mandatory for remote workers who need to access a corporate private network. This will most likely be in the form of a remote site VPN. Employees access their worksite by connecting to a VPN that is configured to enable the required level of access through an encrypted tunnel to protect enterprise data assets.
Internet censorship is a problem that manifests itself in many ways. The use of a VPN service provider can get around many of the restrictions that are placed on your web activity. A virtual private network spoofs IP addresses so your location cannot be determined when you open an Internet connection. This will allow you to subvert geoblocking and censorship strategies that are implemented in your locale.
Public WiFi is offered in many establishments as an enticement to customers. Unfortunately, the WiFi connection you are using in a hotel, airport, restaurant, or other facility is probably not secure. Hackers may have compromised the local network and have access to your unencrypted data. You should always use a VPN when accessing the internet from public WiFi, even if you are not transferring sensitive data.
## Conclusion
The use of a VPN can address privacy and data security issues that accompany certain types of online activity. Maintaining an anonymous presence on the Internet will help reduce unwanted advertising and enable you to access sites that may be blocked by your ISP. Keeping your data encrypted is always a good idea to protect it from misuse by malicious individuals. In most cases, the advantages of a VPN make its use an easy decision.
If you are in the market for a VPS, Atlantic.Net offers [VPS Hosting](https://www.atlantic.net/vps-hosting/) at eight international locations.
## See Additional Guides on Key Information Security Topics
Together with our content partners, we have authored in-depth guides on several other topics that can also be useful as you explore the world of [information security](https://www.exabeam.com/explainers/information-security/information-security-goals-types-and-applications/).
### [API Security](https://checkmarx.com/learn/api-security/ultimate-guide-to-api-security/)
*Authored by Checkmarx*
- [[Guide] Ultimate guide to API Security 2024](https://checkmarx.com/learn/api-security/ultimate-guide-to-api-security/)
- [[Guide] API Security Best Practices – How To Secure APIs In Your Environment](https://checkmarx.com/learn/api-security/api-security-best-practices/)
### [Application Security](https://checkmarx.com/glossary/application-security-appsec/)
*Authored by Checkmarx*
- [[Guide] What is Application Security – How Does It Work & Best Practices](https://checkmarx.com/glossary/application-security-appsec/)
- [[Guide] What is SQL Injection + Examples](https://checkmarx.com/glossary/sql-injection/)
- [[Guide] Malicious code and how to prevent it](https://checkmarx.com/learn/supply-chain-security/malicious-code-guide/)
### [SAST](https://checkmarx.com/glossary/static-application-security-testing-sast/)
*Authored by Checkmarx*
- [[Guide] What is SAST? Static Application Security Testing Meaning](https://checkmarx.com/glossary/static-application-security-testing-sast/)
- [[Guide] CVS Static Code Analysis](https://checkmarx.com/learn/sast/effective-static-source-code-analysis/)
- [[Guide] Open-Source Vs. Premium SAST Tools](https://checkmarx.com/learn/sast/open-source-vs-premium-sast-tools/)
##### **VPN Resources:**
[Atlantic.Net – VPN Connection Guide](https://www.atlantic.net/vps-hosting/atlantic-net-vpn-connection-guide/)
[How to Set Up WireGuard VPN on CentOS 8](https://www.atlantic.net/vps-hosting/how-to-set-up-wireguard-vpn-on-centos-8/)
[How to Install and Configure strongSwan VPN on Ubuntu 18.04](https://www.atlantic.net/vps-hosting/how-to-install-and-configure-strongswan-vpn-on-ubuntu/)
[Do I need a VPN?](https://www.atlantic.net/hipaa-compliant-hosting/do-i-need-a-vpn/)
[Censorship Workarounds: VPN as a Service and Other VM Options](https://www.atlantic.net/vps-hosting/censorship-workarounds-vpn-as-a-service-and-other-vm-options/)
[Censorship Workarounds: How to Set Up a VPN – Part 2](https://www.atlantic.net/vps-hosting/censorship-workarounds-part-2-how-to-set-up-a-vpn/)
---
#### Read More About Remote Management and VPNs
- [VPS vs VPN](https://www.atlantic.net/vps-hosting/vps-vs-vpn-similar-names-but-completely-different-functions/)?
- Best [Remote Management Tools](https://www.atlantic.net/vps-hosting/top-10-remote-management-tools/)
---
---
# Atlantic.Net Technology Wins 2021 BIG Innovation Award
> URL: https://www.atlantic.net/press-releases/atlantic-net-technology-wins-2021-big-innovation-award/ | Published: 2021-01-12 | Updated: 2026-03-02 | Author: Editorial Team
ORLANDO, FLA—January 12, 2021—Atlantic.Net has been named a winner in the [2021 BIG Innovation Awards](https://www.bintelligence.com/big-innovation-awards), presented by the Business Intelligence Group.
Atlantic.Net was awarded the BIG Innovation Award for 2021 for its technological solutions in the cloud, especially for the healthcare vertical.
“More than ever, the global society relies on innovation to help progress humanity and make our lives more productive, healthy, and comfortable,” said Maria Jimenez, chief operating officer of the Business Intelligence Group. “We are thrilled to be honoring Atlantic.Net as they are one of the organizations leading this charge and helping humanity progress.”
Organizations from across the globe submitted their recent innovations for consideration in the BIG Innovation Awards. Nominations were then judged by a select group of business leaders and executives who volunteer their time and expertise to score submissions.
**About Atlantic.Net**
Atlantic.Net is a global [cloud services](https://www.atlantic.net/hipaa-compliant-hosting/) provider with over 25 years of experience, serving thousands of developers and small, medium, and large clients in more than one hundred countries. Atlantic.Net specializes in managed and non-managed Windows, Linux, and FreeBSD server hosting solutions and has served dynamic business clients including Lenovo, Newegg, NASA, and Hilton, among others. With a focus on security, compliance, and simplifying the user experience, Atlantic.Net provides business-class dedicated and cloud hosting solutions, backed by 24/7/365 support in New York, London, San Francisco, Toronto, Dallas, Ashburn, and Orlando. For more information, please visit [Atlantic.Net](https://www.atlantic.net/).
About **Business Intelligence Group**
The [Business Intelligence Group](https://www.bintelligence.com/what-we-do/) was founded with the mission of recognizing true talent and superior performance in the business world. Unlike other [industry award programs](https://www.bintelligence.com/awards-deadlines/), these programs are judged by business executives having experience and knowledge. The organization’s proprietary and unique scoring system selectively measures performance across multiple business domains and then rewards those companies whose achievements stand above those of their peers.
**Contacts**
Atlantic.Net
[pr@atlantic.net](mailto:pr@atlantic.net)
+1(321) 206-1371
Maria Jimenez
Chief Operating Officer
Business Intelligence Group
[jmaria@bintelligence.com](mailto:jmaria@bintelligence.com)
+1 (909) 529-2737
---
# The SolarWinds Hack’s Impact on the US Software Supply Chain
> URL: https://www.atlantic.net/vps-hosting/solarwinds-orion-hack-part-2/ | Published: 2021-01-12 | Updated: 2025-02-07 | Author: Richard Bailey
*Atlantic.Net is providing this security advisory as a news item; we want to reassure our customers that Atlantic.Net does not use any SolarWinds products internally or in any of our service offerings.*
Businesses, organizations, and government institutions are reeling from the fallout of the SolarWinds hack. The story of this far-reaching security breach broke around the 14th of December 2020, and even now we do not know the full impact of the incident. Every day we learn more of the extent of this unprecedented supply chain cyberattack.
## About the SolarWinds Hack
What we do know is that in March 2020, [hackers beached SolarWinds’ computer infrastructure](https://www.solarwinds.com/securityadvisory) and gained control of the SolarWinds content management servers. In April 2020, the bad actors embedded sophisticated malware inside ‘genuine’ digitally signed SolarWinds updates.
The affected updates were the automated updates that client computers look up when downloading security patches and hotfixes for SolarWinds’ Orion applications. This widely trusted software update practice is used by countless tech companies around the globe.
For the SolarWinds customers that downloaded and installed the poisoned update, the hackers used the compromised update to inject a malware payload called SUNBURST into compromised customer servers. The malware apparently stayed dormant for about 2 weeks, likely to evade detection, before being activated by a [command and control site](https://www.microsoft.com/security/blog/2020/12/18/analyzing-solorigate-the-compromised-dll-file-that-started-a-sophisticated-cyberattack-and-how-microsoft-defender-helps-protect/) (C2) using subdomains gathered by the malware.
### How Long Did the Attack Go Undetected?
Security experts believe the [malware lay dormant from April until July 2020](https://www.theguardian.com/technology/2020/dec/16/solarwinds-orion-hack-scrutiny-technology) , hiding in plain sight, and many believe this period was used for target reconnaissance by the threat actors to identify the highest value targets. While we don’t know what data was compromised, we do know Office 365 data is likely to have been breached, potentially from OneDrive, Word documents, Sharepoint sites, and so on.
The list of high profile victims grows daily. Some of the biggest names in technology and government are known to have been breached. Many security experts speculate that the attack was orchestrated by Russia, a view supported by a joint statement released by the FBI, CISA, ODNI, and NSA claiming that [the bad actors were likely Russian](https://www.cisa.gov/news-events/news/joint-statement-federal-bureau-investigation-fbi-cybersecurity-and-infrastructure) .
The CISA was so concerned by the breach that on the 14th of December, it ordered all nonmilitary government systems that were running the SolarWinds Orion software to be [shut down and disconnected](https://www.lawfareblog.com/solarwinds-breach-why-your-work-computers-are-down-today) from the network.
## What Is a Supply Chain Attack?
A **Supply Chain Attack** is a security incident that occurs when a malicious actor infiltrates a target’s system by exploiting an outside partner or service provider to gain unauthorized access to the systems and data files of the target.
Global businesses are more connected now than ever in history. Cloud computing and the Internet have provided the tools to allow businesses to share large amounts of confidential business data quickly. As a normal practice, businesses buy software and hardware from one another to improve their own offerings to their customers. In this supply chain attack, businesses, global organizations, and US government institutions purchased the SolarWinds Orion Network Management System to gain insights about their networks.
The real victims of the hack are not SolarWinds, but the 18,000 customers who never expected to be victims of a sophisticated hack that they had no control over, a hack that may turn out to be potentially the biggest cyberattack in history, and an attack that may lead to dramatic changes in cybersecurity.
A supply chain attack blows cybersecurity controls wide open. The victims were following cybersecurity best practices by ensuring that their platforms were updated to the latest release; they did not know that their technology provider, SolarWinds, had been infiltrated by suspected Russian hacking squads that had poisoned updates to infect the entire supply chain.
## Who Was Targeted in the Supply Chain Attack?
Our picture of this hack is changing all the time as the story unfolds, and we may not know the full extent of the hack for many months to come. But we do know that the US government has been significantly impacted. There are reports that the [US Treasury,](https://www.bankinfosecurity.com/us-treasury-suffers-significant-solarwinds-breach-a-15641) the [US Department of State](https://www.bbc.co.uk/news/technology-55318815) , the [CISA](https://www.scmagazine.com/home/security-news/updated-cisa-directive-discovers-saml-token-abuse-around-solarwinds-hack-calls-for-full-rebuild-of-affected-networks/) , the [DOE](https://www.utilitydive.com/news/doe-confirms-its-systems-were-compromised-by-solarwinds-hack/592441/) were targeted.
### How It Happened
While the exact details are not known, one theory is that each government office used Office 365 and Exchange for email and that the shared keys for Azure Active Directory were compromised, potentially allowing the attackers to masquerade as genuine users to access email systems and document libraries.
This theory is supported by statements released by the [Department of Justice](https://www.justice.gov/opa/pr/department-justice-statement-solarwinds-update) that “this activity involved access to the Department’s Microsoft O365 email environment” and “the number of potentially accessed O365 mailboxes appears limited to around 3 percent and we have no indication that any classified systems were impacted.”
### Who Was Impacted
Of the many tech giants targeted, we know that among the victims were networking powerhouse Cisco Systems, CPU manufacturer Intel, GPU makers NVIDIA Corp., and the tech heavyweights VMware, Microsoft and Belkin. Doubtless many more companies have been impacted, but it will be weeks or months until the full picture is known.
## Next Steps
If your business is concerned about cybersecurity, please feel welcome to reach out to Atlantic.Net. We are specialists in Managed Services, Cloud Hosting, and HIPAA compliance. The security of our infrastructure is of paramount importance, and we work hard to ensure we have the best security processes in place.
This cyberattack will go down in history as one of the worst, and we feel concerned for our friends in the industry that might be affected by this. The clients of SolarWinds have done nothing wrong; they purchased an industry-leading server management suite from a reputable business, and now, due to unknown security incompetence, each customer has been put at risk through no fault of their own. [Get in touch today. ](https://www.atlantic.net/about-us/corporate-contact/)
---
# Announcement: Meet Our Customer Service Champion for 2020: Sam G.
> URL: https://www.atlantic.net/announcements/meet-our-customer-service-champion-for-2020-sam-g/ | Published: 2021-01-12 | Updated: 2025-09-19 | Author: Alexander Wise
Sam G. was awarded our Customer Service Champion for the year 2020!
Sam G., our Senior Account Executive – Major Accounts, has been with the company since 2003, and his favorite part of working here is that every day is different and exciting. He also likes meeting the challenge of helping customers to join and trust Atlantic.Net; Sam feels that a long-term business relationship is very rewarding. He also enjoys creating personal relationships with fellow A-listers (the rest of the Atlantic.Net Team) where he is trusted to do his job and to impart that trust to the people he works with.
Sam says he is grateful for the award and feels that caring for customers is what he does best. He also feels very lucky to have a great place to work and people he loves to work with!
Congrats Sam and thank you for all you do. Being an outside sales representative during a pandemic isn’t easy, and we appreciate all your hard work since 2003!
---
# How to Install React.js on Ubuntu 20.04
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-react-js-on-ubuntu-20-04/ | Published: 2021-01-15 | Updated: 2024-01-18 | Author: Hitesh Jethva
React is an open-source JavaScript library used for building interactive user interfaces for web and mobile applications. It uses a virtual browser to act as an agent between a developer and a real browser. React was created and is maintained by Facebook, but is now used by many companies around the world. React consists of compiled HTML, CSS, and JavaScript files and is often used as a frontend for more complex applications.
In this tutorial, we will show you how to deploy React.js on Ubuntu 20.04.
## Step 1 – Install Nodejs
React App is a JavaScript library, so Node.js must be installed in your server. By default, the latest version of Node.js is not available in the Ubuntu standard repository, so you will need to install it from NodeSource.
First, install the necessary dependencies using the following command.
```
apt-get install -y ca-certificates curl gnupg
```
Next, download the Node.js GPG key.
```
mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
```
Next, add the NodeSource repo to the APT source list.
```
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_18.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
```
Then, update the repository index and install the Ndoe.js with the following command.
```
apt update
apt-get install -y nodejs
```
Once Node.js is installed, update the NPM to the latest version using the following command:
```
npm install npm@latest -g
```
You can now verify the installed version of Node.js with the following command:
```
node -v
```
You should get the following output:
```
v18.19.0
```
## Step 2 – Create a New Reactjs App
First, you will need to install the create-react-app tool to create a new project in React. You can install it using the following command:
```
npm install -g create-react-app
```
You should get the following output:
```
/usr/bin/create-react-app -> /usr/lib/node_modules/create-react-app/index.js
+ create-react-app@4.0.1
added 67 packages from 25 contributors in 3.605s
```
Next, create a new project with the following command:
```
create-react-app awesome-project
```
You should see the following output:
```
Success! Created awesome-project at /root/awesome-project
Inside that directory, you can run several commands:
npm start
Starts the development server.
npm run build
Bundles the app into static files for production.
npm test
Starts the test runner.
npm run eject
Removes this tool and copies build dependencies, configuration files
and scripts into the app directory. If you do this, you can’t go back!
We suggest that you begin by typing:
cd awesome-project
npm start
Happy hacking!
```
Once your project is created, change the directory to your project and start the application with the following command:
```
cd awesome-project
npm start
```
You should get the following output:
```
Compiled successfully!
You can now view awesome-project in the browser.
http://localhost:3000
Note that the development build is not optimized.
To create a production build, use npm run build.
```
Press **CTRL+C** to stop the application.
## Step 3 – Create a Systemd Service File for React App
Next, you will need to create a systemd service file to manage the React service. You can create it with the following command:
```
nano /lib/systemd/system/react.service
```
Add the following lines:
```
[Service]
Type=simple
User=root
Restart=on-failure
WorkingDirectory=/root/awesome-project
ExecStart=npm start -- --port=3000
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the React service and enable it to start at system reboot:
```
systemctl start react
systemctl enable react
```
You can verify the status of the React service with the following command:
```
systemctl status react
```
You should get the following output:
- ```
react.service
```
```
Loaded: loaded (/lib/systemd/system/react.service; static; vendor preset: enabled)
Active: active (running) since Sun 2020-12-06 10:11:04 UTC; 5s ago
Main PID: 18556 (node)
Tasks: 30 (limit: 4691)
Memory: 170.0M
CGroup: /system.slice/react.service
├─18556 npm
├─18583 sh -c react-scripts start "--port=3000"
├─18584 node /root/awesome-project/node_modules/.bin/react-scripts start --port=3000
└─18591 /usr/bin/node /root/awesome-project/node_modules/react-scripts/scripts/start.js --
port=3000
Dec 06 10:11:04 ubuntu2004 systemd[1]: Started react.service.
Dec 06 10:11:04 ubuntu2004 npm[18556]: > awesome-project@0.1.0 start /root/awesome-project
Dec 06 10:11:04 ubuntu2004 npm[18556]: > react-scripts start "--port=3000"
Dec 06 10:11:07 ubuntu2004 npm[18591]: ℹ ｢wds｣: Project is running at http://0.0.0.0:3000/
Dec 06 10:11:07 ubuntu2004 npm[18591]: ℹ ｢wds｣: webpack output is served from
Dec 06 10:11:07 ubuntu2004 npm[18591]: ℹ ｢wds｣: Content not from webpack is served from
/root/awesome-project/public
Dec 06 10:11:07 ubuntu2004 npm[18591]: ℹ ｢wds｣: 404s will fallback to /
Dec 06 10:11:07 ubuntu2004 npm[18591]: Starting the development server...
```
## Step 4 – Configure Nginx as a Reverse Proxy
At this point, your React App is started and listening on port 3000. Next, you will need to configure Nginx as a reverse proxy to access the React App through port 80.
First, install the Nginx web server with the following command:
```
apt-get install nginx -y
```
Once installed, create a new Nginx virtual host configuration file:
```
nano /etc/nginx/conf.d/react.conf
```
Add the following lines:
```
upstream react_backend {
server localhost:3000;
}
server {
listen 80;
server_name react.example.com;
location / {
proxy_pass http://react_backend/;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forward-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forward-Proto http;
proxy_set_header X-Nginx-Proxy true;
proxy_redirect off;
}
}
```
Save and close the file then restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 5 – Access Reactjs Web UI
Now, open your web browser and access the React App using the URL **http://react.example.com**. You should see your React Application in the following screen:
## Conclusion
Congratulations! You have successfully installed and deployed React App with Nginx as a reverse proxy on Ubuntu 20.04. You can now start exploring React App for more features. Try out React.js on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to Install Rundeck on CentOS 8
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-rundeck-on-centos-8/ | Published: 2021-01-16 | Updated: 2023-11-15 | Author: Hitesh Jethva
Rundeck is a free and open-source tool used for managing multiple servers from a single server. Written in Java programming language, Rundeck provides a web-based interface to perform all administrative tasks. It uses a MySQL/MariaDB database to store the job definitions and execution history. Rundeck comes with a lot of tools that make it easier for you to scale up your automation efforts.
In this tutorial, we will show you how to install Rundeck on CentOS 8.
## Step 1 – Install Java
Rundeck is written in Java, so Java must be installed in your system. If not installed, you can install it with the following command:
```
dnf install java -y
```
After installing Java, you can verify the installed version of Java using the following command:
```
java -version
```
You should see the following output:
```
openjdk version "1.8.0_262"
OpenJDK Runtime Environment (build 1.8.0_262-b10)
OpenJDK 64-Bit Server VM (build 25.262-b10, mixed mode)
```
## Step 2 – Install and Configure MySQL
Rundeck uses a MySQL database to store the job and other history, so you will need to install MySQL on your server. You can install it with the following command:
```
dnf install mysql-server -y
```
Once installed, start the MySQL service and enable it to start at system reboot with the following command:
```
systemctl start mysqld
systemctl enable mysqld
```
Next, you will need to create a database and user for Rundeck. First, log into the MySQL shell with the following command:
```
mysql
```
Once logged in, create a database and user with the following command:
```
create database rundeck;
create user 'rundeckuser'@'localhost' identified by 'rundeckpassword';
```
Next, grant all the privileges to the Rundeck database with the following command:
```
grant ALL on rundeck.* to 'rundeckuser'@'localhost';
```
Next, flush the privileges and exit from MySQL with the following command:
```
flush privileges;
exit;
```
## Step 3 – Install Rundeck
By default, Rundeck is not available in the CentOS 8 default repository, so you will need to add Rundeck repository to your system.
First, import the Rundeck GPG key with the following command:
```
rpm --import http://rundeck.org/keys/BUILD-GPG-KEY-Rundeck.org.key
```
Next, add the Rundeck repository with the following command:
```
dnf install -y http://repo.rundeck.org/latest.rpm
```
Next, install Rundeck by running the following command:
```
dnf install rundeck -y
```
Once Rundeck is installed, you can proceed to the next step.
## Step 4 – Configure Rundeck
Next, you will need to define your server address and database details in the Rundeck configuration file. Edit the Rundeck default configuration file as shown below:
```
nano /etc/rundeck/rundeck-config.properties
```
Change the following lines:
```
grails.serverURL=http://your-server-ip:4440
dataSource.dbCreate = update
dataSource.url = jdbc:mysql://localhost/rundeck?autoReconnect=true&useSSL=false&serverTimezone=UTC
dataSource.username=rundeckuser
dataSource.password=rundeckpassword
dataSource.driverClassName=com.mysql.jdbc.Driver
```
Save and close the file when you are finished, then start the Rundeck server and enable it to start at system reboot with the following command:
```
systemctl enable rundeckd
systemctl start rundeckd
```
You can now verify the status of the Rundeck service with the following command:
```
systemctl status rundeckd
```
You should get the following output:
## Step 5 – Access Rundeck Web Interface
At this point, Rundeck is started and listening on port 4440. Now, open your web browser and type the URL http://your-server-ip:4440. You will be redirected to the Rundeck login page:
Provide the default username as **admin** and password as **admin** and click on the **Log** **In** button. You should see the Rundeck dashboard in the following page:
Next, click on the **New** **Project** button to create a new project. You should see the following page:
Provide your project name, label, and description and click on the **Create** button. You should see the following page:
Click on the **Commands** in the left pane. You should see the following page:
Type the command “free -m” and click on the “**Run on 1 Node**“. This will execute the command on the localhost and display the output of the command as shown in the following page:
## Conclusion
In this guide, we learned how to install Rundeck and integrate it with the MySQL database on CentOS 8. We have also created a new project and execute commands with Rundeck. For more information about Rundeck, visit the Rundeck [documentation](https://docs.rundeck.com/docs/). If you’re ready to try Rundeck, get started on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net.
---
# How To Install RethinkDB on CentOS 8
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-rethinkdb-on-centos-8/ | Published: 2021-01-17 | Updated: 2024-08-15 | Author: Hitesh Jethva
RethinkDB is a free and open-source No-SQL database manager that can be used in applications that require continuous access to data. It has very minimal response times and updates and supports the most popular languages, including PHP, Java, Ruby, and Python. RethinkDB is designed with automatic failover and robust fault tolerance. It uses a new database access model instead of polling for changes. RethinkDB also offers a built-in web interface to manage the database.
In this tutorial, we will show you how to install RethinkDB on CentOS 8.
## Step 1 – Install RethinkDB
By default, RethinkDB is not available in the CentOS 8 default repository, so you will need to install it from the RPM package. You can run the following command to download and install the RethinkDB RPM package in your system.
Once installed, you should get the following output:
## Step 2 – Configure RethinkDB
First, you will need to copy RethinkDB sample configuration file with the following command:
```
cp /etc/rethinkdb/default.conf.sample /etc/rethinkdb/instances.d/instance1.conf
```
Next, edit the configuration file using the following command:
```
nano /etc/rethinkdb/instances.d/instance1.conf
```
Change the following lines to enable the RethinkDB web console:
```
http-port=8080
server-name=server1
directory=/var/lib/rethinkdb/default
log-file=/var/log/rethinkdb
bind=0.0.0.0
```
Save and close the file when you are finished. Next, create the necessary files and provide proper permissions with the following command:
```
touch /var/log/rethinkdb
chown -R rethinkdb:rethinkdb /var/log/rethinkdb /var/lib/rethinkdb
chmod -R 775 /var/log/rethinkdb /var/lib/rethinkdb
```
Now, start the RethinkDB service and enable it to start at system reboot with the following command:
```
systemctl enable --now rethinkdb
systemctl start rethinkdb
```
You can now verify the status of the RethinkDB service with the following command:
```
systemctl status rethinkdb
```
You should get the following output:
## Step 3 – Access RethinkDB Web Interface
Now, open your web browser and access RethinkDB using the URL http://your-server-ip:8080. You should see the following page:
Now, click on the **Tables** button. You should see the following page:
Click on the **Add** **Database** button. You should see the following page:
Provide your database name and click on the **Add** button. You should see your database in the following page:
## Conclusion
Congratulations! You have successfully installed RethinkDB on CentOS 8. You can now easily use RethinkDB to build your large-scale applications. For more information, visit the RethinkDB official [documentation](https://rethinkdb.com/docs). Install RethinkDB on your Atlantic.Net [dedicated server](https://www.atlantic.net/dedicated-server-hosting/) today.
---
# How to Install and Configure OpenVPN Server on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-and-configure-openvpn-server-on-ubuntu-20-04/ | Published: 2021-01-19 | Updated: 2023-11-22 | Author: Hitesh Jethva
OpenVPN is an open-source VPN solution for businesses that use virtual private network techniques to create secure point-to-point connections with remote access facilities. OpenVPN is a trusted technology used by many VPNs to make sure any data sent over the internet is encrypted and private.
In simple terms, OpenVPN allows you to connect to other devices within one secure network. It is cross-platform and can be Windows, Mac, Android, iOS, and Linux. OpenVPN offers a rich set of features including:
- Unlimited Bandwidth
- Unlimited Server Switches
- Multi-Device Usage
- No Log Storage
- Protocol Choices
- Multiple Concurrent Connections
In this tutorial, we will learn how to install and configure the OpenVPN server and client on an Ubuntu 20.04 VPS.
## Step 1: Enable IP Forwarding
First, you will need to enable IP forwarding in your system so that OpenVPN can correctly route traffic through the VPN.
You can enable IP forwarding by editing the file /etc/sysctl.conf:
```
nano /etc/sysctl.conf
```
Uncomment the following line:
```
net.ipv4.ip_forward = 1
```
Save the file when you are finished, then run the following command to apply the changes:
```
sysctl -p
```
## Step 2: Install OpenVPN Server
By default, the OpenVPN package is available in Ubuntu 20.04, so you can install it by just running the following command:
```
apt-get install openvpn -y
```
Once the installation has been completed, you can proceed to the next step.
## Step 3: Build the Certificate Authority
To set up the certificate authority and PKI infrastructure, you will need to download EasyRSA in your system. You can download it with the following command:
```
wget https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.6/EasyRSA-unix-v3.0.6.tgz
```
Once downloaded, extract the downloaded file with the following command:
```
tar -xvzf EasyRSA-unix-v3.0.6.tgz
```
Next, move the extracted directory to the /etc/openvpn/ with the following command:
```
mv EasyRSA-v3.0.6 /etc/openvpn/easy-rsa
```
Next, change the directory to /etc/openvpn/easy-rsa and create a EasyRSA configuration file:
```
cd /etc/openvpn/easy-rsa
nano vars
```
Add the following lines including your country, city, and preferred email address:
```
set_var EASYRSA "$PWD"
set_var EASYRSA_PKI "$EASYRSA/pki"
set_var EASYRSA_DN "cn_only"
set_var EASYRSA_REQ_COUNTRY "INDIA"
set_var EASYRSA_REQ_PROVINCE "Gujarat"
set_var EASYRSA_REQ_CITY "Junagadh"
set_var EASYRSA_REQ_ORG "Atlantic CERTIFICATE AUTHORITY"
set_var EASYRSA_REQ_EMAIL "admin@atlantic.net"
set_var EASYRSA_REQ_OU "Atlantic EASY CA"
set_var EASYRSA_KEY_SIZE 2048
set_var EASYRSA_ALGO rsa
set_var EASYRSA_CA_EXPIRE 7500
set_var EASYRSA_CERT_EXPIRE 365
set_var EASYRSA_NS_SUPPORT "no"
set_var EASYRSA_NS_COMMENT "Atlantic CERTIFICATE AUTHORITY"
set_var EASYRSA_EXT_DIR "$EASYRSA/x509-types"
set_var EASYRSA_SSL_CONF "$EASYRSA/openssl-easyrsa.cnf"
set_var EASYRSA_DIGEST "sha256"
```
Save the file when you are finished.
Next, initiate the PKI directory using the following command:
```
./easyrsa init-pki
```
You should get the following output:
```
Note: using Easy-RSA configuration from: ./vars
init-pki complete; you may now create a CA or requests.
Your newly created PKI dir is: /etc/openvpn/easy-rsa/pki
```
Next, build the CA certificates with the following command:
```
./easyrsa build-ca
```
You should get the following output:
```
Note: using Easy-RSA configuration from: ./vars
Using SSL: openssl OpenSSL 1.1.1f 31 Mar 2020
Enter New CA Key Passphrase:
Re-Enter New CA Key Passphrase:
Generating RSA private key, 2048 bit long modulus (2 primes)
.....................................................................................................+++++
..................................................+++++
e is 65537 (0x010001)
Can't load /etc/openvpn/easy-rsa/pki/.rnd into RNG
139636302492992:error:2406F079:random number generator:RAND_load_file:Cannot open file:../crypto/rand/randfile.c:98:Filename=/etc/openvpn/easy-rsa/pki/.rnd
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields, there will be a default value,
If you enter '.', the field will be left blank.
-----
Common Name (eg: your user, host, or server name) [Easy-RSA CA]:
CA creation complete and you may now import and sign cert requests.
Your new CA certificate file for publishing is at:
/etc/openvpn/easy-rsa/pki/ca.crt
```
The above command will generate two files named ca.key and ca.crt. These certificates will be used to sign your server and clients’ certificates.
## Step 4: Create Server Certificate Files
Next, you will need to generate a keypair and certificate request for your server.
Run the following command to generate the server key named atlantic-server:
```
./easyrsa gen-req atlantic-server nopass
```
You should see the following output:
```
Note: using Easy-RSA configuration from: ./vars
Using SSL: openssl OpenSSL 1.1.1f 31 Mar 2020
Generating a RSA private key
.............................+++++
...+++++
writing new private key to '/etc/openvpn/easy-rsa/pki/private/atlantic-server.key.IMonKybM0y'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Common Name (eg: your user, host, or server name) [atlantic-server]:
Keypair and certificate request completed. Your files are:
req: /etc/openvpn/easy-rsa/pki/reqs/atlantic-server.req
key: /etc/openvpn/easy-rsa/pki/private/atlantic-server.key
```
This will generate a private key and a certificate request file for the server.
## Step 5: Sign the Server Key Using CA
Next, you will need to sign the atlantic-server key using your CA certificate:
You can sign the server key using the following command:
```
./easyrsa sign-req server atlantic-server
```
You should see the following output:
```
Note: using Easy-RSA configuration from: ./vars
Using SSL: openssl OpenSSL 1.1.1f 31 Mar 2020
You are about to sign the following certi
ficate.
Please check over the details shown below for accuracy. Note that this request
has not been cryptographically verified. Please be sure it came from a trusted
source or that you have verified the request checksum with the sender.
Request subject, to be signed as a server certificate for 365 days:
subject=
commonName = atlantic-server
Type the word 'yes' to continue, or any other input to abort.
Confirm request details: yes
Using configuration from /etc/openvpn/easy-rsa/pki/safessl-easyrsa.cnf
Enter pass phrase for /etc/openvpn/easy-rsa/pki/private/ca.key:
Check that the request matches the signature
Signature ok
The Subject's Distinguished Name is as follows
commonName :ASN.1 12:'atlantic-server'
Certificate is to be certified until Jun 29 11:43:05 2021 GMT (365 days)
Write out database with 1 new entries
Data Base Updated
Certificate created at: /etc/openvpn/easy-rsa/pki/issued/atlantic-server.crt
```
Next, verify the generated certificate file with the following command:
```
openssl verify -CAfile pki/ca.crt pki/issued/atlantic-server.crt
```
You should get the following output:
```
pki/issued/atlantic-server.crt: OK
```
Next, run the following command to generate a strong Diffie-Hellman key to use for the key exchange:
```
./easyrsa gen-dh
```
You should get the following output:
```
Note: using Easy-RSA configuration from: ./vars
Using SSL: openssl OpenSSL 1.1.1f 31 Mar 2020
Generating DH parameters, 2048 bit long safe prime, generator 2
This is going to take a long time
......................+...........................+............................................
DH parameters of size 2048 created at /etc/openvpn/easy-rsa/pki/dh.pem
```
After creating all certificate files, copy them to the /etc/openvpn/server/ directory:
```
cp pki/ca.crt /etc/openvpn/server/
cp pki/dh.pem /etc/openvpn/server/
cp pki/private/atlantic-server.key /etc/openvpn/server/
cp pki/issued/atlantic-server.crt /etc/openvpn/server/
```
## Step 6: Generate Client Certificate and Key File
Next, you will need to create the key and certificate file for the client.
First, run the following command to build the client key file:
```
./easyrsa gen-req client nopass
```
You should get the following output:
```
Note: using Easy-RSA configuration from: ./vars
Using SSL: openssl OpenSSL 1.1.1f 31 Mar 2020
Generating a RSA private key
...+++++
........+++++
writing new private key to '/etc/openvpn/easy-rsa/pki/private/client.key.JmBal6cmr8'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Common Name (eg: your user, host, or server name) [client]:
Keypair and certificate request completed. Your files are:
req: /etc/openvpn/easy-rsa/pki/reqs/client.req
key: /etc/openvpn/easy-rsa/pki/private/client.key
```
Next, sign the client key using your CA certificate:
```
./easyrsa sign-req client client
```
You should get the following output:
```
Note: using Easy-RSA configuration from: ./vars
Using SSL: openssl OpenSSL 1.1.1f 31 Mar 2020
You are about to sign the following certificate.
Please check over the details shown below for accuracy. Note that this request
has not been cryptographically verified. Please be sure it came from a trusted
source or that you have verified the request checksum with the sender.
Request subject, to be signed as a client certificate for 365 days:
subject=
commonName = client
Type the word 'yes' to continue, or any other input to abort.
Confirm request details: yes
Using configuration from /etc/openvpn/easy-rsa/pki/safessl-easyrsa.cnf
Enter pass phrase for /etc/openvpn/easy-rsa/pki/private/ca.key:
Check that the request matches the signature
Signature ok
The Subject's Distinguished Name is as follows
commonName :ASN.1 12:'client'
Certificate is to be certified until Jun 29 11:46:58 2021 GMT (365 days)
Write out database with 1 new entries
Data Base Updated
Certificate created at: /etc/openvpn/easy-rsa/pki/issued/client.crt
```
Next, copy all client certificates and key files to the /etc/openvpn/client/ directory:
```
cp pki/ca.crt /etc/openvpn/client/
cp pki/issued/client.crt /etc/openvpn/client/
cp pki/private/client.key /etc/openvpn/client/
```
## Step 7: Configure OpenVPN Server
At this point, all certificates and key files are ready. Next, create a new OpenVPN configuration file inside /etc/openvpn/ directory:
```
nano /etc/openvpn/server.conf
```
Add the following lines per your certificate and key path:
```
port 1194
proto udp
dev tun
ca /etc/openvpn/server/ca.crt
cert /etc/openvpn/server/atlantic-server.crt
key /etc/openvpn/server/atlantic-server.key
dh /etc/openvpn/server/dh.pem
server 10.8.0.0 255.255.255.0
push "redirect-gateway def1"
push "dhcp-option DNS 208.67.222.222"
push "dhcp-option DNS 208.67.220.220"
duplicate-cn
cipher AES-256-CBC
tls-version-min 1.2
tls-cipher TLS-DHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-RSA-WITH-AES-256-
CBC-SHA256:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-128-
CBC-SHA256
auth SHA512
auth-nocache
keepalive 20 60
persist-key
persist-tun
compress lz4
daemon
user nobody
group nogroup
log-append /var/log/openvpn.log
verb 3
```
Save the file when you are finished, then start the OpenVPN service and enable it to start after the system reboot using the following command:
```
systemctl start openvpn@server
systemctl enable openvpn@server
```
Run the following command to verify the status of OpenVPN service:
```
systemctl status openvpn@server
```
You should get the following output:
- ```
openvpn@server.service - OpenVPN connection to server
```
```
Loaded: loaded (/lib/systemd/system/openvpn@.service; disabled; vendor preset: enabled)
Active: active (running) since Mon 2020-06-29 11:48:25 UTC; 7s ago
Docs: man:openvpn(8)
https://community.openvpn.net/openvpn/wiki/Openvpn24ManPage
https://community.openvpn.net/openvpn/wiki/HOWTO
Main PID: 2868 (openvpn)
Status: "Initialization Sequence Completed"
Tasks: 1 (limit: 2353)
Memory: 2.0M
CGroup: /system.slice/system-openvpn.slice/openvpn@server.service
└─2868 /usr/sbin/openvpn --daemon ovpn-server --status /run/openvpn/server.status 10 --cd /etc/openvpn --script-security 2 --conf>
Jun 29 11:48:25 vpnserver systemd[1]: Starting OpenVPN connection to server...
Jun 29 11:48:25 vpnserver systemd[1]: Started OpenVPN connection to server.
```
Once the OpenVPN service has started successfully, it will create a new network interface named tun0. You can verify it with the following command:
```
ip a show tun0
```
You should get the new interface tun0 in the following output:
```
4: tun0: mtu 1500 qdisc fq_codel state
UNKNOWN group default qlen 100
link/none
inet 10.8.0.1 peer 10.8.0.2/32 scope global tun0
valid_lft forever preferred_lft forever
inet6 fe80::5f83:99a:30d:eb0/64 scope link stable-privacy
valid_lft forever preferred_lft forever
```
## Step 8: Create Client Configuration File
Next, you will need to create an OpenVPN client configuration file named client.ovpn. You will need this file to connect your OpenVPN server from the client system.
```
nano /etc/openvpn/client/client.ovpn
```
Add the following lines:
```
client
dev tun
proto udp
remote your-vpn-server-ip 1194
ca ca.crt
cert client.crt
key client.key
cipher AES-256-CBC
auth SHA512
auth-nocache
tls-version-min 1.2
tls-cipher TLS-DHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-RSA-WITH-AES-256-
CBC-SHA256:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-128-
CBC-SHA256
resolv-retry infinite
compress lz4
nobind
persist-key
persist-tun
mute-replay-warnings
verb 3
```
Save the file when you are finished.
## Step 9: Install and Configure OpenVPN Client
Next, you will need to install OpenVPN on the client system and connect to the OpenVPN server.
First, log in to the client machine and install the OpenVPN package with the following command:
```
apt-get install openvpn -y
```
Next, you will need to copy the OpenVPN client configuration files from the OpenVPN server to the client machine.
On the client machine, run the following command to download all the client configuration files:
```
scp -r root@vpn-server-ip:/etc/openvpn/client .
```
Once all files are copied, change the directory to the client and run the following command to connect to the OpenVPN server:
```
cd client
openvpn --config client.ovpn
```
Once you are connected to the OpenVPN server, you should see the following output:
```
Jun 29 11:48:27 2020 TCP/UDP: Preserving recently used remote address:
[AF_INET]69.87.218.145:1194
Jun 29 11:48:27 2020 Socket Buffers: R=[212992->212992] S=[212992->212992]
Jun 29 11:48:27 2020 UDP link local: (not bound)
Jun 29 11:48:27 2020 UDP link remote: [AF_INET]69.87.218.145:1194
Jun 29 11:48:27 2020 TLS: Initial packet from [AF_INET]69.87.218.145:1194, sid=6d27e1cb
524bd8cd
Jun 29 11:48:27 2020 VERIFY OK: depth=1, CN=Easy-RSA CA
Jun 29 11:48:27 2020 VERIFY OK: depth=0, CN=atlantic-server
Jun 29 11:48:27 2020 Control Channel: TLSv1.3, cipher TLSv1.3 TLS_AES_256_GCM_SHA384,
2048 bit RSA
Jun 29 11:48:27 2020 [atlantic-server] Peer Connection Initiated with
[AF_INET]69.87.218.145:1194
Jun 29 11:48:27 2020 SENT CONTROL [atlantic-server]: 'PUSH_REQUEST' (status=1)
Jun 29 11:48:27 2020 PUSH: Received control message: 'PUSH_REPLY,redirect-gateway
def1,dhcp-option DNS 208.67.222.222,dhcp-option DNS 208.67.220.220,route 10.8.0.1,topology
net30,ping 20,ping-restart 60,ifconfig 10.8.0.6 10.8.0.5,peer-id 0,cipher AES-256-GCM'
Jun 29 11:48:27 2020 OPTIONS IMPORT: timers and/or timeouts modified
Jun 29 11:48:27 2020 OPTIONS IMPORT: --ifconfig/up options modified
Jun 29 11:48:27 2020 OPTIONS IMPORT: route options modified
```
After a successful connection, OpenVPN will assign an IP address to your system. You can check it with the following command:
```
ip a show tun0
```
Output:
```
4: tun0: mtu 1500 qdisc fq_codel state
UNKNOWN group default qlen 100
link/none
inet 10.8.0.6 peer 10.8.0.5/32 scope global tun0
valid_lft forever preferred_lft forever
inet6 fe80::7226:57b1:f101:313b/64 scope link stable-privacy
valid_lft forever preferred_lft forever
```
You can also check the OpenVPN server log to verify the connection status using the following command:
```
tail -f /var/log/openvpn.log
```
## Conclusion
Congratulations! You have successfully set up a VPN server with OpenVPN on an Ubuntu 20.04 [VPS](https://www.atlantic.net/vps-hosting/). You can now access the internet securely and protect your identity, location, and traffic. Visit the [OpenVPN](https://openvpn.net/community-resources/reference-manual-for-openvpn-2-4/) official documentation for more information.
---
# How to Find a Data Center for Edge Computing Colocation
> URL: https://www.atlantic.net/orlando-colocation-hosting-data-center/how-to-find-a-data-center-for-edge-computing-colocation/ | Published: 2021-01-19 | Updated: 2024-09-24 | Author: Richard Bailey
Organizations have begun to unlock [edge computing](https://www.ibm.com/cloud/what-is-edge-computing)’s potential to provide them with a competitive advantage over market rivals or improve the functionality of distributed Internet-of-Things (IoT) systems.
## What Is Edge Computing?
Edge computing is akin to an extension of, or improvement to, the power inherent to cloud computing. By bringing computing power closer to data sources, edge computing can provide better system response time and more efficient bandwidth usage.
The idea behind edge computing is to process and act on data as closely as physically possible to where the data is created. Edge computing is a strategy to address the constantly growing volume of data generated by connected devices; the huge volume of data is challenging to efficiently transmit and process in centralized cloud data centers. As businesses and consumers move to 5G networks and beyond, the amount of data will only continue to increase.
### How Edge Computing Empowers IoT Devices
The prevalence of IoT implementations and smart devices drives the growth in data and introduces new information streams that need to be efficiently collected and processed. As enterprises struggle to effectively use available data resources, processing them via an edge computing solution becomes an attractive alternative to in-house or traditional cloud data centers.
One of the factors that makes edge computing possible is the advancement of artificial intelligence technology in endpoint devices like security cameras, smartphones, and equipment used in industrial automation systems. These devices can perform preprocessing or sorting of data to minimize the amount of data that needs to be transmitted to more powerful computing environments.
## The Benefits of Edge Computing
Organizations can expect to achieve [multiple advantages](https://www.forbes.com/sites/bernardmarr/2020/09/16/3-advantages-and-1-disadvantage-of-edge-computing/?sh=8f17a4afc71a) when implementing an edge computing approach. These benefits may make the difference between a viable distributed or IoT system and a system that is destined to fail. One of the primary reasons that organizations use colocated data centers is to speed up data transmission.
- **Latency** is a big problem with transferring large amounts of data to cloud data centers. Slow data transfer and response is tolerable under certain circumstances, such as the short delays in the response of a smartphone’s virtual assistant. In more time-sensitive scenarios, latency must be reduced to achieve the system’s desired functionality. Sensors responsible for real-time traffic control systems or autonomous vehicles cannot tolerate the time spent sending waiting for results based on data sent to the cloud.
- **Bandwidth** is like latency in this regard: for certain use cases, the network resources must be available to satisfy system requirements, and bandwidth can be a limiting factor. In edge computing, the critical and most important data can be preprocessed and handled more efficiently without putting excessive demands on bandwidth. The remaining data can be transmitted to the cloud later for further analysis.
- **Security** is enhanced by reducing the volume of data traveling over a network, thereby limiting the possibility of access by unauthorized actors. Having data distributed on multiple devices also eliminates the risk of a single point of failure that can cripple a sy Minimizing the distance data travels also reduces the number of routers the transmission must traverse, each of which is a potential security risk.
The power in edge computing comes from bringing compute capabilities closer to the data rather than insisting on data being processed in a centralized data center. Logically, this means having hardware and software resources situated near the endpoint devices.
This means that every organization wishing to make use of computing capabilities effectively needs a data center located near its end-users or systems. Providers are addressing this need through edge colocation offerings that connect devices located at the edge of the network to more extensive computing resources.
## Essential Components of an Edge Computing Data Center
Companies that wish to make productive use of edge computing need to find the right partner unless they plan to build a dedicated colocation infrastructure. In most cases, this is unnecessary, and organizations will be better served by identifying a partner in their location that can provide the required resources.
Many edge data centers are in secondary markets that lack access to more extensive colocation facilities. Their offerings are designed to appeal to local enterprises that need a bridge between their edge devices and the power of larger cloud infrastructure. In some cases, all processing can be done at the edge data center without the need to access more substantial resources.
Size is not a defining factor for edge data centers. They can vary in size from a single antenna and server to an extensive infrastructure rivaling traditional data centers to meet specific customer requirements. Before entering into an agreement with a provider of edge computing data center services, customers should investigate the following essential components of the prospective provider:
- The location of an edge data center is one of its most defining characteristics. To address the requirements of real-time processing involved in autonomous factories and smart city implementations, the data center needs to be located near the endpoint devices whose data it will service. One of the primary [benefits of edge computing](https://xailient.com/blog/a-comprehensive-guide-to-edge-ai/#Edge_AI_Unlocks_Many_Benefits_for_End_Users) is reducing latency, which is facilitated by limiting the distance between devices and the data center.
- The capability for customers to perform data filtering is necessary to limit the amount of information transferred to larger data centers or the cloud. This helps address the issues of high latency or insufficient bandwidth that plague edge computing implementations. Critical data should be processed rapidly, while less time-sensitive data can be transferred so it can be used for business analytics.
- Cutting-edge technology is mandatory for an edge data center. At a minimum, it must have the infrastructure and space to support its’ customers 5G networking requirements. While 5G promises incredible data transfer speeds, its coverage area per antenna is greatly reduced. This implies that many antennas will be needed to adequately cover a given area. A reliable edge computing data center provider will need to be willing to provide the space, power, and cooling resources to enable customers to install 5G equipment.
## Atlantic Net’s Orlando Data Center
If you are looking for an edge computing colocation partner in the Orlando area, you need to consider the capabilities offered by Atlantic.Net. We offer state-of-the-art edge computing capabilities to Orlando organizations at our [Orlando Colocation](https://www.atlantic.net/orlando-colocation-hosting-data-center/) Data Center. Our secure and reliable collocation platforms are designed to meet the needs of all types of bandwidth-intensive businesses.
Some of the features that set Atlantic.Net apart from its competitors include:
- Our carrier-neutral facility has multiple redundant connections to the Internet backbone to ensure your data is transported over the fastest route. In the event of a carrier outage, traffic is redirected using alternate carriers.
- Infrastructure is immediately available for customers with no waiting period required as with some other providers. Atlantic offers Dedicated Internet Access (DIA) through a blended solution for customers who don’t want to use their own carrier so they can get up and running quickly.
- We offer 100% uptime SLAs for network and infrastructure so customers can be confident that their systems will always be accessible.
- The [Orlando data center](https://www.atlantic.net/orlando-colocation-hosting-data-center/)’s hosting infrastructure is fully audited and is certified to be AICPA SOC 2 and SOC 3 compliant.
- The facility is protected by redundant temperature and humidity controls as well as a backup generator that can serve 100% of customer peak load.
- Our fully customizable and secure colocation hosting lets your business obtain the exact resources it needs and can seamlessly scale as your business grows.
- Dark fiber connections are available, as well as roof space for 5G or satellite antennas, and our partnerships with fiber providers allow customers to minimize the deployment time.
Edge computing can provide businesses with competitive or operational advantages. As opportunities for computing at the edge of the network increase, it becomes more evident that robust implementations require collaborative partnerships that make the best use of all available technology. Atlantic.Net offers organizations a reliable partner with which to reap the benefits of edge computing.
---
# How to Reset a MySQL Root Password
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-reset-a-mysql-root-password/ | Published: 2021-01-20 | Updated: 2024-09-25 | Author: Hitesh Jethva
MySQL is a free, open-source, and widely used database management system. It is very popular for web application software. MySQL has a root password that allows a user to perform all database-related tasks.
If you are a system administrator responsible for managing a MySQL server, then you may often need to set or reset the MySQL root password – for example, if you forgot the MySQL root password or want to change the password for security reasons.
In this tutorial, we will show how to set, change, or reset the MySQL root password in Ubuntu 18.04.
## Step 1 – Set the MySQL Password for the First Time
When you install the MySQL server for the first time, a MySQL root password is not set. You can connect to the MySQL shell without providing a password, but this is not recommended for security reasons.
To set the MySQL root password, connect to the MySQL shell with the following command:
```
mysql
```
Once connected, change the database to mysql using the following command:
```
use mysql;
```
Next, set the MySQL root password with the following command:
```
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'secure-
password';
```
Next, flush the privileges and exit from the MySQL shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
Next, verify the MySQL by logging in with the root user:
```
mysql -u root -p
```
You will be prompted to enter the newly configured password to connect to the MySQL shell.
## Step 2 – Change the MySQL Root Password
The easiest way to change the MySQL root password is with mysql_secure_installation script.
```
mysql_secure_installation
```
You will be asked to provide your current MySQL root password as shown below:
```
Securing the MySQL server deployment.
Enter password for user root:
```
Provide your MySQL root password and hit **Enter**. You should see the following output:
```
Select “No”
```
You will then be prompted to change the **root**password. Select **YES.**
** **
```
Estimated strength of the password: 100
Change the password for root ? ((Press y|Y for Yes, any other key for No) : Y
```
Type **Y** and hit **Enter** to proceed. You will be asked to provide new password as shown below:
```
New password:
Re-enter new password:
```
Provide your new password, hit **Enter**, and complete the remaining steps as shown below:
```
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y
Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y
Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y
Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y
Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y
```
You can also change the MySQL root password with the following command:
```
mysqladmin -u root -p password your-new-password
```
You will be asked to provide your current root password to change the password.
## Step 3 – Recover Forgotten MySQL Root Password
If you forgot the MySQL root password, then you will need to recover it.
To recover the MySQL root password, first stop the MySQL service using the following command:
```
systemctl stop mysql
```
Next, create a mysqld directory and give proper permissions with the following command:
```
mkdir -p /var/run/mysqld
chown mysql:mysql /var/run/mysqld
```
Next, start the MySQL service with the –skip-grant-tables:
```
mysqld_safe --skip-grant-tables &
```
This will allow you to connect the MySQL server without a password.
Next, log in to MySQL with the root user as shown below:
```
mysql -u root
```
After login, change the database to mysql as shown below:
```
use mysql;
```
Next, reset your root password with the following command:
```
UPDATE mysql.user SET authentication_string = PASSWORD('new-password') WHERE User =
'root' AND Host = 'localhost';
```
Next, reload the privileges and exit from the MySQL shell with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
Next, stop the MySQL service with the following command:
```
mysqladmin -u root -p shutdown
```
You will be asked to provide your new password to stop the MySQL service.
Next, start the MySQL service again with the following command:
```
systemctl start mysql
```
Next, log in to MySQL with your new password as shown below:
```
mysql -u root -pnew-password
```
Once logged in, you should see the following output:
## Conclusion
In the above guide, you learned how to set, update, and recover the MySQL root password on an Ubuntu 18.04 server. This guide should work with Ubuntu 18.04, Debian 10 and CentOS 8. If you are ready to try resetting your MySQL password, get started on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net.
---
# Top 10 HIPAA Web Conference Software Companies
> URL: https://www.atlantic.net/hipaa-compliant-hosting/top-10-hipaa-web-conference-software-companies/ | Published: 2021-01-20 | Updated: 2025-08-03 | Author: Dr. Rachael Bailey
Web conferencing software is nothing new and, in some industries, it has been a valuable tool for decades. However, as much of the world’s workforce has shifted to working from home in 2020, video conferencing has transformed from a helpful supporting technology for businesses into an essential tool across the workforce that is keeping the majority of businesses up and running.
Within the healthcare industry, telemedicine enables healthcare providers to improve their patient reach, reduce costs, maximize time, improve emergency response, and improve overall health outcomes. Thanks to technological advances, video conferencing software has now become accessible for businesses of any size.
## What makes a Web Conference Software Company HIPAA-compliant?
With the [recent massive increase in telehealth appointments](https://www.cdc.gov/mmwr/volumes/69/wr/mm6943a3.htm) as a result of the current global pandemic, healthcare providers must ensure that sensitive patient data is protected. Healthcare professionals should make certain that they are using a fully HIPAA and/or HITECH-compliant web conferencing service.
To ensure HIPAA compliance when choosing a video conferencing tool, it is advisable that healthcare professionals:
1. Verify that the web conference software company offers a Business Associate Agreement (BAA)
2. Choose a provider that offers end-to-end encryption
3. Check that your provider has completed a relevant risk assessment to ensure compliance
4. Ensure that web conferencing software implements the necessary access controls, making sure that video calls are password protected
5. Make sure that the chosen software has detailed auditing trails in place
6. Confirm that the telemedicine software features user authentication
7. Ensure that all application executables are digitally signed to ensure data integrity
## Choosing a HIPAA-Compliant Web Conference Software Company
While there are hundreds of web conferencing tools available, there are subtle differences between these solutions. Below we have highlighted some of the top HIPAA-compliant web conferencing services:
1. Let’s Talk Interactive
2. Doxy.me
3. Zoom for Healthcare
4. TheraNest
5. thera-LINK
6. GoToMeeting
7. Medici
8. Mend
9. SimplePractice
10. VSee
## 1. Let’s Talk Interactive
[Let’s Talk Interactive](https://letstalkinteractive.com/) is a leading provider of HIPAA-compliant telehealth technology solutions, facilitating over three million minutes of remote telehealth sessions each month. They deliver a customizable and user-friendly web conferencing platform, ensuring high levels of security and full HIPAA compliance. Compatible with any operating system, browser, or mobile phone, this company’s cloud-based telehealth platform can be used by medical organizations, ranging from solo practitioners to hospital networks.
## 2. Doxy.me
Doxy.me is a highly popular cloud-based web conferencing solution that is fully compliant with HIPAA, GDPR, PHIPA/PIPEDA, and HITECH standards. Doxy.me provides healthcare professionals with a free, simple, and easily accessible interface, requiring no download of software thanks to its browser-based platform. Users can benefit from a fully customizable virtual patient queue, a live chat function, and a BAA across all accounts. High-quality HD video and audio ensures that healthcare providers and their patients have a positive virtual experience.
## 3. Zoom for Healthcare
The popularity of Zoom has risen rapidly during the global coronavirus pandemic. Despite being used primarily by businesses, Zoom also offers a plan aimed specifically at the healthcare industry. Zoom for Healthcare offers a HIPAA-compliant video conferencing solution for healthcare providers that includes a signed BAA. Zoom for Healthcare can successfully integrate with medical devices, such as medical cameras and digital stethoscopes, as well as a patient’s electronic health record (EHR).
## 4. TheraNest
TheraNest is a HIPAA-compliant web-based practice management software tool for the mental health sector. This software is used by therapists, counselors, social workers, and psychologists in educational, non-profit, individual, and large health organizations. Patients can join a scheduled meeting simply by using a unique invite link with no need to download any additional software. This EHR solution offers clients storage for patient information, insurance billing tools, and calendar scheduling, with HIPAA-compliant telehealth video conferencing an additional useful feature available for an extra cost.
## 5. thera-LINK
thera-LINK is a video conferencing solution that is targeted specifically at professionals working within the mental and behavioral health sector, providing them with an essential tool for both one-to-one and group therapy sessions. All video conferencing sessions are fully secured and encrypted to ensure the safety of PHI. thera-LINK incorporates important security features including end-to-end encryption and secure file sharing.
## 6. GoToMeeting
GoToMeeting provides web-hosted face-to-face video conferencing to businesses and professionals. Powered by LogMeIn, GoToMeeting offers a specific, easy-to-use web conferencing platform for healthcare professionals. The software fully supports HIPAA compliance by offering clients a comprehensive BAA and providing robust security measures, such as meeting locks, access codes, and invite-only restrictions. GoToMeeting offers clients a choice of three plans – professional, business, and enterprise, and unlike many competitors, all of these plans are HIPAA compliant.
## 7. Medici
Medici provides medical professionals with a HIPAA-compliant telehealth mobile app. A striking feature of this software is the ability to import patient contact information into the Medici app directly from a supported EHR. Medici’s platform implements robust security standards, with SOC2 Type 2, HIPAA, and VcPR compliance. Using this platform, patients can choose between three secure consultation options: text, voice, or HD video.
## 8. Mend
Mend is a comprehensive integrated telehealth and patient engagement platform. Mend allows integration with EHR services and access to numerous patient communication tools. Mend enables healthcare professionals and patients to make a secure connection with just the click of a link, enabling the sharing of videos, files, photos, messages, and data. PredictiveIQ AI can be used to predict missed appointments and automated appointment reminders can also be set up. Mend meets all HIPAA requirements while providing patients and healthcare providers with a friendly and easy-to-use interface.
## 9. SimplePractice
SimplePractice offers healthcare organizations bank-level encryption to ensure that sensitive patient data remains secure, anonymous, and private during telemedical appointments. Using SimplePractice, patients are able to access meetings from anywhere using just a link and can even share information with their healthcare professionals prior to their appointment. Incorporating many useful features, SimplePractice’s offer of insurance processing distinguishes it from many of its competitors.
## 10. VSee
With over 10 years of experience within the healthcare sector, VSee offers an all-in-one platform that provides its users with easy-to-use HIPAA-compliant video conferencing and remote patient monitoring. VSee enables healthcare professionals to connect with their patients in between appointments, as well as offering the ability to integrate with popular medical devices. VSee securely encrypts all audio and video communication and provides users with a BAA.
## How Can Atlantic.Net Help?
Atlantic.Net is a global cloud service provider with over 30 years of industry-leading experience. We have very many happy healthcare clients that leverage Atlantic.Net services for a robust and scalable HIPAA-compliant hosting solution that can integrate directly with your telehealth applications.
We can provide turn-key hosting solutions that include encrypted VPN connectivity, perfect if your medical organization opts for a cloud-based SaaS web conferring solution. We encrypt peer-to-peer connections and implement access controls in line with HIPAA safeguard recommendations.
Our world-class HIPAA hosting facilities can power your healthcare infrastructure, giving you the performance needed to build your own teleconferencing solution on our platform. We have detailed instructions on how to install [Let’s Chat](https://www.atlantic.net/vps-hosting/how-to-install-lets-chat-on-an-ubuntu-20-04/) or [Rocket.Chat](https://www.atlantic.net/vps-hosting/how-to-deploy-rocket-chat-with-nginx-on-ubuntu-18-04/) securely on our HIPAA infrastructure.
If you are a healthcare provider in the market for a secure HIPAA compliant cloud hosting service, [contact our sales team](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) to find out how Atlantic.Net can help you.
---
# Top 10 DSP Providers
> URL: https://www.atlantic.net/vps-hosting/top-10-dsp-providers/ | Published: 2021-01-21 | Updated: 2024-08-16 | Author: Dr. Rachael Bailey
A Demand-Side Platform (DSP) is a web-based platform that allows media buyers to purchase digital ad inventory from multiple sources through a single interface. As a part of the Programmatic Advertising ecosystem, the DSP acts as a central repository, integrating with ad exchanges and other sources, such as SSPs (Supply Side Platform). By acting as a middleman between publishers and media buyers, DSPs help to streamline the process of ad buying, making it significantly cheaper, quicker, and more efficient.
DSPs automate media buying activities by using intelligent software to analyze ad impressions and make informed bids in real-time. This allows advertisers, brands, and agencies to target adverts to their tailored audiences.
Are you in the market for a DSP? With hundreds of DSPs on the market, we have compiled a list of our top 10 DSP providers. Our list considers their available inventory, targeting capabilities, reporting analytics, and anti-fraud measures.
1. The Trade Desk
2. MediaMath
3. Adobe Advertising Cloud DSP
4. Amazon DSP
5. StackAdapt
6. Adform
7. Brightroll
8. Google Display and Video 360
9. AppNexus
10. Adelphic
## 1. The Trade Desk
The Trade Desk is an industry-leading independent DSP provider, helping media buyers to improve their reach across every channel and device all around the world. With access to a marketplace of over 225 partners, The Trade Desk provides its clients with the data management platform necessary to ensure that all media buying decisions are guided by real-time insights. The Trade Desk API can hook straight into client systems streamlining application integration. The Trade Desk has partnered with White Ops, an industry-leading cybersecurity firm, to scan and block fraudulent impressions before purchase.
## 2. MediaMath
MediaMath’s TerminalOne is a responsive and fully customizable media buying platform designed to improve a [brand’s reach](https://brand24.com/blog/online-presence-score/) and influence. MediaMath provides its clients with access to hundreds of integrated data, media, and technology providers. Like The Trade Desk, TerminalOne also allows media buyers to control the features of the digital advertising platform using APIs. Committed to transparency and honesty, MediaMath’s TerminalOne has partnered with White Ops and use White Ops Human Verification Technology to block sophisticated invalid traffic (SIVT) and fraudulent impressions.
## 3. Adobe Advertising Cloud DSP
Adobe’s DSP offering, Adobe Advertising Cloud DSP, delivers cross-screen and cross-channel integrations, allowing media buyers to purchase, measure, and optimize their ad campaigns. As Adobe Advertising Cloud is natively integrated with Adobe Analytics, brands and agencies can target their advertising more efficiently through analysis of DSP performance metrics.
## 4. Amazon DSP
Amazon DSP, previously known as Amazon Advertising Platform (AAP), allows media buyers to target audiences on Amazon-owned sites and apps and through third-party exchanges and Amazon’s publishing partners. [Amazon DSP](https://www.sellerapp.com/blog/amazon-dsp/) provides its clients with audience insights and performance reporting, allowing them to track the success of their ad campaigns. Clients may opt for a self-service or a managed-service option and will benefit from industry-standard protection against SIVT.
## 5. StackAdapt
Based out of Toronto, Canada, [StackAdapt](https://www.stackadapt.com/) is a leading self-serve programmatic advertising platform that allows digital marketers to plan, execute, and manage data-driven digital advertising campaigns. With the use of machine learning and AI, StackAdapt makes automating performance decisions quicker and easier so that business can scale their campaigns.
## 6. Adform
Based in Denmark, Adform is a leading global independent advertising technology company. Adform’s omnichannel DSP platform provides advertisers with access to its extensive inventory, advanced buying algorithms, cross-device targeting, and built-in proprietary anti-fraud measures.
## 7. BrightRoll
Owned by Yahoo, BrightRoll is a global DSP that provides access to inventory from both Yahoo-owned sites and other premium publishing partners. Exclusive access to Yahoo Audience Data ensures that clients are able to gain insights that help them to target the right audiences. With BrightRoll, media buyers have extensive data at their fingertips as Yahoo platforms register over 165 billion data points each day. BrightRoll has built strong strategic partnerships with companies, such as DoubleVerify, to effectively manage fraud across the platform.
## 8. Google Display and Video 360
Google Display and Video 360 represents the amalgamation of DoubleClick Bid Manager, Campaign Manager, Studio, and Audience Center. With a reach across over 80 non-Google 3rd-party ad exchanges and over 800 million websites, the inventory provided by Display and Video 360 is unparalleled. Clients can benefit from intelligent automation to allow bidding and optimization to be streamlined and native integration with other solutions, such as Google Analytics 360.
## 9. AppNexus
AppNexus boasts the world’s largest independent programmatic marketplace and allows clients to harness the power of data and machine learning to inform advertising decisions, delivering intelligent campaigns. AppNexus DSP’s transparent platform can be integrated with internal programs to streamline the media buying process.
## 10. Adelphic
Adelphic is a leading omnichannel DSP, designed to simplify the workflow of programmatic traders. Adelphic’s self-service intuitive software ensures that brands and agencies are able to establish and maintain meaningful campaigns across all programmatic formats and devices. Adelphic is the only DSP on the market that provides a subscription-based model, helping to significantly reduce buying fees.
## Bonus: Oxagile
We also would like to highlight [Oxagile,](https://www.oxagile.com/adtech/?utm_source=atlanticnet&utm_medium=referral&utm_campaign=dsplisting) a full-fledged [adtech](https://hightouch.com/blog/adtech) development provider that focuses on building, re-architecturing, and enhancing demand-side platforms. Underpinned by programmatic advertising knowledge, the company revamps complex workflows, including inventory buying and optimization, cross-device campaign creation and management, ad performance reporting, and advanced audience targeting. By reinforcing existing DSPs with cutting-edge functionality or building custom ones, Oxagile helps clients get more control over their media-buying processes as well as optimize costs.
## Bonus: Basis
Basis by Centro is an award-winning omnichannel DSP designed for speed and performance. Basis has an intuitive and user-friendly interface and possesses the toolkit necessary for the purchase and management of cross-channel and cross-format ad campaigns. With over 15 years of establishing publisher relationships, Basis brings its best-in-class private marketplace of over 2000 active private deals across hundreds of top sites. Basis has established partnerships with industry-leading brand safety providers, ensuring that fraudulent activity across the platform is constantly monitored and blocked.
## How Can Atlantic.Net Help?
Atlantic.Net has been providing cutting-edge hosting services for over 30 years. Our platform uses the latest technology and is powered by the latest Intel Xeon CPUs architecture and networking. All our storage is redundant, tipping the reliability scale into overdrive. If you are looking for a scalable cloud platform to meet the demand of your next DSP marketing drive, look no further than Atlantic.Net.
Our programmatic API allows you to provision a single server to thousands of machines in a matter of seconds and allows for programmatic integration. Our service is resilient and will stay up even with heavy traffic loads; we even offer a 100% service level agreement to back up this claim.
Our Managed Services are specially designed to help our clients get more for less, and our engineering team will never leave you hanging. Our Managed Services and Security Services help bring focus to your core business so that you can continue to grow your business.
[Contact the team today](https://www.packtpub.com/product/amazon-web-services-aws-technical-essentials-ultimate-training-program-video/9781801079716) to see how Atlantic.Net can drive you forward and help get your brand out there for the rest of the world to explore.
---
# How to Set Environment Variables in Linux
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-set-environment-variables-in-linux/ | Published: 2021-01-23 | Updated: 2023-11-18 | Author: Hitesh Jethva
A variable is a location for storing a value which could be a filename, text, number or any other data.
A variable is usually referred to with its symbolic name. The value stored can be displayed, deleted, edited, and re-saved. Variables play an important role in computer programming because they enable programmers to write flexible programs.
An environment variable alters the dynamic values which affect the processes or programs on a computer. They exist in every operating system and their types vary. Environment variables also give information about system behavior and can change the behavior of software and programs.
In this tutorial, we will show you how to set environment variables in Linux.
## Step 1 – List Environment Variables
You can list all environment variables in your system by running the following command:
```
printenv
```
Or:
```
env
```
You should see the following screen:
There are a lot of environment variables available in Linux, including HOME, USER, EDITOR, PATH, LANG, TERM, MAIL, SHELL, and many more.
You can display the value of specific variable by passing the name of the variable to the printenv command.
For example, to display the value of the LANG variable, use the following command:
```
printenv LANG
```
You should see the following output:
```
en_US.UTF-8
```
## Step 2 – Set up an Environment Variable
There are two types of variables: Shell variables and the Environment variables.
To create a new shell variable named COMPANY with value Atlantic, use the following command:
```
COMPANY="Atlantic"
```
Next, you can verify the variable using the echo command:
```
echo $COMPANY
```
You should see the value of your variable in the following output:
```
Atlantic
```
You can also verify whether the above variable is an environment variable or not using the printenv command:
```
printenv COMPANY
```
You should see the empty output which means the variable is not an environment variable.
To create a new environment variable named ORGANIZATION, use the export command:
```
export ORGANIZATION=Atlantic
```
You can verify the environment variable with the following command:
```
printenv ORGANIZATION
```
You should get the following output:
```
Atlantic
```
The environment variables which you have created in this way are available only in the current session. If you log out of your system, all variables will be lost.
You can also unset an environment variable you created earlier using the unset command followed by the variable name.
For example, to unset an ORGANIZATION variable, use the following command:
```
unset ORGANIZATION
```
## Step 3 – Set up Persisting Environment Variable
When you set an environment variable using the export command, its existence ends when the user’s session ends, so it is recommended to set environment variables that are persist across sessions.
To set persisting environment variables globally, you will need to define them in /etc/profile file.
For example, you can set the persisting environment variable named COMPANY with value Atlantic by editing /etc/profile file as shown below:
```
nano /etc/profile
```
Add the following line at the end of the file:
```
export COMPANY=Atlantic
```
Save and close the file when you are finished, then activate the variable with the following command:
source /etc/profile
You can also set a persisting environment for a specific user by editing the user’s .bashrc file.
For example, set a persisting environment named VAR with value “My Linux Box” by editing the user’s .bashrc file:
```
nano ~/.bashrc
```
Add the following line at the end of the file:
```
export VAR="My Linux Box"
```
Save and close the file when you are finished, then activate the environment variable with the following command:
```
source ~/.bashrc
```
## Conclusion
In the above guide, you learned how to set and unset an environment variable in Linux. Environment variables are very useful for developers who will need to read or alter the environment of your system. If you’re ready to try setting an environment variable in Linux, get started on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net.
---
# How to Install the Rudder System Auditing tool on CentOS 8
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-the-rudder-system-auditing-tool-on-centos-8/ | Published: 2021-01-25 | Updated: 2023-11-15 | Author: Hitesh Jethva
Rudder is a multi-platform, open-source, professional solution for continuous auditing, deployment, and remediation of configurations within critical systems. It can be likened to a control tower that offers real-time visibility over how compliant your systems are with security and reliability parameters.
Rudder manages the following issues:
- **Continuous growth:** The IT industry increasingly demands an ever greater number of machines to maintain business services. Ensuring that all of these machines are functioning properly can be a major challenge.
- **Continuous availability:** When IT infrastructure is reliable and continuously reachable, it ensures high availability for IT services.
- **Continuous threat:** Systems that are constantly exposed to threats require continuous audits. Audits help detect and correct the threats.
In this tutorial, we will learn how to install the Rudder system auditing tool on CentOS 8.
## Step 1 – Install Rudder
By default, Rudder is not available in the CentOS 8 standard repository, so you will need to create a repo for Rudder.
First, import the Rudder key with the following command:
```
rpm --import https://repository.rudder.io/rpm/rudder_rpm_key.pub
```
Next, create a Rudder repo file using the following command:
```
nano /etc/yum.repos.d/rudder.repo
```
Add the following lines:
```
[Rudder_6.1]
name=Rudder 6.1
baseurl=http://repository.rudder.io/rpm/6.1/RHEL_$releasever/
gpgcheck=1
gpgkey=https://repository.rudder.io/rpm/rudder_rpm_key.pub
```
Save and close the file when you are finished, then install the Rudder server with the following command:
```
dnf install rudder-server-root -y
```
Once the Rudder is installed, you can verify the status of the Rudder service with the following command:
```
systemctl status rudder-jetty
```
You should get the following output:
- ```
rudder-jetty.service - Jetty Web Application Server
```
```
Loaded: loaded (/usr/lib/systemd/system/rudder-jetty.service; enabled; vendor preset: disabled)
Active: active (running) since Fri 2020-10-02 04:56:08 EDT; 3min 59s ago
Main PID: 5155 (java)
Tasks: 84 (limit: 12523)
Memory: 630.7M
CGroup: /system.slice/rudder-jetty.service
└─5155 /bin/java -server -Xms1024m -Xmx1024m -XX:+UseConcMarkSweepGC -
XX:+CMSClassUnloadingEnabled -Dfile.encoding=UTF-8 -Drudder.c>
Oct 02 04:55:50 centos8 systemd[1]: Starting Jetty Web Application Server...
Oct 02 04:55:50 centos8 rudder-jetty.sh[5081]: Setting umask to 0007
Oct 02 04:56:08 centos8 rudder-jetty.sh[5081]: Starting Jetty: . . . OK Fri Oct 2 04:56:08 EDT 2020
Oct 02 04:56:08 centos8 systemd[1]: Started Jetty Web Application Server.
```
## Step 2 – Create an Admin User for Rudder
Next, you will need to create a Rudder admin user and set the password. You can create it with the following command:
```
rudder server create-user -u admin
```
You will be asked to set admin password, as shown below:
```
New password:
Re-type new password:
User 'admin' added, restarting the Rudder server
Next, restart the Rudder service to apply the changes:
```
```
systemctl restart rudder-server
```
Next, you will need to allow the network that you want to monitor. You can allow it with the following command:
```
/opt/rudder/bin/rudder-init LDAPReset 0.0.0.0/0
```
You should get the following output:
```
SUMMARY OF OPTIONS:
Allowed networks: 0.0.0.0/0
Force LDAP reset: LDAPReset
done.
Updating Rudder password file with random passwords... done.
Cleaning up temporary directories... done.
Restarting jetty... done.
Reinitialization complete, Rudder is currently reloading.
You can access it via https://centos8/rudder
```
## Step 3 – Access Rudder Web Interface
You can now access the Rudder web interface using the URL **https://your-server-ip/rudder**. You should see the Rudder login page:
Provide your admin username and password and click on the **SIGN** **IN** button. You should see the Rudder dashboard on the following page:
## Conclusion
Congratulations! You have successfully installed and configured Rudder on CentOS 8. You can now install Rudder clients on the remote nodes, add them to the Rudder server, and start managing them from the Rudder dashboard. Install Rudder on your Atlantic.Net [dedicated server](https://www.atlantic.net/dedicated-server-hosting/) today.
---
# How to Install Varnish Cache with Apache on CentOS 8
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-varnish-cache-with-apache-on-centos-8/ | Published: 2021-01-27 | Updated: 2023-11-19 | Author: Hitesh Jethva
Caching is the process of storing copies of files in a cache so that future requests for that file can be accessed more quickly. Varnish is a free, open-source, powerful HTTP engine and reverse HTTP proxy used by more than 3.4 million websites. It stores the incoming page requests in memory and serves the same page request directly from Varnish cache instead of going straight to the web server.
This will speed up the performance of your website significantly. Varnish has its own configuration language (VCL) to write policies on incoming requests such as back-end servers, ACLs, responses, and more.
In this tutorial, we will learn how to set up Varnish caching with Apache on CentOS 8. We will set up Apache to listen on port 8080 and work as a backend server, then configure Varnish to listen on default HTTP port 80.
## Step 1 – Install Varnish Cache
By default, the Varnish package is available in the CentOS 8 system. You can install it by just running the following command:
```
dnf update -y
dnf install varnish -y
```
After installing Varnish, start the Varnish service and enable it to start after system reboot with the following command:
```
systemctl start varnish
systemctl enable varnish
```
Next, verify the status of Varnish with the following command:
```
systemctl status varnish
```
You should get the following output:
By default, Varnish listens on port 6081. You can verify it using the following command:
```
netstat -ltnp | grep 6081
```
You should get the following output:
```
tcp 0 0 0.0.0.0:6081 0.0.0.0:* LISTEN 1508/varnishd
tcp6 0 0 :::6081 :::* LISTEN 1508/varnishd
```
## Step 2 – Install and Configure Apache
Next, you will need to install the Apache webserver and configure it to work with the Varnish cache.
First, install the Apache server with the following command:
```
dnf install httpd -y
```
After installing the Apache webserver, you will need to change the Apache web server listening port from **80** to **8080**.
You can do it by editing the file /etc/httpd/conf/httpd.conf.
```
nano /etc/httpd/conf/httpd.conf
```
Find the following line:
```
Listen 80
```
And replace it with the following line:
```
Listen 8080
```
Save and close the file, then start the Apache service and enable it to start after system reboot:
```
systemctl start httpd
systemctl enable httpd
```
Next, copy the sample **index.html** page to the Apache default document root directory:
```
cp /usr/share/httpd/noindex/index.html.en-US /var/www/html/index.html
```
**Note:** If you are using Virtual hosting, then configure the relevant configuration file.
## Step 3 – Configure Varnish to Work with Apache
By default, Varnish is configured to listen on port 6081, so you will need to configure it to listen on port 80. You can configure it by editing varnish.service configuration file:
```
nano /usr/lib/systemd/system/varnish.service
```
Find the following line:
```
ExecStart=/usr/sbin/varnishd -a :6081 -f /etc/varnish/default.vcl -s malloc,256m
```
And replace it with the following line:
```
ExecStart=/usr/sbin/varnishd -a :80 -f/etc/varnish/default.vcl -s malloc,256m
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, restart Varnish service to apply the changes:
```
systemctl restart varnish
```
## Step 4 – Configure Apache as a Backend Server for Varnish
Next, you will need to configure Apache as a backend server for the Varnish proxy.
You can configure it by editing the file /etc/varnish/default.vcl:
```
nano /etc/varnish/default.vcl
```
Uncomment the following lines **if commented**:
```
backend default {
.host = "127.0.0.1";
.port = "8080";
}
```
Save and close the file when you are finished.
**Note:** Change the line 127.0.0.1 with your Apache server IP address if your Apache server resides on the other host. Change the port 8080 with a port number of your Apache server.
## Step 5 – Verify Varnish Cache
At this point, the Varnish cache is configured to work with the Apache webserver. It’s time to test whether caching is working or not.
You can test it using the curl command:
```
curl -I http://your-server-ip
```
You should get the HTTP header information in the following output:
Next, run the command again:
```
curl -I http://your-server-ip
```
You should get the Varnish cached response in the Age header:
You can also test the varnish cache using varnishlog command with curl command to view Varnish activity as it happens:
```
varnishlog
```
You should get an output similar to the following:
## Conclusion
Congratulations! You have successfully installed and configured Varnish cache with Apache web server on CentOS 8. Your website should now load faster because Varnish will retrieve the most frequently requested content from the cache memory. Try out Varnish on [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to Install TimescaleDB on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-timescaledb-on-ubuntu-20-04/ | Published: 2021-01-28 | Updated: 2023-11-25 | Author: Hitesh Jethva
TimescaleDB is a free, open-source, powerful database system powered by PostgreSQL. It is an extension of PostgreSQL and is specially designed to analyze time-series data with PostgreSQL. TimescaleDB is very similar to PostgreSQL, but it is optimized for speed and scale. Generally, relational databases are mainly used to store data, and they cannot handle the large volumes of time series data. This where TimescaleDB excels; it combines the speed of NoSQL databases and the ease-of-use of relational databases.
In this tutorial, we will show you how to install and use TimescaleDB on Ubuntu 20.04.
## Step 1 – Install PostgreSQL Database
First, you will need to install a PostgreSQL server in your server. By default, it is available in the Ubuntu standard repository. You can install it easily using the following command:
```
apt-get install postgresql postgresql-contrib -y
```
Once the installation is completed, log in to PostgreSQL and set the postgres password:
```
su - postgres
psql -c "alter user postgres with password 'password'"
```
Next, exit from the PostgreSQL shell with the following command:
```
exit
```
## Step 2 – Install TimescaleDB
By default, TimescaleDB is not available in the Ubuntu 20.04 default repository, so you will need to add the repository for it.
First, install all the required dependencies with the following command:
```
apt-get install gnupg2 software-properties-common curl git unzip -y
```
Once all the dependencies are installed, add the TimescaleDB repository with the following command:
```
add-apt-repository ppa:timescale/timescaledb-ppa -y
```
Next, install TimescaleDB by running the following command:
```
apt-get install timescaledb-postgresql-12 -y
```
Once the TimescaleDB is installed, it is recommended to tune some desired configurations. You can do it with the following command:
```
timescaledb-tune --quiet --yes
```
You should get the following output:
Next, restart the PostgreSQL service to apply the configuration changes:
```
systemctl restart postgresql
```
## Step 3 – Create a New Database and Enable TimescaleDB
In this section, we will create a new database, enable TimescaleDB, and connect the database to it.
First, log in to the PostgreSQL shell and create a new database named testdb with the following command:
```
su - postgres
psql
CREATE DATABASE testdb;
```
Next, change the database to testdb and connect it to the TimescaleDB with the following command:
```
\c testdb
CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;
```
You should get the following output:
The time-series data are hypertables which consist of many individual tables. We will create a regular SQL table and then convert it into a hypertable via the function create_hypertable.
First, create a table to store temperature and humidity information.
```
CREATE TABLE conditions (
time TIMESTAMP WITH TIME ZONE NOT NULL,
device_id TEXT,
temperature NUMERIC,
humidity NUMERIC
);
```
Next, transform your table into a hypertable with the following command:
```
SELECT create_hypertable('conditions', 'time');
```
Next, insert some data into the hypertable with the following command:
```
INSERT INTO conditions(time, device_id, temperature, humidity)
VALUES (NOW(), 'weather-pro-000000', 84.1, 84.1);
```
Next, insert multiple rows of data with the following command:
```
INSERT INTO conditions
VALUES
(NOW(), 'weather-pro-000002', 71.0, 51.0),
(NOW(), 'weather-pro-000003', 70.5, 50.5),
(NOW(), 'weather-pro-000004', 70.0, 50.2);
```
You can now verify your inserted data with the following command:
```
INSERT INTO conditions
VALUES (NOW(), 'weather-pro-000002', 70.1, 50.1) RETURNING *;
```
You should get the following output:
```
time | device_id | temperature | humidity
-------------------------------+--------------------+-------------+----------
2020-12-03 15:48:24.329461+00 | weather-pro-000002 | 70.1 | 50.1
(1 row)
INSERT 0 1
```
You can also delete data from the hypertable using the following command:
```
DELETE FROM conditions WHERE temperature > 80;
```
Once the data is deleted, you can run the VACUUM command to reclaim space still used by data that has been deleted.
```
VACUUM conditions;
```
## Conclusion
Congratulations! You have successfully installed and configured TimescaleDB on Ubuntu 20.04. You can now use TimescaleDB for storing time-series data and use those data to create graphs. Get started with TimescaleDB on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Upgrade Ubuntu 18.04 to Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-upgrade-ubuntu-18-04-to-ubuntu-20-04/ | Published: 2021-01-29 | Updated: 2023-11-18 | Author: Hitesh Jethva
The stable version of Ubuntu 20.04 Focal Fossa was released on April 23, 2020. This version is the latest Long-Term Support (LTS) release with security patches and updates available until 2025.
If you are using an older version of Ubuntu, you must upgrade it to the latest version as Ubuntu 20.04 introduced some important features. Some of them are listed below:
- Fast boot process
- Linux Kernel version 5.4
- Ships with GNOME 3.36
- Modified login screen
- Ships with PHP7.4, Ruby 2.7, Python 3.8 and OpenJDK 11
- Improved ZFS file system with native encryption
In this tutorial, we will explain how to upgrade Ubuntu.
## Step 1 – Verify Current Ubuntu Version
Before starting, we recommend that you create a backup of applications, databases, and other important files.
Next, verify your existing Ubuntu Version by running the following command:
```
cat /etc/lsb-release
```
You should see the following output:
Next, update all installed packages in your system with the following command:
```
apt-get update -y
apt-get upgrade -y
apt-get dist-upgrade -y
```
The process will take several minutes to complete.
Once your system is up to date, restart it to apply all the changes:
```
reboot
```
Once you are finished, you can proceed to the next step.
## Step 2 – Remove Unused Packages
Next, it is a good idea to remove unnecessary packages in your system to free up the space. You can do it with the following command:
```
apt-get --purge autoremove
```
Next, you will need to install the Update Manager package in your system, as it is frequently not installed in server operating systems.
You can install it with the following command:
```
apt-get install update-manager-core -y
```
Once the installation is completed, you can proceed to the next step.
## Step 3 – Upgrade Ubuntu 18.04 to Ubuntu 20.04
At this point, your system is ready for upgrade. Now, run the following command to display whether new 20.04 LTS version is available for your system:
```
do-release-upgrade
```
You should see that there is no development version of an LTS available:
```
Checking for a new Ubuntu release
There is no development version of an LTS available.
To upgrade to the latest non-LTS develoment release
set Prompt=normal in /etc/update-manager/release-upgrades.
```
You can now use the -d option to get the latest supported release forcefully and start the upgrade process:
```
do-release-upgrade -d
```
During the upgrade process, you will be prompted to type **y** or hit **Enter** to confirm as shown below:
```
Reading cache
Checking package manager
Continue running under SSH?
This session appears to be running under ssh. It is not recommended
to perform an upgrade over ssh currently because in case of failure it
is harder to recover.
If you continue, an additional ssh daemon will be started at port
'1022'.
Do you want to continue?
Continue [yN] y
Starting additional sshd
To make recovery in case of failure easier, an additional sshd will
be started on port '1022'. If anything goes wrong with the running
ssh you can still connect to the additional one.
If you run a firewall, you may need to temporarily open this port. As
this is potentially dangerous it's not done automatically. You can
open the port with e.g.:
'iptables -I INPUT -p tcp --dport 1022 -j ACCEPT'
To continue please press [ENTER]
```
Once the process has been completed successfully, you will be asked to select **y** to restart your system as shown below:
```
System upgrade is complete.
Restart required
To finish the upgrade, a restart is required.
If you select 'y' the system will be restarted.
Continue [yN] y
```
Type **y** and hit **Enter** to restart your system.
## Step 4 – Verify Upgrade
After rebooting the system, run the following command to verify the Ubuntu version:
```
cat /etc/lsb-release
```
You should see Ubuntu 20.04 LTS in the following output:
```
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=20.04
DISTRIB_CODENAME=focal
DISTRIB_DESCRIPTION="Ubuntu 20.04 LTS"
```
## Conclusion
In the above guide, you learned how to upgrade Ubuntu 18.04 LTS to Ubuntu 20.04 LTS. Upgrade your Ubuntu 18.04 [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net today!
---
# How to Install XWiki on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-xwiki-on-ubuntu-20-04/ | Published: 2021-02-01 | Updated: 2023-11-25 | Author: Hitesh Jethva
XWiki is a simple, lightweight, powerful wiki platform that allows you to customize the wiki to your specific needs. It is written in Java and runs on servlet containers like JBoss or Tomcat. XWiki provides a simple and user-friendly web interface that helps you create and manage your content from any device and browser. It comes with a rich set of features including WYSIWYG editing, OpenDocument-based document import/export, tagging, version control, powerful wiki syntax, advanced search functionality and many more.
In this tutorial, we will show you how to install XWiki on Ubuntu 20.04.
## Step 1 – Install Java
XWiki is written in Java, so you will need to install Java in your system. You can install Java using the following command:
```
apt-get install default-jdk gnupg2 -y
```
Once Java is installed, you can verify the Java version with the following command:
```
java --version
```
You should get the following output:
```
openjdk 11.0.9.1 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-Ubuntu-0ubuntu1.20.04)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-Ubuntu-0ubuntu1.20.04, mixed mode, sharing)
```
## Step 2 – Install XWiki
By default, XWiki is not available in the Ubuntu 20.04 default repository, so you will need to add the XWiki official repository to your system.
First, add the GPG key with the following command:
```
wget -q "https://maven.xwiki.org/public.gpg" -O- | apt-key add -
```
Next, add the XWiki repository with the following command:
```
wget "https://maven.xwiki.org/stable/xwiki-stable.list" -P /etc/apt/sources.list.d/
```
Next, update the repository with the following command:
```
apt-get update -y
```
Once the repository is updated, you can install XWiki by running the following command:
```
apt-get install xwiki-tomcat9-common xwiki-tomcat9-mariadb -y
```
During the installation, you will be asked to configure a database for XWiki as shown below:
Select **yes** and hit **Enter**. You will need to set a password for the xwiki database as shown below:
Provide your desired password and hit **Enter** to finish the installation.
After installing XWiki, you can verify the Tomcat service using the following command:
```
systemctl status tomcat9.service
```
You should get the following output:
- ```
tomcat9.service - Apache Tomcat 9 Web Application Server
```
```
Loaded: loaded (/lib/systemd/system/tomcat9.service; enabled; vendor preset: enabled)
Drop-In: /etc/systemd/system/tomcat9.service.d
└─xwiki-tomcat9-systemd.conf
Active: active (running) since Wed 2020-11-18 10:27:27 UTC; 1min 42s ago
Docs: https://tomcat.apache.org/tomcat-9.0-doc/index.html
Main PID: 39480 (java)
Tasks: 52 (limit: 2353)
Memory: 524.9M
CGroup: /system.slice/tomcat9.service
└─39480 /usr/lib/jvm/default-java/bin/java -
Djava.util.logging.config.file=/var/lib/tomcat9/conf/logging.properties -Djava.util.l>
Nov 18 10:27:44 server tomcat9[39480]: 2020-11-18 10:27:44,176 [main] WARN
o.e.j.u.s.S.config - No Client EndPointIdentificationA>
Nov 18 10:27:44 server tomcat9[39480]: 2020-11-18 10:27:44,202 [main] WARN
o.a.s.c.CoreContainer - Not all security plugins configur>
Nov 18 10:27:47 server tomcat9[39480]: 2020-11-18 10:27:47,618 [main] INFO
o.x.s.s.i.EmbeddedSolr - Started embedded Solr server.
Nov 18 10:27:52 server tomcat9[39480]: 2020-11-18 10:27:52,832 [main] INFO
o.x.s.f.i.FilesystemStoreTools - Using filesystem store directory >
Nov 18 10:27:54 server tomcat9[39480]: Deployment of deployment descriptor
[/etc/tomcat9/Catalina/localhost/xwiki.xml] has finished in [24,889>
Nov 18 10:27:54 server tomcat9[39480]: Deploying web application directory
[/var/lib/tomcat9/webapps/ROOT]
Nov 18 10:27:55 server tomcat9[39480]: At least one JAR was scanned for
TLDs yet contained no TLDs. Enable debug logging for this logger for a>
Nov 18 10:27:55 server tomcat9[39480]: Deployment of web application directory
[/var/lib/tomcat9/webapps/ROOT] has finished in [926] ms
Nov 18 10:27:55 server tomcat9[39480]: Starting ProtocolHandler ["http-nio-8080"]
Nov 18 10:27:55 server tomcat9[39480]: Server startup in [25,998] milliseconds
```
By default, Tomcat is listening on port 8080. You can check it with the following command:
```
ss -antpl | grep 8080
```
You should get the following output:
```
LISTEN 0 100 *:8080 *:* users:(("java",pid=39480,fd=39))
```
## Step 3 – Configure Nginx for XWiki
Next, you will need to install and configure Nginx as a reverse proxy to access the XWiki. First, install the Nginx webserver with the following command:
```
apt-get install nginx -y
```
Once installed, create a new Nginx virtual host configuration file using the following command:
```
nano /etc/nginx/sites-available/xwiki.conf
```
Add the following lines:
```
server {
listen 80;
server_name xwiki.example.com;
access_log /var/log/nginx/xwiki-access.log;
error_log /var/log/nginx/xwiki-error.log;
location / {
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $host;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_cache_bypass $http_upgrade;
proxy_pass http://127.0.0.1:8080;
}
}
```
Save and close the file then activate the Nginx virtual host with the following command:
```
ln -s /etc/nginx/sites-available/xwiki.conf /etc/nginx/sites-enabled/
```
Next, you will need to edit the Nginx main configuration file and increase the hash_bucket size:
```
nano /etc/nginx/nginx.conf
```
Add the following line below http {:
```
server_names_hash_bucket_size 64;
```
Save and close the file then restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 4 – Access XWiki Web UI
Now, open your web browser and access the XWiki web interface using the URL **http://xwiki.example.com/xwiki**. You should see the following page:
Click on the **Continue** button. You should see the admin user creation page:
Provide your username, password, and email and click on the **Register** **and** **Login** button. You should see the following page:
Click on the **Continue** button. You should see the following page:
Select your flavor and click on the **Install** button. Once the installation has been finished, you should see the following page:
Click on the **Continue** button. You should see the following page:
Click on the **Continue** button. You should see the XWiki default dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed and configured XWiki on Ubuntu 20.04. You can now easily deploy your own XWiki in the production environment. Try XWiki on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# Install Zulip Chat Server on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/install-zulip-chat-server-on-ubuntu-20-04/ | Published: 2021-02-02 | Updated: 2023-11-25 | Author: Hitesh Jethva
Zulip is a free and open-source chat application used for sharing private and public messages. It is very similar to Slack, written in Python, and uses the Django framework. Zulip is a cross-platform software tool able to handle thousands of concurrent chat sessions. It can be integrated with GitHub, Jira, Stripe, Sentry, and more using third-party plugins. Zulip offers a rich set of features including private messaging, group chats, drag-and-drop file uploads, Emoji, audible notifications, missed-message emails, and more.
In this tutorial, we will show you how to install a Zulip chat server on Ubuntu 20.04.
## Prerequisites
- A fresh Ubuntu 20.04 [VPS](https://www.atlantic.net/vps-hosting/)
- A valid domain pointed to your server IP
- A root password configured on your server
## Step 1 – Download Zulip
First, you will need to download the latest version of Zulip from its official website. You can download it with the following command:
```
wget https://www.zulip.org/dist/releases/zulip-server-latest.tar.gz
```
Once the download is completed, extract the downloaded file with the following command:
```
tar -xvzf zulip-server-latest.tar.gz
```
Once the downloaded file is extracted, you can proceed to the next step.
## Step 2 – Install Zulip Server
You can start the Zulip installation by specifying your valid email address and an FQDN as shown below:
```
./zulip-server-3.1/scripts/setup/install --certbot --email=admin@example.com --
hostname=zulip.example.com
```
Once the Zulip server is installed successfully, you should get the following output along with Zulip URL:
```
+ '[' -e /var/run/supervisor.sock ']'
+ supervisorctl restart all
zulip-django: started
zulip-tornado: started
process-fts-updates: started
zulip-workers:zulip_events_deferred_work: started
zulip-workers:zulip_events_digest_emails: started
zulip-workers:zulip_events_email_mirror: started
zulip-workers:zulip_events_embed_links: started
zulip-workers:zulip_events_embedded_bots: started
zulip-workers:zulip_events_error_reports: started
zulip-workers:zulip_events_invites: started
zulip-workers:zulip_events_email_senders: started
zulip-workers:zulip_events_missedmessage_emails: started
zulip-workers:zulip_events_missedmessage_mobile_notifications: started
zulip-workers:zulip_events_outgoing_webhooks: started
zulip-workers:zulip_events_signups: started
zulip-workers:zulip_events_user_activity: started
zulip-workers:zulip_events_user_activity_interval: started
zulip-workers:zulip_events_user_presence: started
zulip-workers:zulip_deliver_enqueued_emails: started
zulip-workers:zulip_deliver_scheduled_messages: started
+ set +x
+ su zulip -c '/home/zulip/deployments/current/manage.py generate_realm_creation_link'
Please visit the following secure single-use link to register your
new Zulip organization:
https://zulip.example.com/new/mmlbpkhig2hnl5kpkzz6hot1
```
## Step 3 – Access Zulip Web Interface
Now, open your web browser and type the URL from the above output https://zulip.example.com/new/mmlbpkhig2hnl5kpkzz6hot1. You should see the following page:
Provide your email address and click on the **Create** **organization** button. You should see the following page:
Provide your Organization name, URL, admin username, and password and click on the **Login** button. You will be redirected to the Zulip dashboard as shown below:
## Conclusion
Congratulations! You have successfully installed Zulip chat server with Let’s Encrypt SSL on Ubuntu 20.04. If you’re looking for a simple and cost-effective replacement for Slack or Microsoft Teams then the Zulip chat server is the right choice for you – get started with Zulip on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# Why cPanel Is the Best Solution for Website Designers
> URL: https://www.atlantic.net/vps-hosting/why-cpanel-is-the-best-solution-for-website-designers/ | Published: 2021-02-03 | Updated: 2026-03-04 | Author: Alexander Wise
Linux-based website hosting is popular due to its nonexistent-to-low price and high degree of security. Linux supports multiple control panel software applications that facilitate customer website design.
Let’s take a close look at the most popular solution available today, cPanel, and see why it’s the best choice for website designers.
## What Is cPanel/WHM?
The most popular Linux-based control panel software is aptly named cPanel. You will often see it referenced in combination with WHM (Web Host Manager) as a website management solution. These two tools perform complementary functions related to the management of websites or cloud servers.
cPanel is control panel software accessed by end-users to manage a Linux hosting service, such as for a website. It features a simple and intuitive GUI that provides a powerful platform for performing many website administrative and management tasks. We will get deeper into its details shortly, but for now, let’s just say it’s the front end of the cPanel/WHM tandem.
WHM is used to create and manage cPanel accounts, and frequently resellers use WHM to manage their customers’ hosting accounts. Administrators using the WHM interface have root-level access to resources, whereas cPanel provides access to a customer’s hosting account.
## cPanel Features and Benefits
cPanel has become a popular solution for managing virtual private server (VPS) hosted websites and servers due to several features that directly address the needs of the user community. The tool offers complete control over a website or server for both experienced professionals and non-technical users just beginning to explore the possibilities of the web.
What follows are some of the main characteristics that make cPanel so popular for [VPS hosting](https://www.atlantic.net/vps-hosting/) and an explanation of why it should be the first choice of website designers.
### Simplicity
No matter what level of technical expertise you enjoy, it’s always preferable to use a simple solution when one exists. cPanel’s user interface enables many website management activities to be accomplished by simply pointing and clicking. Both basic and complex tasks can be performed through the GUI with a few clicks. Documentation and built-in tutorials that help guide non-technical users through all cPanel operations are easily accessible.
The cPanel interface enables users to fully manage their website without requiring them to possess any level of technical skills. Many website designers are not computer experts. They have decided to build an online presence to further business or personal interests and greatly benefit from using the simple and intuitive cPanel interface.
By eliminating the technical impediments to website management, cPanel allows users to focus on designing interesting sites and managing them efficiently. Rather than getting bogged down investigating the syntax of some arcane command, designers can concentrate on the aspects of their website that appeal to users, drive traffic, and increase engagement.
### Scalability
Another outstanding feature of cPanel is its ability to allow entities such as marketing agencies to manage multiple clients on a single VPS. With cPanel, it’s easy to manage multiple domains on the same VPS. Client email lists and files can be segregated and managed efficiently from cPanel’s intuitive interface. Once again, cPanel enables users to focus on what they want to do rather than on the technical details of how to get things done.
### Flexibility
If the basic features of cPanel are not sufficient, [multiple extensions](https://cpanel.net/extensions/) allow users to easily augment their systems. Offerings like WordPress management tools, billing systems, customizable backup applications, and security solutions can quickly be added. Easy installation capabilities with Atlantic.Net’s One-Click Apps let you add software with just a few clicks.
### Compatibility
cPanel is compatible with all web browsers including Google Chrome, Safari, Firefox, Microsoft Edge, Opera, and Internet Explorer. It is also compatible with many third-party add-ons and applications that extend website functionality. This adds to the degree of creativity that can be exercised by website designers using cPanel.
### Customization
Through cPanel extensions and third-party compatibility, there is no limit to the degree of customization that can be achieved by website designers. CMS solutions like Joomla, Drupal, or WordPress can be added simply and easily. Resellers can take advantage of cPanel customization for enhanced branding and improving [logo design](https://blog.designcrowd.com/article/1898/7-tips-to-keep-in-mind-while-designing-a-brand-logo) and brand colors to promote their business.
### Database Management
Databases are an essential component of most useful websites. They are a requirement for any site that intends to be more than a bulletin board. Database creation and management can be done with cPanel. Multiple database platforms are supported by cPanel, with the two most popular being MySQL and PostgreSQL.
### Email Management
A primary objective of many website owners is retaining visitors once they have attracted them to their sites. Another is communicating with visitors who have expressed interest in the website’s offering. Email is perfect for both tasks and is easily managed with cPanel. Users can easily create or delete email accounts and customize emails to reflect their brand.
### Backup and Recovery
cPanel provides flexible backup and recovery functionality that enables users to protect their information. You can back up full cPanel accounts and use the media to restore them on different servers. This includes all of the account files, databases, email accounts, and settings.
### Conclusion
As this list demonstrates, cPanel offers website designers an intuitive platform from which to manage all aspects of their sites. It removes most of the technical impediments that stand in the way of an average user running a superb website.
## [Atlantic.Net](https://www.atlantic.net)‘s cPanel Offerings
As a [VPS provider](https://www.atlantic.net/vps-hosting/), Atlantic.Net offers its customers flexible hosting options. Atlantic’s Cloud VPS offerings provide users with the choice to host on a VPS with or without cPanel. It is a fully integrated solution that enables users to only pay for what they need. You can easily add cPanel as one of Atlantic.Net’s One-Click Apps, rather than taking the hour or so normally spent on manual installation.
Atlantic’s combination of cost-efficient Linux VPS solutions and a cPanel license gives website designers the perfect platform for building engaging sites. You can tailor the size of the hosting solution to meet your business requirements and avoid paying for unnecessary capacity. The addition of cPanel lets users of all levels of technical proficiency efficiently manage their websites.
---
# What’s the Best VPS: Windows or Linux?
> URL: https://www.atlantic.net/vps-hosting/whats-the-best-vps-windows-or-linux/ | Published: 2021-02-04 | Updated: 2025-09-19 | Author: Alexander Wise
A [Virtual Private Server (VPS)](https://www.atlantic.net/vps-hosting/) is a popular choice for organizations in need of web hosting as it provides an economical and secure platform from which to run their applications, for example, a business or e-commerce website. In this article, we are going to look at why a VPS makes sense for businesses of any size and how to choose the operating system used by your virtual server.
## Why Choose a VPS?
There are three basic choices when engaging hosting services for a website or web-based application. Depending on the security and performance requirements and the organization’s budget constraints, an enterprise might choose one of the following options:
- **Dedicated Physical Server** – Dedicated server hosting provides the greatest control and customization. Customers self-manage or pay for the management of an entire server that is housed in a provider’s data center. The increased control over the hosting environment comes with a price. Using a dedicated physical server is the most expensive of the three options. It can provide a secure environment when configured correctly but relies on the customer to implement this security or pay a service provider for those services.
- **Shared Hosting** – In a shared hosting environment, multiple customers have access to the same physical server. They share the server resources such as the storage space, memory, and CPU power. A shared hosting option is the least expensive alternative but provides limited customization. The possibility exists that performance may be impacted by other customers sharing the server. You may also be limited as to the software you can install making it difficult to achieve business goals or utilize certain software packages.
- **Virtual Private Server** – A virtual private server, also known as a cloud server, gives users additional benefits to those provided by a dedicated physical server at a lower cost. It builds on the concept of shared hosting; however, hosting multiple virtual servers on a physical machine offers customers more fine-grained control and less interference from the other occupants. It is a secure, scalable, customizable, and economical alternative that can fit the needs of many customers. Using a VPS eliminates the resource limitations enforced in a shared hosting scenario.
Selecting a VPS is a wise decision for organizations or individuals who desire the security and customization of a dedicated server at a reduced cost. In addition to providing a secure and customizable platform for their websites and applications, the virtual nature of a VPS makes it more flexible than a physical server. Resources can be scaled to allow customers to use exactly what they need and easily address variable usage patterns.
At Atlantic.Net, if you are utilizing a VPS but your business’ growth requires a dedicated server for compliance or other business reasons, then you have the option to live-migrate your VPS to your own private Dedicated Host in the cloud. This means no downtime for you or your business, providing an easy path to upgrade your VPS and scale your online presence as needed.
A VPS combines the best features of the dedicated and shared hosting models. Once the choice has been made to go with a virtual private server, the next decision customers must make is whether to choose a VPS that uses the Windows or Linux operating system.
## Choosing the Operating System for Your VPS
While other operating systems are available for virtual hosting, we will focus on Windows and Linux. Both operating systems can provide reliable functionality for websites and applications, but some significant differences may make one more attractive to some customers. Below, we compare the characteristics of the two platforms to differentiate the two choices and help you select the one that works best for your situation.
### Cost
As an open-source solution, Linux can initially be a less expensive solution. Some Linux distributions have no licensing fees, unlike Microsoft Windows Server. This is a major difference between the two solutions and may be enough to sway customers who are primarily concerned with budgetary constraints. Other concerns may impact the final decision, but Linux is a less expensive alternative out of the box when only considering licensing.
### Performance
If performance and extended uptime is a primary concern, Linux may be a better choice in an operating system. Linux provides more opportunities for server optimization and has less intensive hardware requirements. Windows servers require more frequent reboots, which impact system availability, and need to be restarted after patching. The Windows GUI can expend unnecessary resources if not correctly configured and optimized. Optionally, the Windows GUI can be disabled in favor of PowerShell to reduce resource usage, but this is not a common solution for most. When it comes to utilizing server resources, Linux is still considered the performance king, but Microsoft is continually pursuing improvements.
### Compatibility
The software tools and packages that you plan to use on the VPS can be the determining factor in making the selection. If you are working with Microsoft-centric products a Windows VPS will provide a better and, in some cases, the only solution. A Linux VPS will be better suited for users who are comfortable with Linux-specific software. You need to perform a thorough review of the products you will use and ensure they are compatible with the operating system you select. Additionally, you will need to ensure that your OS is supported by your provider. For Windows and Linux, earlier versions may be “end of life” (EOL) operating systems, meaning they are no longer supported. This means that patching, security fixes, bug fixes, etc. will no longer be provided from the manufacturer.
### Control Panel
The control panel used to manage and customize your website differs based on the chosen OS platform. Linux systems use cPanel or Web Host Manager (WHM). On a Windows VPS, these will be replaced by Plesk. Familiarity with one of these control panel solutions may influence the choice of operating system to host your VPS. While an administrator could install either software package on the other operating system, the issues and work involved are not considered worthwhile. If you require a control panel, selecting your OS first is a great place to start.
### Security
The security of web-based applications is a critically important consideration when choosing its hosting platform. Due to its incredible popularity, Windows is a prime target of hackers looking to compromise enterprise IT resources. Malicious actors also attempt to subvert Linux security but are generally less successful. Linux was designed with strong security in mind and the user community works to maintain it as a safe choice in operating systems. If security is your primary concern, and you are comfortable working with the OS, you may want to go with a Linux solution. It is important to remember that proper configuration and patch management are necessary to maintain security in any operating system platform, so if you do not understand how to properly secure your Linux server, purchasing managed services or instead opting for a Windows Server and additional software to cover your needs will be the best routes for you and your team.
### Ease of Use
A Windows VPS provides a more user-friendly interface that features its well-known graphical user interface (GUI). Even with the addition of management tools such as cPanel, a Linux VPS requires a higher degree of technical knowledge than a Windows solution. Thus, the users who will interact with the system may be a deciding factor in the operating system choice. In general, a Windows VPS is easier to use than a Linux alternative. A GUI can be added to some Linux distributions to remove the need to work with a command-line interface; however, most server-based GUIs will use additional resources and can introduce additional security concerns which negate some of the advantages Linux offers over Windows.
### Technical Support
One of the most apparent benefits of going with a Windows solution is the technical support available from Microsoft and Microsoft certified partners. Windows is the most widely used commercial operating system in the world, and the company offers extensive support options that can be used by its customers. Organizations that are more comfortable with a corporate-backed OS solution will favor running their VPS on the Windows platform. Over the past decade, however, operating systems like Red Hat Linux, Ubuntu, and others have begun to provide paid support, though engaging that paid support can bring you closer the costs of Windows Server.
Technical support for many Linux distributions is provided by the large user community associated with the solution free of charge. However, that old saying “you get what you pay for” holds true. Volunteer-provided Linux support will not help you through your issues if the user base does not want to. There are no contracts, service level agreements, or anything to guarantee your issue will be resolved. This should be a key factor in your decision if you or your team do not possess the technical skills needed to overcome issues.
## Conclusion
Specific aspects of implementing a Linux or Windows VPS can pose contradictions that customers must resolve when making their decision on which OS to employ. You might want to take the least expensive route, which generally means a Linux solution, but be skeptical of your ability to handle its technical challenges. While a Windows-based VPS may enable your team to work in a familiar setting, security concerns may cause you to opt for a hardened Linux installation. As with many decisions in life, you need to strike the proper balance to be successful.
[Atlantic.Net](https://www.atlantic.net/managed-services/) also offers managed services to help enterprises reach their IT objectives. With over 20 years of experience, their technical team ensures you have the best support available. Offerings include managed server hosting as well as a fully Managed Firewall, Intrusion Prevention Service, patch management, vulnerability scans, multi-factor authentication, onsite and offsite backups, replication, and more. Managed services are a perfect solution for customers who want to use a Linux platform but do not have the required technical expertise in-house as they can help cover the gaps you have in your IT knowledge base.
You can choose from a variety of Windows Server variants and Linux distributions. Windows Server users can select to host their VPS using Windows Server 2008, Windows Server 2012, Windows Server 2016, or Windows Server 2019. A wide range of Linux flavors are available with users able to use Ubuntu, Debian, CentOS, Fedora, or Arch Linux. FreeBSD Unix VPS options are also available. Atlantic.Net also has One-Click Apps to help take some of the work out of a Linux deployment. Our most popular One-Click Apps include cPanel, WordPress, LAMP stacks, and LEMP stacks.
Atlantic.Net can meet your requirements for a VPS with either Linux or Windows solutions. We offer Windows or Linux VPS hosting in the cloud powered by enterprise-grade solid-state drives and backed by an experienced technical support team that is available 24x7x365. Virtual private servers built on multiple Linux distributions and a wide range of hosting options are available. Atlantic.Net can tailor a [VPS solution](https://www.atlantic.net/vps-hosting/) that gives you the features your application needs with straightforward and competitive pricing. Found out more by contacting Atlantic.Net today.
---
# Applied Cloud Computing in Higher Education
> URL: https://www.atlantic.net/life-sciences-pharma-biotech/applied-cloud-computing-in-higher-education/ | Published: 2021-02-05 | Updated: 2026-09-15 | Author: Dr. Rachael Bailey
The current global pandemic has made it essential for educational institutions to fully embrace the power of the cloud. University professors and researchers are turning to cloud-based technologies to provide and maintain their online resources and, as the benefits of cloud computing align perfectly with the key priorities of the higher education sector, this transition is unsurprising. So, how can cloud computing deliver a vital academic solution?
## Benefits of Cloud Computing for Academic Research
Scientific research demands fast and intense compute power, flexible turn-key solutions, and the resources to store vast data volumes. What are the key benefits of leveraging the power of the cloud in academic research?
**Turn-key flexible terms**
Academic research teams generally seek a one-stop-shop computing platform that enables them to get up and running immediately. Cloud providers can deliver a turn-key solution with flexible terms to ensure maximum performance while saving time and money. Implementing a managed service ensures that an institution deploys a highly effective and secure IT infrastructure that is routinely maintained and updated.
**Set Pricing**
When working within academic research, funds can be restrictive and must be spent wisely. When choosing a managed service provider, lead researchers may wish to consider cloud providers that offer their clients fixed pricing or subscription model. Under this type of model, the client is charged a set fee for a specific number of service units. This is much easier to understand than [dynamic pricing](https://dealhub.io/glossary/dynamic-pricing/) structures and can be seamlessly factored into a grant proposal.
**Communication and Collaboration**
The year 2020 has highlighted how essential collaboration is when we seek to drive scientific innovation and discovery. Global collaboration has led to the successful discovery and approval of several COVID-19 vaccines and therapies. Cloud-based technologies support a collaborative research environment, allowing data and resources to be securely shared, anywhere and at any time.
**Scalability**
By providing flexible scalability, cloud-based technologies allow researchers to meet the computing demands of working with large data sets. Whether your research involves highly complicated computations or complex run models, cloud computing delivers the flexibility and elasticity required to efficiently match computing power to demand.
**Innovation and Agility**
The cloud can improve both the quality and quantity of scientific research, helping to drive novel scientific discoveries. Scientists are now able to do what was once impossible, analyzing vast datasets to discover exciting patterns and correlations. By leveraging the power of cloud technology and AI/machine learning, scientists can even identify new and exciting areas of research.
## Benefits of Employing Cloud Technology in a Higher Education Setting
**Accessibility**
The cloud enables students and staff to access online lessons, coursework, digital textbooks, and journals remotely. This makes online content more accessible and helps to enhance productivity. Higher education often requires the use of specialized hardware and software that can be expensive to purchase. Cloud technology allows individual terminals to access shared resources remotely, from anywhere with internet access. This content and infrastructure can be accessed 24/7.
**Security**
When employing cloud-based services within a higher education setting, robust security is essential. Data safety and privacy and intellectual property are key concerns for university professors and researchers who must consider relevant federal regulations, such as FERPA, HIPAA, HITECH, and COPPA, and opt for a cloud provider that can ensure full compliance with these standards.
**Scalability**
Cloud computing enables a university professor or researcher’s infrastructure to be highly and dynamically scalable. On-demand scalability allows professors to quickly and efficiently expand their compute and storage capabilities in response to the traffic spikes and usage peaks that are inevitable given the vast amount of staff and students accessing services at any given time. It also enables academics who are engaged in research projects to offset intense workloads to the cloud, automating resource deployments using the power of cloud API’s,
**Reduced infrastructure**
Cloud technology significantly reduces physical hardware requirements, resulting in a significant cost saving. Just like utility companies, cloud providers enable university professors to only pay for the resources that they use, saving money and consolidating space. As space is often at a premium within universities, the elimination of on-premise servers allows valuable space to be utilized for more pressing needs.
## How Can Atlantic.Net Help?
With over 30 years of experience, Atlantic.Net can deliver a turn-key solution that will fast-track [research and development](https://www.atlantic.net/life-sciences-pharma-biotech/) within your institution.
If you are an educator or researcher looking for a managed service provider that can help to boost productivity, streamline your workload and accelerate time to science, then Atlantic.Net can help. By deploying our services, you can trust that your valuable data is safe and secure and that you remain fully compliant with the necessary regulations.
Unlike Hyper-scale cloud providers, Atlantic.Net is willing and able to adjust our terms of service so that they can meet the requirements needed to be cleared by your legal team.
[Contact the team today](https://www.atlantic.net/about-us/corporate-contact/) to see how Atlantic.Net can provide the powerful infrastructure needed to drive your education and research forwards.
---
# Paying With PayPal
> URL: https://www.atlantic.net/vps-hosting/paying-with-paypal/ | Published: 2021-02-16 | Updated: 2026-03-04 | Author: Richard Bailey
## Introduction
Based on feedback we have received and to better serve our ever-growing customer base, we have introduced the ability for our customers to pay with PayPal.
While paying online securely with credit/debit cards is commonplace, you can now enjoy paying with PayPal if you don’t want to pay with a credit/debit card, or simply prefer to pay in advance for your services.
You can choose PayPal as a form of payment during or after signing up with Atlantic.Net. When you choose PayPal, you prepay an amount of your choosing which will be applied to your Atlantic.Net account as an ‘account credit’. This account credit will then be applied to the invoices generated on your customer account. If the account credit is not sufficient to cover the total of your outstanding invoice, our systems will check if you also have a credit or debit card on file. If you do, the card will be charged for the remaining outstanding amount.
You can view your remaining available credit on the Account page inside the Cloud Portal. Additionally, we will notify you if your account credit falls below 20% of what you deposited to give you an opportunity to add funds to your account before you have exhausted your remaining credit.
## **What you will learn in this guide**
How do I signup using PayPal as a method of payment?
How do I use PayPal after signing up to add funds to my account?
## How do I signup using PayPal as a method of payment?
You can choose PayPal as a form of payment during the second step of signup where you are requested to provide ‘Billing information’.
You can choose the desired amount to preload ranging from $10 to $500 in the following set of choices: $10, $25, $50, $100, or $500. Additionally, you can choose to enter a custom amount.
Once you submit the information on ‘Billing Information’ page, you will be taken to the PayPal website to complete the payment. If you are not already logged into PayPal in your browser, you will be prompted to log into PayPal first. Note that you can use a PayPal account registered with a different email address than the one you are using to create your account with Atlantic.Net.
Once you log into PayPal, you will be requested to confirm the PayPal transaction.
After you confirm the PayPal transaction, you will be brought back to the Atlantic.Net Cloud Signup page and you will see the confirmation that your account is currently undergoing verification.
## How do I use PayPal after signing up to add funds to my account?
Head over to your Atlantic.Net Control Panel at [cloud.atlantic.net](https://cloud.atlantic.net/?page=userlogin), login and then click on your email address in the top right and then click on ‘Account’. This will bring you to the Account Info page. This page will help you use PayPal with your account as well as show you important information about your usage, the amount past due (if any), the amount of credit you have with us and how much of your credit has been used up based on your usage since the last statement. You can easily add a credit or debit card as a second form of payment even if you have chosen to use PayPal.
You can click on the ‘Manage Cards / Make Payment’ button to bring up options that will allow you to update/view the credit/debit card you have on file with us or choose PayPal and the amount you wish to add to your account. If you choose PayPal, you can pick from the preset amounts to add or enter a custom amount you wish to add to your account, then click ‘Proceed to Pay with PayPal’. You will be taken to the PayPal website to complete the transaction. Once you complete the transaction, you will be sent back to the ‘Account Info’ page with the new credit correctly reflected.
You can view your PayPal history by clicking on the ‘PayPal Payment History’ button.
Since PayPal is a prepaid type payment, a convenient feature called ‘Manage Billing Alerts’ is available to help you stay informed if your Atlantic.Net usage for the current billing cycle exceeds a chosen threshold.
## FAQ
**My PayPal account email address is different from my the email address I used to signup at Atlantic.Net. Can I still use that PayPal email address to pay for my services?**
Yes. Your PayPal account email address that you use to pay for your services can be different from the email address you used to signup up with Atlantic.Net
**What is the minimum amount I can deposit into my account using PayPal?**
$10.
**Can I use multiple PayPal accounts to pay for my services?**
Yes. Feel free to use as many accounts as you like. However, only one account can be used per transaction.
---
# Atlantic.Net Expands the Free G3.2GB Promo in San Francisco Data Center
> URL: https://www.atlantic.net/press-releases/atlantic-net-expands-the-free-g3-2gb-promo-in-san-francisco-data-center/ | Published: 2021-02-19 | Updated: 2024-06-11 | Author: Editorial Team
**Free G3.2GB Cloud VPS Hosting is now available in California data center for one full year**
**ORLANDO, FLA. (February 19, 2021)** – [Atlantic.Net](https://www.atlantic.net/), a leading cloud services provider, expanded their offer enabling new cloud VPS customers to double their server resources at no extra cost. Atlantic.Net will upgrade all cloud plans to the capabilities of the next highest price bracket at no additional cost for new customers at its San Francisco data center. This program also includes Atlantic.Net’s Free-to-Use for One Year Server promotion, meaning that any new free tier users will be automatically upgraded from 1GB to 2GB Cloud Server usage for one full year.
“With this expansion, our Free-to-Use promotion is now available in five data centers for one full year,” said Marty Puranik, CEO and Founder of Atlantic.Net. “We are excited to continue to expand our services and happy to allow entrepreneurs a full year of free service with our G3.2GB Cloud VPS. This is one way we are helping small businesses and developers get their businesses off the ground.”
Atlantic.Net initially offered the new program in Orlando, New York, Ashburn, and Toronto, but has now expanded it to San Francisco, with plans to make it available at all its locations in coming weeks. Customers will be able to take advantage of the G3 plans with double memory, 1TB more outbound data transfer than the G2 plans, some plans have better vCPU and disk space, and three new larger 48 GB, 96 GB, and 192 GB RAM plans are also available.
The Atlantic.Net Cloud Platform, which is engineered to provide fault-tolerant, ultra-fast performance, includes award-winning Cloud Servers, Secure Block Storage, one-click applications, DNS, dedicated private nodes, private networking, RESTful API, data backup, a full suite of managed services, 24/7/365 expert U.S.-based support, and more. This infrastructure is ideally suited to support businesses and organizations as they evolve toward a distributed remote work environment to mitigate the health risks of COVID-19 to the global workforce.
To view the latest cloud offerings and pricing structure, visit [https://www.atlantic.net/vps-hosting/](https://www.atlantic.net/vps-hosting/).
**About Atlantic.Net**
Atlantic.Net is a global [cloud services](https://www.atlantic.net/hipaa-compliant-hosting/) provider with over 25 years of experience, serving thousands of developers and small, medium, and large clients in more than one hundred countries. Atlantic.Net specializes in managed and non-managed Windows, Linux, and FreeBSD server hosting solutions and has served dynamic business clients including Lenovo, Newegg, NASA, and Hilton, among others. With a focus on security, compliance, and simplifying the user experience, Atlantic.Net provides business-class dedicated and cloud hosting solutions, backed by 24/7/365 support in New York, London, San Francisco, Toronto, Dallas, Ashburn, and Orlando. For more information, please visit [Atlantic Net/](https://www.atlantic.net/).
---
# How to Choose a WordPress VPS Provider
> URL: https://www.atlantic.net/vps-hosting/how-to-choose-a-wordpress-vps-provider/ | Published: 2021-02-19 | Updated: 2025-09-19 | Author: Brandon Schroth
WordPress powers 455 million websites (around 35% of *all websites)*, and its broad support and user-friendliness make it an ideal choice for a content management system. But setting up a website is never as easy as just picking a website platform – you need a [web host](https://hostingdata.co.uk/), too.
VPS hosting can be incredibly powerful, so much so that it can even give a competitive edge to industries as unforgiving as [Forex trading](https://www.atlantic.net/vps-hosting/how-vps-is-giving-a-competitive-edge-to-forex-trading/), Healthcare, Advertising, Life Sciences and more. Today, though, we’ll be covering the benefits that VPS hosting can provide in the context of [WordPress VPS hosting](https://www.atlantic.net/vps-hosting/wordpress-vps-hosting/).
## What Is VPS Hosting?
So what exactly is a VPS? Essentially, it’s a type of cloud hosting that doesn’t put you in a position where a bad neighbor can potentially cause you an issue.
With traditional shared hosting, there may be dozens or hundreds of people on the same server, and the technology that oversees that server isn’t always very strict. That means that if a shared server has 32GB of RAM and there are a few hundred people on it, then that 32GB of ram gets torn back and forth between users in a virtual tug-of-war. For *most* personal use cases, that’s not necessarily a problem, but if you’re trying to host a website on an overutilized shared server, you might find the website crashing often.
VPS is a nice alternative to such unrestricted shared hosting wherein the host limits the number of users per server and strictly cordones off each user’s environment (or VPS). To continue using our example above – a server that has 32GB of RAM – the number of users may be limited to 16, so each user can get 2GB of RAM. No matter what happens, you are guaranteed the 2GB RAM resources. Servers are not overprovisioned; instead, the load is balanced to another host.
Of course, this equal split applies to all the hardware on the server, whether that’s RAM, the CPU, storage, or maybe even the connection the server runs on.
### The Cost
Since the resources of virtual private servers are allocated to fewer people, that means that VPS hosting is generally more expensive than shared hosting. While you may find monthly prices in the $5-$10 ballpark at the lower end, you might expect a relatively good entry-tier [VPS hosting](https://www.atlantic.net/vps-hosting/pricing/) service starts from $10 monthly, although that can go up to hundreds or thousands of dollars depending on the server and your needs.
There are also specific VPS hosting services that come with a slew of additional features such as server management, additional IP addresses, 100% Service Level Agreements, Onsite and Offsite backups, replication, and so forth. Going with such an option is perfect if you aren’t necessarily familiar with the website development and hosting or if you just don’t feel comfortable setting up and maintaining a WordPress website on your own.
## What to Look For
### Server Uptime
One of the most important things you’ll want to focus on when choosing a host is the [uptime of the service](https://www.atlantic.net/disaster-recovery/what-exactly-does-uptime-mean-in-the-cloud-hosting-industry/). There’s no point putting so much effort into building a site if the host it’s on is constantly going down and your users can’t access it.
As such, you’ll want to look for hosts that [guarantee 100% uptime if possible](https://www.atlantic.net/hosting-services-provider/100-uptime-sla/). These types of providers have high-performing and highly available infrastructure services that should never go down unexpectedly.
### WordPress Management Suite
Since we’re talking about WordPress hosting, it’s important to find a site that has WordPress management tools that you’re comfortable with. These considerations can range from how your WordPress site is installed (such as with a one-click installation) to the control panel that you’re going to be dealing with day-to-day (such as cPanel).
More importantly, you need to gauge your own level of comfort when it comes to managing WordPress and knowing how much help you’re going to need. If you are a novice at administering a website, then choosing a VPS host that does most of the stuff for you is a good idea. On the other hand, if you have some experience, then a bit less hand-holding is OK.
### Customer Support
Related to the point above, you’ll certainly want a host that has excellent customer support. Customer support can come in various forms, from email support to phone support. Ultimately the best choice here comes down to your preference and the way you’re most comfortable communicating. Either way, you’ll want a host that has [24/7 customer support](https://www.atlantic.net/press-releases/atlantic-net-begins-offering-247-customer-service/).
We’ll even go so far as to say that if the host you’re looking at doesn’t offer 24/7 support, then you should just move on to the next one. We can’t stress how important it is to have timely access to help in a situation where your website has a problem. Similarly, check out reviews for the customer support of the host you want to join and make sure the customer service representatives are actually helpful.
## What to Avoid
### Unmanaged Servers
While we’ve flagged this as a potential issue with a host, it may not be if you have experience in managing servers. On the other hand, if you’re reading this article, it’s likely you are entering the world of servers and hosting for the first time and therefore might possibly not be comfortable with server management.
As such, we’d generally suggest getting a managed service, either as a plain VPS or managed WordPress VPS. Setting up a website can be frustrating if you don’t have experience with it, and knowing how to handle working and managed server can certainly help build experience with websites in the long run.
Another option is to select a VPS hosting provider that also provides professional services so if you ever hit a tough spot, you can engage with the hosting parnter as a consultant to get you over that hurdle you are facing. That said, if you feel comfortable with an unmanaged server, go for it!
### VPS vs Dedicated Hosting
While most people will probably start out with relatively cheap VPS hosting, at some point they almost always need to scale up in both hardware *and* cost. As such, you may want to consider whether [dedicated hosting](https://www.atlantic.net/dedicated-server-hosting/what-is-dedicated-server-hosting/) works better for you than VPS hosting. You can certainly find both at similar price points, even in the hundreds or thousands of dollars, and so it’s important to make sure you’re purchasing the right service.
### Cheap Hosting
Far be it from us to tell you how you should spend your money, but the truth of the matter is that you get what you pay for.
If you find a VPS hosting service in the free to $5 a month range, it’s likely not going to be great and you’re more than likely to run into problems. Not only that, but you’re probably giving up something important to get to that price point, such as 24/7 customer support.
As such, we’d advise against any VPS service that costs less than $10 or so, since that’s really the lower bound of what we’d consider good entry-level VPS hosting.
## Conclusion
While VPS hosting may seem complicated when you first start exploring hosting, don’t let it scare you off. It’s incredibly versatile, and when you add WordPress management into the mix, it can be an empowering tool for those who are just starting out with hosting their own website. More importantly, keep in mind that WordPress VPS hosting is a very flexible service and you can tier up and down in terms of cost depending on your budget and your needs.
Hopefully, after reading this you have a better idea of what to look for when it comes to a good WordPress VPS host!
---
# How to Install Chatwoot on Ubuntu 20.04
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-chatwoot-on-ubuntu-20-04/ | Published: 2021-02-23 | Updated: 2023-11-15 | Author: Hitesh Jethva
Chatwoot is an open-source customer support tool for real-time messaging channels. It is like other commercial customer support software like Intercorn & Zendesk. Chatwoot is designed to provide a great customer experience and to increase the productivity of your support team. Chatwoot allows you to integrate social media chat including WhatsApp, Twitter, Facebook and Email to a central place.
In this tutorial, we will explain how to install **Chatwoot** on Ubuntu 20.04.
## Step 1 – Install Chatwoot
You can install Chatwoot easily by downloading its automated installation script.
You can download it with the following command:
```
apt install git -y
git clone https://github.com/chatwoot/chatoot.git
cd chatwoot/deployment/
bash setup_20.04.sh -O setup.sh
```
```
```
**Note: the install process will take several minutes.**
Once the installation has been completed successfully, you should get the following output:
```
Woot! Woot!! Chatwoot server installation is complete
The server will be accessible at http://:3000
To configure a domain and SSL certificate, follow the guide at
https://www.chatwoot.com/docs/deployment/deploy-chatwoot-in-linux-vm
```
You can also verify the status of the Chatwoot service with the following command:
```
systemctl status chatwoot.target
```
You should get the following output:
- ```
chatwoot.target
Loaded: loaded (/etc/systemd/system/chatwoot.target; enabled; vendor preset: enabled)
Active: active since Mon 2021-01-11 07:13:25 UTC; 2min 20s ago
```
```
Jan 11 07:13:25 ubuntu2004 systemd[1]: Reached target chatwoot.target.
```
By default, Chatwoot listens on port 3000. You can verify it with the following command:
```
ss -antpl | grep 3000
```
You should see the following output:
```
LISTEN 0 1024 0.0.0.0:3000 0.0.0.0:* users:(("ruby",pid=57666,fd=8))
```
## Step 2 – Configure Nginx as a Reverse Proxy
Next, you will need to install and configure Nginx as a reverse proxy for Chatwoot.
First, install the Nginx with the following command:
```
apt-get install nginx -y
```
Once the Nginx has been installed, create a new Nginx virtual host configuration file with the following command:
```
nano /etc/nginx/conf.d/chatwoot.conf
```
Add the following lines:
```
server {
server_name chatwoot.example.com;
# Point upstream to Chatwoot App Server
set $upstream 127.0.0.1:3000;
# Nginx strips out underscore in headers by default
# Chatwoot relies on underscore in headers for API
# Make sure that the config is turned on.
underscores_in_headers on;
location /.well-known {
alias /var/www/ssl-proof/chatwoot/.well-known;
}
location / {
proxy_pass_header Authorization;
proxy_pass http://$upstream;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Forwarded-Ssl on; # Optional
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_http_version 1.1;
proxy_set_header Connection “”;
proxy_buffering off;
client_max_body_size 0;
proxy_read_timeout 36000s;
proxy_redirect off;
}
listen 80;
```
}
Save and close the file, then verify Nginx for any syntax errors with the following command:
```
nginx -t
```
If you get this error:
```
nginx: [emerg] could not build server_names_hash, you should increase
server_names_hash_bucket_size: 32
```
Do the following:
```
nano /etc/nginx/nginx.conf
```
In the http block, add:
```
server_names_hash_bucket_size 64;
```
Next, restart the Nginx to apply the configuration changes:
```
systemctl reload nginx
```
## Step 3 – Access Chatwoot
Now, open your web browser and access the Chatwoot web interface using the URL **http://chatwoot.example.com**. You will be redirected to the following page:
Click on the **Create new account** button. You should see the following page:
Provide your username and email and click on the **Submit** button. You should see the Chatwoot dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed Chatwoot on Ubuntu 20.04. You can now use Chatwoot to integrate all your social accounts and manage them from a central location. Try it using a [dedicated server](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# Top Healthcare Technology and Compliance Trends in 2021
> URL: https://www.atlantic.net/hipaa-compliant-hosting/top-healthcare-technology-and-compliance-trends-in-2021/ | Published: 2021-02-23 | Updated: 2025-09-19 | Author: Dr. Rachael Bailey
The year 2020 saw a rapid acceleration in the development and uptake of new healthcare technologies, largely due to the global COVID-19 pandemic. Nascent technologies, such as telehealth solutions and AI chatbots, quickly became essential as the world united in its fight against coronavirus.
As the pandemic continues to unfold, will we see a surge in digital health technologies through 2021? Innovation in digital health will be key to resolving the pandemic and supporting economic recovery and growth. Here, we consider some of the trends in healthcare technology and compliance that can be expected in 2021.
## Accelerated Cloud Adoption Driven by the Need for Compliance and Telehealth
Cloud adoption within the healthcare industry has traditionally remained notoriously slow, due to concerns regarding data security and regulatory requirements, such as HIPAA and HITECH. Today, it is regulatory compliance that is driving the growth curve.
The COVID-19 pandemic has served to drive forward cloud adoption in order to address the changing needs of the healthcare sector. In 2021, we can expect more healthcare organizations to utilize the benefits of cloud-based infrastructure, to support remote consultations, improve collaboration, increase security and provide the scalability required for data storage.
Telehealth has played an essential role in ensuring that patients remain able to access vital healthcare services during the pandemic. Indeed, [43.5% of Medicare primary care visits](https://www.hhs.gov/about/news/2020/07/28/hhs-issues-new-report-highlighting-dramatic-trends-in-medicare-beneficiary-telehealth-utilization-amid-covid-19.html) were delivered via telehealth services in April 2020.
Telehealth solutions have allowed physicians to continue to offer primary care to patients while abiding with the necessary social distancing guidelines. Virtual consultations lessen the strain placed on healthcare services by limiting the use of valuable time and resources, including PPE, which has remained in short supply throughout the pandemic.
With high patient adoption rates, this telehealth boom looks set to continue long after the pandemic has ended.
## 5G, Geonomics and 3D Printing
These three technologies will surge in popularity in 2021, as 5G networks are already expanding across the globe at a rapid pace, and coverage will populate all cities and major towns quickly. The added network performance introduced with 5G will benefit telehealth significantly, improve teleconferencing capabilities, and give doctors greater flexibility with remote surgery, transferring medical files, and real-time monitoring of patients.
Genomic medicine will thrive in 2021, and advances will include using genomics to personalize care for diagnosis or decision making. 3D printing (bioprinting) advances will push genomics further to creating human cells and tissue for use in regenerative medicine.
## Artificial Intelligence and Machine Learning Powered Healthcare
The potential for AI/Machine Learning in healthcare is endless. AI has certainly proven valuable so far during the fight against coronavirus, powering scientific research, managing hospital bed capacities, triaging COVID-19 patients, and easing the burden of administrative duties via the use of AI-powered digital workers. AI solutions help to reduce costs, increase productivity, and, most importantly, improve patient outcomes.
In 2021, we can expect to see many more AI-powered solutions being deployed within the healthcare sector. With technological advancements, we will see a move to a personalized medicine model, steering away from the traditional “one size fits all” approach.
AI tools will enable physicians to select the appropriate treatment strategy for their patient, based on the analysis of unique information that may include biometrics, such as genetic data. As we move towards identifying many potential COVID-19 therapies and vaccines, AI tools can also help to speed up and cut the costs of the vital drug discovery process.
## Virtual and Augmented Reality
Virtual Reality (VR) and Augmented Reality (AR) technologies are helping to transform healthcare services. When used alongside telehealth solutions, VR/AR can enhance patient-physician interaction, improving diagnosis and treatment planning.
VR and AR technology also presents an invaluable tool for the education and surgical training of medical students. VR and AR tools show promise in improving visualization when gaining intravenous access or conducting spinal surgery and for helping patients with certain chronic conditions, for example, improving motor deficiencies in victims of stroke.
As the technology advances throughout 2021, we can expect to see progress in the use of VR/AR for these applications.
## Blockchain Technology
Increasing numbers of healthcare organizations are adopting blockchain technology to improve the security of data and enable secure interoperability and accessibility. The implementation of blockchain technologies is set to optimize the healthcare industry.
Replacing the conventional pharma supply chain management system with blockchain technology would help to overcome the issues surrounding counterfeit products, improving drug traceability and authenticity.
As we move towards building a more resilient healthcare system, the swift implementation of transformative technologies, such as blockchain, will become vital.
## Internet of Medical Things (IoTM)
The Internet of Medical Things (IoMT) refers to a system of connected medical applications and devices that serves to collect individual patient health and fitness data. [By 2026, the IoMT market is predicted to be worth USD 254,233.6 million](https://www.alltheresearch.com/report/166/internet-of-medical-things-market#:~:text=The%20global%20Internet%20of%20Medical,period%20(2016%2D2026).) .
While the adoption of wearable devices is soaring, IoMT will not be limited to such tools with the implementation of this technology for new applications set to occur throughout the coming year. Driven by advances in 5G technology, network coverage, and patient acceptance, we expect an upsurge in IoMT.
As the precision of device sensors improve, an increasing number of chronic conditions will be able to be effectively managed using IoMT. IoMT will enable remote patient monitoring to improve the accuracy and effectiveness of telehealth solutions, as well as providing a welcome boost to patient engagement.
## Big Data and Predictive Analytics
Leveraging the power of big data and predictive analytics to predict pandemics/epidemics, improve patient outcomes, and cure chronic disease has become more important than ever before.
The scale and quality of data available is growing as fast as the deployment of new technologies, and we must keep pace to ensure that we are using the right tools to obtain calculative and meaningful insights from this information.
Throughout 2021, all eyes will be watching keenly to see how advances in big data are used to gain real-time control of coronavirus and help in our fight against the current epidemiological crisis we find ourselves in.
## Post-Pandemic Focus on Cybersecurity
Cybersecurity was already incredibly important before the Covid-19 pandemic, but with remote working becoming commonplace and telehealth appointments increasing, cybersecurity must become the backbone of any healthcare in technology.
It has been essential for healthcare providers to carefully consider security and compliance requirements throughout 2020. While certain HIPAA compliance regulations were relaxed and waivers introduced during the pandemic, healthcare providers must still ensure that their services remain fully compliant wherever possible.
Some telehealth solutions are not fully HIPAA compliant and, as telemedicine becomes the norm, this is an issue that needs to be addressed in 2021.
## Atlantic.Net Healthcare Hosting Solutions
Atlantic.Net is an award-winning [HIPAA-compliant hosting](https://www.atlantic.net/hipaa-compliant-hosting/) provider, with over 30 years worth of experience. We provide effective hosting solutions to an extensive list of leading healthcare clients. [Contact our sales team today](https://www.atlantic.net/about-us/corporate-contact/#GetStarted) to find out how, heading through 2021, Atlantic.Net can help your organization to both meet and exceed HIPAA requirements, with a managed or unmanaged hosting solution that is customized to meet the needs of your business.
Learn more about our [HIPAA compliant web hosting](https://www.atlantic.net/hipaa-compliant-hosting/) and [HIPAA cloud hosting](https://www.atlantic.net/hipaa-compliant-hosting/) solutions.
---
# How to Install FiveM Game Server on Ubuntu
> URL: https://www.atlantic.net/vps-hosting/how-to-install-fivem-game-server-on-ubuntu/ | Published: 2021-02-24 | Updated: 2026-03-14 | Author: Hitesh Jethva
FiveM is a multiplayer game server that allows you to play on customized dedicated servers. It was specifically designed for creativity. You can create your server and make your dreams come true. It provides a set of tools to personalize the gameplay experience of your server. With FiveM, you can make anything, including roleplay, drifting, racing, deathmatch, or something completely original.
This tutorial will show you how to install FiveM on Ubuntu 20.04.
## Prerequisites
- A fresh Ubuntu 20.04 Server (at least 2GB RAM)
- A valid domain name pointed to your server IP
- A root password configured on your server
## Step 1 – Install Required Dependencies
Before starting, you will need to install some dependencies on your server. You can install all of them with the following commands:
```
apt-get update -y
```
```
apt-get install screen wget git -y
```
Once all the packages are installed, you can proceed to the next step.
## Step 2 – Install and Configure FiveM
First, create a directory for FiveM and download the latest version of FiveM inside the directory:
```
mkdir ~/fivem_server
cd ~/fivem_server
wget https://runtime.fivem.net/artifacts/fivem/build_proot_linux/master/6683-
0c5d71ad77873c159d7542a7e8314d9696c1b55b/fx.tar.xz
```
Once the download is completed, extract the downloaded file with the following command:
```
tar -xvf fx.tar.xz
```
Next, you must download the CFX server data to your system. You can download it with the following command:
```
git clone https://github.com/citizenfx/cfx-server-data ~/fivem_resources
```
Next, you will need to create a FiveM configuration file.
You can create it with the following command:
```
nano ~/fivem_resources/server.cfg
```
Add the following lines, including your FiveM Licence:
```
# Only change the IP if you’re using a server with multiple network interfaces, otherwise
change the port only.
endpoint_add_tcp "0.0.0.0:30120”
endpoint_add_udp "0.0.0.0:30120”
# These resources will start by default.
ensure mapmanager
ensure chat
ensure spawnmanager
ensure sessionmanager
ensure fivem
ensure hardcap
ensure rconlog
ensure scoreboard
# This allows players to use scripthook-based plugins such as the legacy Lambda Menu.
# Set this to 1 to allow scripthook. Do note that this does _not_ guarantee players won’t be
able to use external plugins.
sv_scriptHookAllowed 0
# Uncomment this and set a password to enable RCON. Make sure to change the password - it
should look like rcon_password "YOURPASSWORD”
#rcon_password "”
# A comma-separated list of tags for your server.
# For example:
# - sets tags "drifting, cars, racing”
# Or:
# - sets tags "roleplay, military, tanks”
sets tags "default”
# Set an optional server info and connecting banner image url.
# Size doesn’t matter, any banner sized image will be fine.
#sets banner_detail "https://url.to/image.png”
#sets banner_connecting "https://url.to/image.png”
# Set your server’s hostname
sv_hostname "FXServer, but unconfigured”
# Nested configs!
#exec server_internal.cfg
# Loading a server icon (96×96 PNG file)
#load_server_icon myLogo.png
# convars which can be used in scripts
set temp_convar "hey world!”
# Uncomment this line if you do not want your server to be listed in the server browser.
# Do not edit it if you *do* want your server listed.
#sv_master1 "”
# Add system admins
add_ace group.admin command allow # allow all commands
add_ace group.admin command.quit deny # but don’t allow quit
add_principal identifier.steam:110000100000000 group.admin # add the admin to the group
# Hide player endpoints in external log output.
sv_endpointprivacy true
# Server player slot limit (must be between 1 and 32, unless using OneSync)
sv_maxclients 32
# License key for your server (https://keymaster.fivem.net)
sv_licenseKey i1mqzvi2eukui85p8cb0uddanqsru2lk
```
Save and close the file when you are finished.
Next, you can start the FiveM server with the following command:
```
cd ~/fivem_resources && bash ~/fivem_server/run.sh +exec server.cfg
```
Once the server has started successfully, you should get the following output:
Note: This process will take several minutes to start
```
[------------------------------------------------------------------------------------------------------
--------------------------------] 0/315Server license key authentication succeeded. Welcome!
Authenticating with Nucleus...
[#####-------------------------------------------------------------------------------------------------
-------------------------------] 11/315 fff
cccc ff xx xx rr rr eee
cc ffff xx rrr r ee e
cc ff xx ... rr eeeee
ccccc ff xx xx ... rr eeeee
Authenticated with cfx.re Nucleus: https://hitj-e8q3pd.users.cfx.re/
[###############################-----------------------------------------------------------------------------
-------------------------] 74/315-- [server notice: tebex_not_set]
================
Monetize your server using Tebex! Visit https://tebex.io/fivem for more info.
================
```
Press **CTRL + C** to stop the server.
## Step 3 – Create a Systemd Service File for FiveM
Creating a systemd service file to manage the FiveM service is a good idea. You can create it with the following command:
```
nano /lib/systemd/system/fivem.service
```
Add the following lines:
```
[Unit]
Description=FiveM server
[Service]
Type=forking
User=root
ExecStart=/usr/bin/fivem_start.sh
[Install]
WantedBy=multi-user.target
```
Save and close the file, then create a FiveM start script:
```
nano /usr/bin/fivem_start.sh
```
```
Add the following lines:
#!/bin/bash
screen -dm bash -c 'cd /root/fivem_resources && bash /root/fivem_server/run.sh +exec
server.cfg'
```
Save and close the file, then set proper permission:
```
chmod +x /usr/bin/fivem_start.sh
```
Next, reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start FiveM and enable it to start at system reboot:
```
systemctl start fivem
systemctl enable fivem
```
You can verify the status of FiveM with the following command:
systemctl status five
You should get the following output:
- ```
fivem.service - FiveM server
```
```
Loaded: loaded (/lib/systemd/system/fivem.service; disabled; vendor preset: enabled)
Active: active (running) since Wed 2021-01-13 15:09:13 UTC; 6s ago
Process: 24132 ExecStart=/usr/bin/fivem_start.sh (code=exited, status=0/SUCCESS)
Main PID: 24136 (screen)
Tasks: 67 (limit: 4691)
Memory: 48.1M
CGroup: /system.slice/fivem.service
├─24136 SCREEN -dm bash -c cd /root/fivem_resources && bash /root/fivem_server/run.sh +exec server.cfg
├─24148 /root/fivem_server/alpine/opt/cfx-server/ld-musl-x86_64.so.1 --
library-path /root/fivem_server/alpine/usr/lib/v8/:/root/f>
└─24151 /root/fivem_server/alpine/opt/cfx-server/ld-musl-x86_64.so.1 --
library-path /root/fivem_server/alpine/usr/lib/v8/:/root/f>
Jan 13 15:09:13 ubuntu2004 systemd[1]: Starting FiveM server...
Jan 13 15:09:13 ubuntu2004 systemd[1]: Started FiveM server.
```
By default, FiveM listens on port 30120. You can check it with the following command:
```
ss -antpl | grep 30120
```
You should get the following output:
```
LISTEN 0 128 0.0.0.0:30120 0.0.0.0:* users:(("ld-musl-x86_64.",pid=24148,fd=57))
```
## Step 4 – Manage Your FiveM Server with txAdmin
Once your FiveM server is running, you can [set up txAdmin](https://gravelhost.com/index.php?rp=/knowledgebase/90/Setting-up-txAdmin-for-your-FiveM-server.html) to manage the server using a web-based dashboard. txAdmin comes built into the FXServer platform and provides a graphical interface that makes server administration much easier compared to managing everything from the terminal.
Instead of stopping and restarting the server manually through SSH, you can log into the txAdmin panel from a browser and control most server operations from a single interface. This is especially helpful for community servers where administrators need to monitor activity, manage players, and maintain server stability.
One of the most useful features of txAdmin is the real-time server monitoring dashboard. The panel displays server performance metrics such as CPU usage, memory consumption, player count, and resource activity. This information helps administrators identify performance issues quickly and maintain smooth gameplay for connected players.
## Conclusion
Congratulations! You have successfully installed and configured a FiveM game server on Ubuntu 20.04. You can now download the FiveM client on your desktop system and play using FiveM on your [virtual private server](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
Learn more about our [VPS hosting](https://www.atlantic.net/vps-hosting/) services and [Virtual private servers.](https://www.atlantic.net/vps-hosting/)
---
# How to Install Elasticsearch Ubuntu 20.04 and CentOS 8
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-elasticsearch-ubuntu-20-04-and-centos-8/ | Published: 2021-02-25 | Updated: 2023-11-16 | Author: Hitesh Jethva
[jumpbox]
## Update your Server
Once you are logged in to your Ubuntu 20.04 server, run the following command to update your base system with the latest available packages.
```
apt-get update -y
```
You can also update your CentOS 8 system with the following command:
```
dnf update -y
```
Elasticsearch is an open-source, distributed search engine that allows you to store and analyze a large amount of data. It is specially designed for complex search requirements. It uses a simple set of APIs that provide the ability for full-text search. Elasticsearch is the best choice for you if you are looking to search a large, complex dataset.
In this tutorial, we will show you how to install Elasticsearch on Ubuntu 20.04 and CentOS 8.
## Install Elasticsearch on Ubuntu 20.04
In this section, we will show you how to install Elasticsearch on Ubuntu 20.04.
First, you will need to install all the required dependencies to your server. You can install them with the following command:
```
apt-get install apt-transport-https ca-certificates gnupg2 curl -y
```
Once all the dependencies are installed, add the Elasticsearch GPG key with the following command:
```
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
```
Next, add the Elasticsearch repository to APT with the following command:
```
sh -c 'echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" >
/etc/apt/sources.list.d/elastic-7.x.list'
```
Once the repository is added, update the repository and install Elasticsearch with the following command:
```
apt-get update -y
apt-get install elasticsearch -y
```
Once the installation is completed, start Elasticsearch and enable it to start at system reboot:
```
systemctl start elasticsearch
systemctl enable elasticsearch
```
You can now verify Elasticsearch with the following command:
```
curl -X GET "localhost:9200/"
```
You should get the following output:
```
{
"name" : "ubuntu2004",
"cluster_name" : "elasticsearch",
"cluster_uuid" : "PKpCl7VJT6G8q8SxR7m6DQ",
"version" : {
"number" : "7.10.1",
"build_flavor" : "default",
"build_type" : "deb",
"build_hash" : "1c34507e66d7db1211f66f3513706fdf548736aa",
"build_date" : "2020-12-05T01:00:33.671820Z",
"build_snapshot" : false,
"lucene_version" : "8.7.0",
"minimum_wire_compatibility_version" : "6.8.0",
"minimum_index_compatibility_version" : "6.0.0-beta1"
},
"tagline" : "You Know, for Search"
}
```
## Install Elasticsearch on CentOS 8
In this section, we will show you how to install Elasticsearch on CentOS 8.
First, install Java and other required dependencies with the following command:
```
dnf install java-11-openjdk-devel curl
```
Once the installation is completed, verify the Java version with the following command:
```
java -version
```
You should get the following output:
```
openjdk version "11.0.9.1" 2020-11-04 LTS
OpenJDK Runtime Environment 18.9 (build 11.0.9.1+1-LTS)
OpenJDK 64-Bit Server VM 18.9 (build 11.0.9.1+1-LTS, mixed mode, sharing)
```
Next, import the Elasticsearch GPG key with the following command:
```
rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
```
Next, create a repo file for Elasticsearch with the following command:
```
nano /etc/yum.repos.d/elasticsearch.repo
```
Add the following lines:
```
[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
```
Save and close the file, then install Elasticsearch with the following command:
```
dnf install elasticsearch -y
```
Once the installation is completed, start the Elasticsearch service and enable it to start at system reboot with the following command:
```
systemctl start elasticsearch
systemctl enable elasticsearch
```
You can now verify the status of the Elasticsearch service with the following command:
```
systemctl status elasticsearch
```
You should get the following output:
- ```
elasticsearch.service - Elasticsearch
```
```
Loaded: loaded (/usr/lib/systemd/system/elasticsearch.service; disabled; vendor preset: disabled)
Active: active (running) since Mon 2021-01-11 03:04:19 EST; 8s ago
Docs: https://www.elastic.co
Main PID: 1801 (java)
Tasks: 65 (limit: 12523)
Memory: 1.2G
CGroup: /system.slice/elasticsearch.service
├─1801 /usr/share/elasticsearch/jdk/bin/java -Xshare:auto -Des.networkaddress.cache.ttl=60
-Des.networkaddress.cache.negative.ttl=1>
└─1986 /usr/share/elasticsearch/modules/x-pack-ml/platform/linux-x86_64/bin/controller
Jan 11 03:03:50 centos8 systemd[1]: Starting Elasticsearch...
Jan 11 03:04:19 centos8 systemd[1]: Started Elasticsearch.
```
Next, run the following command to verify Elasticsearch:
```
curl -X GET "localhost:9200/"
```
You should see the following output:
```
{
"name" : "centos8",
"cluster_name" : "elasticsearch",
"cluster_uuid" : "vFz_YYRvTAWC3AiaMP_ORA",
"version" : {
"number" : "7.10.1",
"build_flavor" : "default",
"build_type" : "rpm",
"build_hash" : "1c34507e66d7db1211f66f3513706fdf548736aa",
"build_date" : "2020-12-05T01:00:33.671820Z",
"build_snapshot" : false,
"lucene_version" : "8.7.0",
"minimum_wire_compatibility_version" : "6.8.0",
"minimum_index_compatibility_version" : "6.0.0-beta1"
},
"tagline" : "You Know, for Search"
}
```
## Conclusion
In the above guide, you learned how to install Elasticsearch on Ubuntu 20.04 and CentOS 8. You can now use Elasticsearch with your e-commerce store application on your [dedicated server hosting](https://www.atlantic.net/dedicated-server-hosting/) plan from Atlantic.Net!
---
# How to Install and Use Checkmk Monitoring Server on Ubuntu 20.04
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-and-use-checkmk-monitoring-server-on-ubuntu-20-04/ | Published: 2021-02-26 | Updated: 2023-11-15 | Author: Hitesh Jethva
Checkmk is a monitoring software written in Python and C++. This self-contained tool combines with Nagios and its add-ons and can be used for monitoring your infrastructure and services. Checkmk works in client-server architecture, meaning you must install Checkmk agent on each computer that you want to monitor. With Checkmk, you can monitor web servers, database servers, and cloud infrastructure such as, Azure, AWS and more.
In this tutorial, we will show you how to install and use the Checkmk monitoring server on Ubuntu 20.04.
## Step 1 – Install Checkmk
By default, Checkmk is not included in the Ubuntu default repository, so you will need to download Checkmk package from its official website:
First, download the Checkmk with the following command:
```
wget https://download.checkmk.com/checkmk/1.6.0p20/check-mk-raw-
1.6.0p20_0.focal_amd64.deb
```
Once the download is completed, install the downloaded package with the following command:
```
dpkg -i check-mk-raw-1.6.0p20_0.focal_amd64.deb
```
Next, run the following command to install the required dependencies for Checkmk.
```
apt-get install -f
```
Once the installation has been completed, run the following command to list all commands available with Checkmk:
```
omd
```
You should get the following output:
```
Usage (called as root):
omd help Show general help
omd setversion VERSION Sets the default version of OMD which will be used by new sites
omd version [SITE] Show version of OMD
omd versions List installed OMD versions
omd sites Show list of sites
omd create SITE Create a new site (-u UID, -g GID)
omd init SITE Populate site directory with default files and enable the site
omd rm SITE Remove a site (and its data)
omd disable SITE Disable a site (stop it, unmount tmpfs, remove Apache hook)
omd enable SITE Enable a site (reenable a formerly disabled site)
omd mv SITE NEWNAME Rename a site
omd cp SITE NEWNAME Make a copy of a site
omd update SITE Update site to other version of OMD
omd start [SITE] [SERVICE] Start services of one or all sites
omd stop [SITE] [SERVICE] Stop services of site(s)
omd restart [SITE] [SERVICE] Restart services of site(s)
omd reload [SITE] [SERVICE] Reload services of site(s)
omd status [SITE] [SERVICE] Show status of services of site(s)
omd config SITE ... Show and set site configuration parameters
omd diff SITE ([RELBASE]) Shows differences compared to the original version files
omd su SITE Run a shell as a site-user
omd umount [SITE] Umount ramdisk volumes of site(s)
omd backup SITE [SITE] [-|ARCHIVE_PATH] Create a backup tarball of a site,
writing it to a file or stdout
omd restore [SITE] [-|ARCHIVE_PATH] Restores the backup of a site to an
existing site or creates a new site
omd cleanup Uninstall all Check_MK versions that are not used by any site.
General Options:
-V set specific version, useful in combination with update/create
omd COMMAND -h, --help show available options of COMMAND
```
## Step 2 – Create a Monitoring Instance
Next, you will need to create a monitoring instance for testing purposes. You can create it using the omd tool:
```
omd create myserver
```
You will should see the following output:
```
Adding /opt/omd/sites/myserver/tmp to /etc/fstab.
Creating temporary filesystem /omd/sites/myserver/tmp...OK
Restarting Apache...OK
Created new site myserver with version 1.6.0p20.cre.
The site can be started with omd start myserver.
The default web UI is available at http://ubuntu2004/myserver/
The admin user for the web applications is cmkadmin with password: RCDM5jQG
(It can be changed with 'htpasswd -m ~/etc/htpasswd cmkadmin' as site user.
)
Please do a su - myserver for administration of this site.
```
**Note:** Please remember the checkmk username and password from the above output. You will need it to access the Checkmk dashboard.
Next, start the server with the following command:
```
omd start myserver
```
You should get the following output:
```
Starting mkeventd...OK
Starting rrdcached...OK
Starting npcd...OK
Starting nagios...OK
Starting apache...OK
Initializing Crontab...OK
```
You can verify the status of the server with the following command:
```
omd status
```
You should get the following output:
```
Doing 'status' on site myserver:
mkeventd: running
rrdcached: running
npcd: running
nagios: running
apache: running
crontab: running
-----------------------
Overall state: running
```
To check the omd version, run the following command:
```
omd version
```
Output:
```
OMD - Open Monitoring Distribution Version 1.6.0p20.cre
```
You can also see your all monitoring instances with the following command:
```
omd sites
```
Output:
```
SITE VERSION COMMENTS
myserver 1.6.0p20.cre default version
```
## Step 3 – Access Checkmk Web Interface
Now, open your web browser and access the Checkmk web interface using the URL **http://your-server-ip/myserver**. You will be redirected to the Checkmk login page:
Provide your Checkmk username, password and click on the **Login** button. You should see the Checkmk dashboard in the following screen:
It is a good idea to change the default Checkmk password. Click on the WATO – Configuration in the left side and you should see the following screen:
Set your new password and click on the **Save** button to change the password.
## Step 4 – Create a Monitoring Host
Before starting, you will need to download and install the Checkmk monitoring agent on the server.
In the WATO – Configuration menu, click on the **Monitoring Agents**, you should see agent packages for all operating systems in the following page:
Pick the package for Ubuntu and download it with the following command:
```
wget http://45.58.38.223/myserver/check_mk/agents/check-mk-agent_1.6.0p20-1_all.deb
```
Once downloaded, install the agent package with the following command:
```
dpkg -i check-mk-agent_1.6.0p20-1_all.deb
```
Once the agent package is installed, you can verify it with the following command:
```
check_mk_agent | less
```
You should get the following output:
```
<<>>
Version: 1.6.0p20
AgentOS: linux
Hostname: ubuntu2004
AgentDirectory: /etc/check_mk
DataDirectory: /var/lib/check_mk_agent
SpoolDirectory: /var/lib/check_mk_agent/spool
PluginsDirectory: /usr/lib/check_mk_agent/plugins
LocalDirectory: /usr/lib/check_mk_agent/local
<<>>
```
In the WATO – Configuration menu, click on the **Hosts** button. You should see the following page:
Click on the **Create new host** button. You should see the following page:
Provide all required information and click on the **Save and go to Services** button. You should see all services in the following page:
## Conclusion
Congratulations! You have successfully installed and configured a Checkmk monitoring server on Ubuntu 20.04. You can now install Checkmk agents on the remote machines and start monitoring from the Checkmk web interface. Try it today using a [dedicated server](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to Install and Use Cockpit on Ubuntu 20.04
> URL: https://www.atlantic.net/dedicated-server-hosting/how-to-install-and-use-cockpit-on-ubuntu-20-04/ | Published: 2021-02-27 | Updated: 2023-11-15 | Author: Hitesh Jethva
The Cockpit is a web-based tool that helps system administrators perform day-to-day administrative tasks from a web browser. You can monitor system resources, create and remove user accounts, start and stop services, restart and shut down the system, and create and manage virtual boxes using the Cockpit. Cockpit makes it easier to administer your Linux server via a web-based interface.
## Step 1 – Install Cockpit
By default, the Cockpit package is included in the Ubuntu default repository. You can install it by just running the following command:
```
apt-get update -y
apt-get install cockpit -y
```
Once the Cockpit is installed, start the Cockpit service and enable it to start at system reboot:
```
systemctl start cockpit
systemctl enable cockpit
```
You can also verify the status of the Cockpit service with the following command:
```
systemctl status cockpit
```
You should get the following output:
```
cockpit.service - Cockpit Web Service
Loaded: loaded (/lib/systemd/system/cockpit.service; static; vendor preset>
Active: active (running) since Fri 2021-01-22 15:26:48 UTC; 4s ago
TriggeredBy: ● cockpit.socket
Docs: man:cockpit-ws(8)
Process: 7544 ExecStartPre=/usr/sbin/remotectl certificate --ensure --user=>
Main PID: 7552 (cockpit-tls)
Tasks: 1 (limit: 2353)
Memory: 2.0M
CGroup: /system.slice/cockpit.service
└─7552 /usr/lib/cockpit/cockpit-tls
Jan 22 15:26:48 ubuntu2004 systemd[1]: Starting Cockpit Web Service...
Jan 22 15:26:48 ubuntu2004 remotectl[7544]: Generating temporary certificate us>
Jan 22 15:26:48 ubuntu2004 remotectl[7544]: Error generating temporary dummy ce>
Jan 22 15:26:48 ubuntu2004 remotectl[7544]: Generating temporary certificate us>
Jan 22 15:26:48 ubuntu2004 systemd[1]: Started Cockpit Web Service.
```
At this point, Cockpit is started and listening on port 9090. You can verify it with the following command:
```
ss -antpl | grep 9090
```
You should see the following output:
```
LISTEN 0 4096 *:9090 *:* users:(("cockpit-
tls",pid=7552,fd=3),("systemd",pid=1,fd=101))
```
## Step 2 – Access Cockpit Web Interface
Now, open your web browser and access the Cockpit web interface using the URL **https://your-server-ip:9090**. You should see the Cockpit login page:
Provide your root username and password and click on the **Log in** button. You should see the Cockpit dashboard in the following page:
## Step 3 – How to Use Cockpit
You can also create and manage the virtual machine using Cockpit.
First, you will need to enable the virtual machine option in Cockpit. You can enable it with the following command:
```
apt-get install cockpit-machines -y
```
Once installed, log out and log in again, you should see the Virtual machine option in the following page:
Click on the **Create VM** button to create a virtual machine. You should see the following page:
Provide your VM name, operating system, RAM, and Disk and click on the **Create** button. Once the VM is created, you should see the following page:
Next, click on the **Console** tab, you should see the following page:
Click on the **Run** button to start the Virtual Machine. Once the VM is started, you should see the Virtual Machine login screen in the following page:
You can now login to VM using your root username and password.
## Step 4 – Manage Services and Logs
You can manage the system services and logs from the Cockpit web interface. In the Cockpit web interface, click on the **Services** button. You should see all system services in the following page:
From here, you can start, stop and disable the system services easily.
Click on the **Logs** button in the left pane and you should see all system logs in the following page:
If you want to access your server via terminal, click on the **Terminal** button. You should see the terminal windows in the following screen:
## Conclusion
Congratulations! You have successfully installed Cockpit on Ubuntu 20.04. You can now easily manage your server from its web-based interface. You can also use Cockpit on a [dedicated server](https://www.atlantic.net/dedicated-server-hosting/) from Atlantic.Net!
---
# How to Update Docker Container with Zero Downtime
> URL: https://www.atlantic.net/vps-hosting/how-to-update-docker-container-with-zero-downtime/ | Published: 2021-03-01 | Updated: 2023-11-27 | Author: Hitesh Jethva
In a Dockerized environment, you are using multiple images and working with many containers. When you run a container from an image, it continues running that version because Docker images do not update automatically. You may need to update it manually. It is always recommended to run a container from the latest Docker image.
In this guide, we will show you hands-on examples of how to update a running container with zero downtime.
## Step 1 – Install Docker CE and Docker Compose
First, install all required dependencies with the following command:
```
apt-get update -y
apt-get install git apt-transport-https ca-certificates curl software-properties-common -y
```
Next, add the Docker GPG key and repository with the following command:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
```
Once the repository has been added, install the Docker and Docker compose with the following command:
```
apt-get install docker-ce docker-compose -y
```
Once both packages are installed, you can proceed to the next step.
## Step 2 – Create a Docker Compose File
For the purpose of this tutorial, we will create a docker network, volume, and a docker-compose.yml file to deploy a Ghost container.
First, create a network named net and volume named ghost using the following command:
```
docker network create net
docker volume create ghost
```
Next, create a directory for the Ghost project with the following command:
```
mkdir Ghost
```
Next, change the directory to Ghost and create a docker-compose.yml file:
```
cd Ghost
nano docker-compose.yml
```
Add the following lines:
```
version: '3.5'
services:
ghost:
image: ghost:3.36
volumes:
- ghost:/var/lib/ghost/content
environment:
- VIRTUAL_HOST=ghost.example.com
- url=http://ghost.example.com
- NODE_ENV=production
restart: always
networks:
- net
volumes:
ghost:
external: true
networks:
net:
external: true
```
Save and close the file when you are finished.
The above file will download the Ghost image version 3.36 and create a Ghost container for domain ghost.example.com.
## Step 3 – Create a Ghost Container
Now, change the directory to Ghost and launch the Ghost container using the following command:
```
docker-compose up -d
```
You should get the following output:
```
Pulling ghost (ghost:3.36)...
3.36: Pulling from library/ghost
bb79b6b2107f: Pull complete
99ce436c3449: Pull complete
f7bdc31da5f5: Pull complete
7a1300b9ff59: Pull complete
a495c68fa838: Pull complete
6e362a39ec35: Pull complete
b68b4f3c36f7: Pull complete
41f8b02d4a71: Pull complete
3ecc736ea4e5: Pull complete
Digest: sha256:595c759980cd22e99037811397012908d89efb799776db222a4be6d4d892917c
Status: Downloaded newer image for ghost:3.36
Creating ghost_ghost_1 ... done
```
You can check the Ghost image with the following command:
```
docker images
```
Output:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
ghost 3.36 455ce1645479 4 months ago 440MB
```
You can also check the Ghost container with the following command:
```
docker ps
```
Output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
d4b51b1aafc8 ghost:3.36 "docker-entrypoint.s…" 23 seconds ago Up 20 seconds 2368/tcp ghost_ghost_1
```
## Step 4 – Update the Docker Compose File
In this section, we will update the Docker compose file and change the Ghost version from 3.36 to 3.37.1:
```
nano docker-compose.yml
```
Make the following changes:
```
version: '3.5'
services:
ghost:
image: ghost:3.37.1
volumes:
- ghost:/var/lib/ghost/content
environment:
- VIRTUAL_HOST=ghost.example.com
- url=http://ghost.example.com
- NODE_ENV=production
restart: always
networks:
- net
volumes:
ghost:
external: true
networks:
net:
external: true
```
Save and close the file when you are finished.
## Step 5 – Launch a New Ghost Container
Now, we will use the scaling method to create a new Ghost container without affecting the older Ghost container. You can do it with the following command:
```
cd Ghost
docker-compose up -d --scale ghost=2 --no-recreate
```
You should get the following output:
```
Pulling ghost (ghost:3.37.1)...
3.37.1: Pulling from library/ghost
bb79b6b2107f: Already exists
99ce436c3449: Already exists
7f4b5e228565: Pull complete
de71eab7febf: Pull complete
29961d2eb573: Pull complete
923f84e249ab: Pull complete
dfad6f73fc3d: Pull complete
b16cf83b3022: Pull complete
387b2254843c: Pull complete
Digest: sha256:fad0c2631cbba3d6c61da6fa5ef39da201780f2ae64ce51f3d5ebb412ca2564b
Status: Downloaded newer image for ghost:3.37.1
Starting ghost_ghost_1 ... done
Creating ghost_ghost_2 ... done
```
You can check the new Ghost image with the following command:
```
docker images
```
Output:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
ghost 3.37.1 c64d108acdfe 3 months ago 439MB
ghost 3.36 455ce1645479 4 months ago 440MB
```
You can also check the new Ghost container with the following command:
```
docker ps
```
Output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c21550f39440 ghost:3.37.1 "docker-entrypoint.s…" 33 seconds ago Up 31 seconds 2368/tcp ghost_ghost_2
d4b51b1aafc8 ghost:3.36 "docker-entrypoint.s…" 4 minutes ago Up 4 minutes 2368/tcp ghost_ghost_1
```
## Step 6 – Scale the New Ghost Container
At this point, both Ghost containers are running using the same configuration. Now, we will stop and remove the old Ghost container.
```
docker container stop ghost_ghost_1
docker container rm ghost_ghost_1
```
Now, run the following command to scale down the configuration to its original setting:
```
cd Ghost
docker-compose up -d --scale ghost=1 --no-recreate
```
You can also check the new Ghost container log for more information.
```
docker logs ghost_ghost_2
```
Output:
```
[2021-03-05 04:50:13] INFO Blog is in maintenance mode.
[2021-03-05 04:50:13] INFO Ghost is running in production...
[2021-03-05 04:50:13] INFO Your site is now available on http://ghost.example.com/
[2021-03-05 04:50:13] INFO Ctrl+C to shut down
[2021-03-05 04:50:13] INFO Ghost boot 3.581s
[2021-03-05 04:50:13] INFO Creating database backup
[2021-03-05 04:50:13] INFO Database backup written to: /var/lib/ghost/content/data/ghost.ghost.2021-03-05-04-50-13.json
[2021-03-05 04:50:13] INFO Updating portal button setting to false
[2021-03-05 04:50:13] INFO Blog is out of maintenance mode.
```
Your Ghost container is now updated with a new Ghost image.
## Conclusion
In the above guide, you learned how to update the Docker container without any downtime. Get started with updating your Docker container on [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Dockerize Python Applications With Miniconda
> URL: https://www.atlantic.net/vps-hosting/how-to-dockerize-python-applications-with-miniconda/ | Published: 2021-03-02 | Updated: 2023-11-18 | Author: Hitesh Jethva
Python is a popular general-purpose programming language used for a wide variety of applications. It is used by software developers as a support language for build control and management, testing, and other purposes.
Docker is an open-source containerized platform that allows you to run your application in a lightweight container. This way your application runs in exactly the same manner as it will in production using the same operating system.
In this post, we will show you how to dockerize Python applications with Miniconda on CentOS 8.
## Step 1 – Install Docker CE
By default, the latest version of Docker CE is not included in the CentOS 8 default repo, so you will need to add a repo from Docker’s official website.
You can add it with the following command:
```
dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
```
Once the repo is created, run the following command to install the Docker CE on your system.
```
dnf install docker-ce --nobest
```
Once the installation is finished, start the Docker service and enable it to start at system reboot with the following command:
```
systemctl start docker
systemctl enable docker
```
Next, verify the installed version of Docker with the following command:
```
docker --version
```
You should get the following output:
```
Docker version 20.10.5, build 55c4c88
```
## Step 2 – Create a Docker File to Deploy Python App
In this section, we will create a directory for the Python project and create a Dockerfile with all required information to deploy the Python app.
First, create a directory with the following command:
```
mkdir project
```
Next, change the directory to project and create a Dockerfile with the following command:
```
cd project
nano Dockerfile
```
Add the following lines:
```
FROM python:slim
RUN apt-get update && apt-get -y upgrade \
&& apt-get install -y --no-install-recommends \
git \
wget \
g++ \
ca-certificates \
&& rm -rf /var/lib/apt/lists/*
ENV PATH="/root/miniconda3/bin:${PATH}"
ARG PATH="/root/miniconda3/bin:${PATH}"
RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \
&& mkdir /root/.conda \
&& bash Miniconda3-latest-Linux-x86_64.sh -b \
&& rm -f Miniconda3-latest-Linux-x86_64.sh \
&& echo "Running $(conda --version)" && \
conda init bash && \
. /root/.bashrc && \
conda update conda && \
conda create -n python-app && \
conda activate python-app && \
conda install python=3.6 pip && \
echo 'print("Hello World!")' > python-app.py
RUN echo 'conda activate python-app \n\
alias python-app="python python-app.py"' >> /root/.bashrc
ENTRYPOINT [ "/bin/bash", "-l", "-c" ]
CMD ["python python-app.py"]
```
Save and close the file when you are finished.
The above file will download Python minimal image, install Miniconda, create a Python environment, and create a simple Hello World application.
## Step 3 – Build the Python Application Image
Now, you will need to build the image using the Dockerfile that we have created in the previous step.
First, change the directory to project with the following command:
```
cd project
```
Next, build the Python application by running the following command:
```
docker build -t python-app .
```
You should get the following output:
```
Downloading and Extracting Packages
setuptools-52.0.0 | 724 KB | ########## | 100%
certifi-2020.12.5 | 140 KB | ########## | 100%
python-3.6.13 | 29.7 MB | ########## | 100%
pip-21.0.1 | 1.8 MB | ########## | 100%
Preparing transaction: ...working... done
Verifying transaction: ...working... done
Executing transaction: ...working... done
Removing intermediate container 10f97804ad82
---> 3662950574f9
Step 6/8 : RUN echo 'conda activate python-app \nalias python-app="python python-app.py"' >> /root/.bashrc
---> Running in faab9e188650
Removing intermediate container faab9e188650
---> 8ee98d205c5c
Step 7/8 : ENTRYPOINT [ "/bin/bash", "-l", "-c" ]
---> Running in 3e74eb8fd8b7
Removing intermediate container 3e74eb8fd8b7
---> 6c6d83dfd01f
Step 8/8 : CMD ["python python-app.py"]
---> Running in 4d8c066aeefc
Removing intermediate container 4d8c066aeefc
---> 78e4f8e7e05e
Successfully built 78e4f8e7e05e
Successfully tagged python-app:latest
```
You can now check the downloaded images with the following command:
```
docker images
```
You should see all images in the following output:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
python-app latest 78e4f8e7e05e 24 seconds ago 907MB
python slim ce689abb4f0d 10 days ago 118MB
```
## Step 4 – Launch the Container
At this, point the Python application image is ready. You can now launch the container from the python-app image with the following command:
```
docker run python-app
```
You should see the output of your python application in the following output:
```
Hello World!
```
You can also connect to your Python application container and run the application.
To do so, run the container again with the following command:
```
docker run -it python-app /bin/bash
```
You will be connected to the python-app container as shown below:
```
(python-app) root@42e627b899fe:/#
```
Now, run your Python Hello World application using the following command:
```
(python-app) root@42e627b899fe:/# python-app
```
You should get the following output:
```
Hello World!
```
You can also verify your Python version using the following command:
```
(python-app) root@42e627b899fe:/# python --version
```
Output:
```
Python 3.6.13 :: Anaconda, Inc.
```
You can now exit from the container with the following command:
```
(python-app) root@42e627b899fe:/# exit
```
## Conclusion
In the above guide, you learned how to dockerize a Python application with Miniconda on CentOS 8. Now you can deploy your Python application in a lightweight and containerized environment on your [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
---
# Atlantic.Net Named to CRN’s Managed Service Provider 500 List
> URL: https://www.atlantic.net/press-releases/atlantic-net-named-to-crns-managed-service-provider-500-list/ | Published: 2021-03-02 | Updated: 2026-03-02 | Author: Editorial Team
ORLANDO, FLA—March 2, 2021—Atlantic.Net has been named to CRN’s Managed Service Provider 500 list as an MSP Pioneer 250.
Atlantic.Net was recognized amongst the **Pioneer 250 list** of top MSPs for 2021 for their continually growing suite of **technological solutions in the cloud** **and for** **providing exceptional services** to small and medium-sized businesses.
CRN’s annual MSP500 list recognizes North American solution providers with innovative approaches to managed services. The list is divided into 3 categories, including The **MSP Pioneer 250,** *t*he **MSP Elite 150**, and the **Managed Security 100.** Every year, The Channel Co. releases its list of top 500 Managed Service providers, which ranks the leading IT channel partner organizations across North America. The CRN Solution Provider 500 list serves as the industry’s leading identifier of top-performing technology integrators and service providers. The MSP 500 list was featured in the February 2021 issue of CRN and online at [www.CRN.com/msp500](https://www.crn.com/rankings-and-lists/msp2021.htm).
“We are pleased to be recognized by CRN as a top Pioneer MSP, which further solidifies our standing as a profitable and successful business for over 25 years without any outside funding,” said Marty Puranik, Founder and CEO of Atlantic.Net. “I am proud to be recognized for our continued growth and for our very own cloud platform that we worked very hard to build from the ground-up.”
**About The Channel Company**
The Channel Company enables breakthrough IT channel performance with our dominant media, engaging events, expert consulting and education, and innovative marketing services and platforms. As the channel catalyst, we connect and empower technology suppliers, solution providers, and end-users. Backed by more than 30 years of unequaled channel experience, we draw from our deep knowledge to envision innovative new solutions for ever-evolving challenges in the technology marketplace. [www.thechannelcompany.com](https://www.thechannelcompany.com/). © 2021. CRN is a registered trademark of The Channel Company, LLC. All rights reserved.
**About Atlantic.Net**
Atlantic.Net is a global [cloud services](https://www.atlantic.net/hipaa-compliant-hosting/) provider with over 25 years of experience, serving thousands of developers and small, medium, and large clients in more than one hundred countries. Atlantic.Net specializes in managed and non-managed Windows, Linux, and FreeBSD server hosting solutions and has served dynamic business clients including Lenovo, Newegg, NASA, and Hilton, among others. With a focus on security, compliance, and simplifying the user experience, Atlantic.Net provides business-class dedicated and cloud hosting solutions, backed by 24/7/365 support in New York, London, San Francisco, Toronto, Dallas, Ashburn, and Orlando. For more information, please visit [Atlantic Net](https://www.atlantic.net/).
---
# Postfix Mail Server Setup on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/postfix-mail-server-setup-on-ubuntu-20-04/ | Published: 2021-03-03 | Updated: 2023-11-18 | Author: Hitesh Jethva
 Verified and tested 02/27/2021
### Introduction
In this how-to article, we will walk you through building a complete mail server on Ubuntu 20.04 with Postfix. Building a Linux mail server from ground up can be a painful process unless you do it day in and day out, but we are going to show you how to do it as painlessly as we can.
A mail server usually consists of a range of different packages that handle SMTP, POP3/IMAP, storage of the mail, and spam-related tasks, and they must all talk together. Here is an outline of the packages and goals for this how-to article.
## 1 – Basic Server Preparation
The base installation of Ubuntu comes with a limited set of packages, so the first thing we want to do is install the tools we’ll be using to complete all tasks.
First, make sure that you are logged in as the root user account.
```
sudo su -
```
Now, let’s install the basic tools so that we can download files, and edit configuration files easily.
```
apt-get install wget nano ssl-cert
```
> - **wget**: package for retrieving files using HTTP, HTTPS and FTP, the most widely-used Internet protocols.
> - **nano**: command line text editor with easy to use controls.
> - **ssl-cert**: package that enables the ability to create SSL certificates.
Next, we are going to update the hostname and domain name of the server so that when you send email it will match the reverse pointer DNS record that we set up with your hosting provider. We will also update the `/etc/hostname` file. Make sure to replace example with your real hostname and domain name.
```
hostnamectl set-hostname email.linuxbuz.com
```
Now we are going to manually edit the `/etc/hosts` configuration file so that it matches the name we just entered.
```
nano /etc/hosts
```
Edit the first line and add your FQDN (fully qualified domain name) just after the 127.0.0.1 IP address.
```
127.0.0.1 email.linuxbuz.com localhost
```
We are now going to update the default SSL certificate on the server so that it matches our new hostname. If you purchased an SSL certificate for your mail server, you can skip this step.
```
make-ssl-cert generate-default-snakeoil --force-overwrite
```
This command tells the server to regenerate the default system SSL certificate and forces it to overwrite the original CRT and KEY files.
We have now completed the Basic Server Preparation and can move on to installing our web server services.
[Back to top]
## 2 – Build out the LAMP Web Server
During this step, we are going to install the “LAMP” packages. LAMP stands for Linux, Apache, MySQL, and PHP. These packages combined will enable your server to provide dynamic web services with MySQL connectivity.
First, let’s install the packages. This is called a task package installation.
```
apt-get install lamp-server^
```
> To see a list of the packages that are included in this group install, you can execute the following:
>
> ```
> tasksel --task-packages lamp-server
> ```
After all the packages are installed, we will be ready to install some additional PHP modules. These additional modules will enable your server to support APC User Cache for PHP 5, memcached, cURL, an XML parser, and GD image processing.
```
apt-get install php-apcu php-memcache php-curl php-mbstring php-gd php-xml php-imap php-xmlrpc libdbi-perl libdbd-mysql-perl -y
```
Next, you will need to set the MySQL root password and secure the MySQL installation. You can do it with the following command:
```
mysql_secure_installation
```
Answer all the questions as shown below:
```
New password:
Re-enter new password:
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y
Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y
Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y
Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y
```
Next, log in to MySQL and change the password policy to low:
```
mysql -u root -p
SET GLOBAL validate_password.policy = 0;
FLUSH PRIVILEGES;
EXIT;
```
[Back to top]
## 3 – Configure PHP
We are now going to update the configuration of PHP. The default configuration is usually sufficient for most systems; however, we want to make sure that PHP does not expose information to potential attackers. We are going to edit the file `/etc/php/7.4/apache2/php.ini`.
```
nano /etc/php/7.4/apache2/php.ini
```
Locate the variable `expose_php` and update the value from `On` to `Off`. With nano, you can search by pressing `CTRL-W` and then enter your search word.
```
367 ;;;;;;;;;;;;;;;;;
368 ; Miscellaneous ;
369 ;;;;;;;;;;;;;;;;;
370
371 ; Decides whether PHP may expose the fact that it is installed on the server
372 ; (e.g. by adding its signature to the Web server header). It is no security
373 ; threat in any way, but it makes it possible to determine whether you use PHP
374 ; on your server or not.
375 ; http://php.net/expose-php
376 expose_php = Off
377
```
[Back to top]
## 4 – Configure Apache2
We are now ready to move on to customizing the configuration of the Apache web services. The end result for Apache is that it will serve a single website with a couple of running web applications: Webmail (RoundCube) and Postfix Admin. All traffic will be directed to HTTPS (secured) web services.
First, we are going to minimize the information that Apache exposes to the public. Using nano, we are going to edit the configuration file `/etc/apache2/conf-available/security.conf`.
```
nano /etc/apache2/conf-available/security.conf
```
Search for the configuration variable `ServerTokens` and set the value from `OS` to `Prod`.
```
# ServerTokens
# This directive configures what you return as the Server HTTP response
# Header. The default is 'Full' which sends information about the OS-Type
# and compiled in modules.
# Set to one of: Full | OS | Minimal | Minor | Major | Prod
# where Full conveys the most information, and Prod the least.
#ServerTokens Minimal
ServerTokens Prod
#ServerTokens Full
```
Now search for the configuration variable `ServerSignature` and set the value from `On` to `Off`.
```
# Optionally add a line containing the server version and virtual host
# name to server-generated pages (internal error documents, FTP directory
# listings, mod_status and mod_info output etc., but not CGI generated
# documents or custom error documents).
# Set to "EMail" to also include a mailto: link to the ServerAdmin.
# Set to one of: On | Off | EMail
ServerSignature Off
#ServerSignature On
```
You can now save and exit this configuration file.
We are now going to enable the additional modules `rewrite` and `ssl` in Apache so that we can redirect default HTTP traffic to the HTTPS port as well as support SSL certificates within Apache.
```
a2enmod rewrite ssl
a2ensite default-ssl
```
We are now moving on to customize the website configuration. These files are located in the directory `/etc/apache2/sites-available`. We are going to update the existing default configuration files to support SSL services.
First, edit the configuration file `000-default.conf`. You can replace the existing configuration with the below, just replace the `ServerName` variable with your hostname.
```
nano /etc/apache2/sites-available/000-default.conf
```
```
# The ServerName directive sets the request scheme, hostname and port that
# the server uses to identify itself. This is used when creating
# redirection URLs. In the context of virtual hosts, the ServerName
# specifies what hostname must appear in the request's Host: header to
# match this virtual host. For the default virtual host (this file) this
# value is not decisive as it is used as a last resort host regardless.
# However, you must set it for any further virtual host explicitly.
ServerName email.linuxbuz.com
DocumentRoot /var/www/html
Options FollowSymLinks
AllowOverride All
# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
# error, crit, alert, emerg.
# It is also possible to configure the loglevel for particular
# modules, e.g.
LogLevel info ssl:warn
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
# For most configuration files from conf-available/, which are
# enabled or disabled at a global level, it is possible to
# include a line for only one particular virtual host. For example the
# following line enables the CGI configuration for this host only
# after it has been globally disabled with "a2disconf".
#Include conf-available/serve-cgi-bin.conf
```
You can now save and exit this configuration file.
If you have not purchased your own SSL certificate, the system default SSL configuration file `default-ssl.conf` will work for our needs. However, if you have purchased a custom SSL certificate, you will need to edit the configuration file and update the variables `SSLCertificateFile`, `SSLCertificateKeyFile` and `SSLCertificateChainFile` to point to the location where you have saved your certificate and key files (consult your certificate authority or vendor for additional configuration assistance).
We are now going to create an `.htaccess` configuration file that will force visitors to your web server to use the HTTPS (SSL) protocol.
```
nano /var/www/html/.htaccess
```
Copy and paste the following variables into the `.htaccess` configuration.
```
RewriteEngine On
RewriteCond %{SERVER_PORT} 80
RewriteRule ^(.*) https://%{HTTP_HOST}/$1 [L]
```
These configuration variables tell Apache to enable the mod_rewrite engine, and then to redirect visitors on HTTP (port 80) to the HTTPS (port 443) URL.
[Back to top]
## 5 – Install and Configure Memcached
Memcached is a high-performance, distributed memory object caching system. This package will help speed up dynamic web applications, such as RoundCube and Postfix Webadmin.
First, let’s install the package using apt-get.
```
apt-get install memcached
```
For smaller systems, the default configuration is usually sufficient. It locks down access to the localhost and provides sufficient memory allocation values. However, if you are building a larger server that may get heavy usage, you will most likely want to change the memory allocation values to be higher than the default of 64M.
The memcached configuration files is located at `/etc/memcached.conf`.
[Back to top]
## 6 – Install the Mailserver Packages
We are now ready to install the mail server packages. Again, these are located in a `tasksel` package group.
```
apt-get install mail-server^
```
> To see a list of the packages that are included in this group install, you can execute the following:
>
> ```
> tasksel --task-packages mail-server
> ```
During the package installation, Postfix will ask you a series of questions:
1. Installation configuration type —
You will want to select “**Internet Site**” as the configuration type.
2. Hostname of the mail server —
Make sure to enter the same hostname (FQDN) that you used in Step #1
3. Create a self-signed SSL Certificate —
Select the ‘Yes’ option
4. Setup the SSL Certificate Common Name —
Enter the same hostname (FQDN) that you used in Step #1
We are now going to install the remainder of the packages that are needed for the mail server to support MySQL-based users as well as the Spam and AntiVirus detection packages. (Note: these packages could be installed via a single `apt-get install` command, with each package name separated by a space, but they are presented here as separate commands for ease of reading.)
```
apt-get install postfix-mysql dovecot-mysql dovecot-imapd postgrey
apt-get install amavis clamav clamav-daemon spamassassin
apt-get install php-imap
```
This next set of optional packages extends the abilities of the anti-spam and antivirus detection packages by allowing greater inspection of attached files that come into your mail server.
```
apt-get install libnet-dns-perl pyzor razor
apt-get install arj bzip2 cabextract cpio file gzip nomarch pax unzip zip
```
Now, let’s restart the Apache2 services so that it will see the new modules we have provided it.
```
systemctl restart apache2
```
[Back to top]
## 7 – Creating a MySQL Database for the Email Server
We are now ready to create the database for our user accounts and other mail server functions.
To begin, we need to log into the MySQL database service as the root user. You will need that password that you first entered in Step #2.
```
mysql -u root -p
```
You will now see a different command line prompt (`mysql>`). This is the MySQL CLI console where you can manage your MySQL server databases and tables.
First, we are going to create a new database named “mail”, and then we will create a system user account with full permissions to this new database. Make sure to replace the `` variable with another *new* secure password for this account. *Do not use the same password that you used for the root user account*.
```
CREATE DATABASE mail;
CREATE USER 'mail'@'localhost' IDENTIFIED BY 'mypassword';
GRANT ALL PRIVILEGES ON mail.* TO 'mail'@'localhost' WITH GRANT OPTION;
FLUSH PRIVILEGES;
EXIT;
```
We have now setup the database that will be used by your mail server services.
[Back to top]
## 8 – Installing Postfix Admin
[Postfix Admin](https://postfixadmin.sourceforge.net/) is a web-based management tool created for Postfix. It is a PHP-based application that handles Postfix-style virtual domains and users that are stored in MySQL or PostgreSQL.
First, we need to download the latest release of the application. This example will download version 2.92–*always check [the version on the provider’s website](https://postfixadmin.sourceforge.net/) to make sure you are getting the latest release*.
```
wget https://excellmedia.dl.sourceforge.net/project/postfixadmin/postfixadmin-3.3.1/PostfixAdmin%203.3.1.tar.gz
```
We are now going to extract the application and copy it to the HTML directory `/var/www/html/postfixadmin` on our server.
```
tar -xvf PostfixAdmin%203.3.1.tar.gz
mv postfixadmin-postfixadmin-cc23eba /var/www/html/postfixadmin
```
Now we need to create a template directory and update the permissions of this new folder so that the `www-data` user account has access to it.
```
mkdir /var/www/html/postfixadmin/templates_c
chown -R www-data:www-data /var/www/html/postfixadmin
```
[Back to top]
## 9 – Configuring Postfix Admin
We now have some configurations to update in the Postfix Admin files. First, we will modify the `config.inc.php` file so that it knows how to communicate with the database that we just created in Step #7.
```
nano /var/www/html/postfixadmin/config.inc.php
```
Search for the variable `'configured'` and reset the value from `false` to `true`.
```
$CONF['configured'] = true;
```
Now search for the variable `'database_'` and replace the values for your MySQL server configuration. Make sure to replace the variable `mypassword` with the password for the database user “mail” that you entered in Step #7.
```
$CONF['database_type'] = 'mysqli';
$CONF['database_host'] = 'localhost';
$CONF['database_user'] = 'mail';
$CONF['database_password'] = 'mypassword';
$CONF['database_name'] = 'mail';
```
Now search for the variable `'admin_email'` and replace the value with the email address you will setup for your administrator email account.
```
$CONF['admin_email'] = 'admin@linuxbuz.com';
```
Now search for the variable `'domain_path'` and replace the value from ‘`YES`‘ to ‘`NO`‘.
```
$CONF['domain_path'] = 'NO';
```
Now search for the variable `'domain_in_mailbox'` and replace the value from ‘`NO`‘ to ‘`YES`‘.
```
$CONF['domain_in_mailbox'] = 'YES';
```
These last configuration variables do not define the path to where the actual user mailbox data will be stored on the server. These will be defined later during the Dovecot configuration steps.
You are now ready to save the configuration file, **but do not exit yet!**
We are now going to open a web browser enter the URL of your mail server, pointing directly to the `setup.php` configuration page. *Make sure to replace *mail.example.tld* with your real server hostname.*
```
https://email.linuxbuz.com/postfixadmin/public/setup.php
```
When you access the URL, the script will automatically check the server and confirm that all the prerequisite modules are installed and working.
 Postfix Admin setup checker output
Once the checks are completed, you will be prompted to enter a setup password. This password is used to create master admin accounts for the Postfix Admin web interface.
Enter a secure password and press the “Generate Password Hash” button.
 Postfix Admin generate password hash
 Postfix Admin example password hash
**Do NOT close the web browser yet! We are coming back here in a few minutes.**
After generating the password hash, we will then need to update the `config.inc.php` file again with this password. Search for the variable `'setup_password'` and replace the value with the one generated from the script.
```
// In order to setup Postfixadmin, you MUST specify a hashed password here.
// To create the hash, visit setup.php in a browser and type a password into the field,
// on submission it will be echoed out to you as a hashed value.
$CONF['setup_password'] = '';
```
You can now save and exit the configuration file.
We are now ready to return to the web browser and generate the “super admin” account for the Postfix Admin portal.
When you clicked the ‘Generate Password Hash’ button, the form fields changed to look like the example below. You can now fill out the form to generate a super admin account.
 Creating a superadmin account with Postfix Admin
You can also create an admin user with the following command:
```
bash /var/www/html/postfixadmin/scripts/postfixadmin-cli admin add superadmin@linuxbuz.com --superadmin 1 --active 1 --password password@123 --password2 password@123
```
You should get the following output:
```
Welcome to Postfixadmin-CLI v0.3
---------------------------------------------------------------
The admin superadmin@linuxbuz.com has been added!
---------------------------------------------------------------
```
[Back to top]
## 10 – Adding User Accounts (mailboxes) to Postfix Admin
We are now ready to create a virtual user account on our mail server. To do this, we will return to the Postfix Admin URL in our web browser and enter the URL of your mail server. *Make sure to replace *mail.example.tld* with your real server hostname.*
```
https://email.linuxbuz.com/postfixadmin/public
```
You will now be able to log in to the Postfix Admin portal where you can manage virtual domains and virtual user accounts. Enter the super admin username and password that you created above during the Postfix Admin configuration, and then press the “Login” button.
 Admin login for Postfix Admin
Once you are logged in to the Postfix Admin portal, you will see a menu at the top of the page.
The menu options provide the ability to manage your Postfix mail server virtual domains and users and to view log files.
 Postfix Admin menu  Postfix Admin Add Mailbox option
To create a user mailbox, click the quick link “Add Mailbox.” You will now be taken to the “Add Mailbox Wizard” screen. Fill out the details in the form and press the “Add Mailbox” button once completed. The wizard will create your first virtual user (mailbox) account.
 Creating a new mailbox in Postfix Admin
[Back to top]
## 11 – Create a System User To Handle Virtual Mail Directories
Virtual users are those that don’t technically exist on your Linux server, and they don’t use the standard Linux methods for authentication or mail delivery and storage. Your mail server virtual user accounts are defined within the database created by Postfix Admin rather than existing as system user accounts, so we have to create a single system user account that will handle services like mail storage and Dovecot authentication.
First, let’s create a system user account called `vmail` and give it permissions to the required directories. This system account will be responsible for the backend operations for mailbox storage and services.
```
useradd -r -u 150 -g mail -d /var/vmail -s /sbin/nologin -c "Virtual MailDir Handler" vmail
mkdir -p /var/vmail
chown vmail:mail /var/vmail
chmod 770 /var/vmail
```
An explanation of the above commands:
1. We created the system user account `vmail`, assigned the home directory as `/var/vmail`, and restricted the ability for this account to login via shell or console.
2. We then manually created the home directory `/var/vmail` for the new system user account.
3. We then set the owner and group for the `/var/vmail` directory.
4. We then gave full permissions to the system user `vmail` and the security group `mail` assigned to the directory `/var/vmail`.
[Back to top]
## 12 – Configuring Dovecot
Dovecot is an open-source IMAP and POP3 email server written with security in mind. Dovecot has many built-in features, which you can view at [their public website, http://www.dovecot.org](https://www.dovecot.org).
Dovecot will be responsible for managing the IMAP and POP3 connections, managing local mail directories, and receiving the incoming mail handed off from the Postfix SMTP mail server process. Dovecot will also manage the authentication for SMTP connections. Many different files within the `/etc/dovecot` directory handle Dovecot configuration.
First, let’s configure Dovecot to use the database set up by Postfix Admin. We will first edit the configuration file `/etc/dovecot/conf.d/auth-sql.conf.ext`
```
nano /etc/dovecot/conf.d/auth-sql.conf.ext
```
Edit or update the contents to have the following configuration.
```
# Look up user passwords from a SQL database as
# defined in /etc/dovecot/dovecot-sql.conf.ext
passdb {
driver = sql
args = /etc/dovecot/dovecot-sql.conf.ext
}
# Look up user information from a SQL database as
# defined in /etc/dovecot/dovecot-sql.conf.ext
userdb {
driver = sql
args = /etc/dovecot/dovecot-sql.conf.ext
}
```
Once done, save and exit the configuration file.
**SQL Configuration File**
Now we are going to back up the original SQL configuration file `/etc/dovecot/dovecot-sql.conf.ext` and create a new configuration file for Dovecot to use.
```
mv /etc/dovecot/dovecot-sql.conf.ext /etc/dovecot/dovecot-sql.conf.ext.original
nano /etc/dovecot/dovecot-sql.conf.ext
```
Now copy the below content into the configuration file and update the values for the mail database you set up in Step 7.
```
# Database driver: mysql, pgsql, sqlite
driver = mysql
# Database Connection:
# connect = host=192.168.1.1 dbname=users
# connect = host=sql.example.com dbname=virtual user=virtual password=blarg
# connect = /etc/dovecot/authdb.sqlite
#
connect = host=localhost dbname=mail user=mail password=mypassword
# Default password scheme.
#
# List of supported schemes is in
# http://wiki2.dovecot.org/Authentication/PasswordSchemes
#
# Weak but common encryption scheme:
default_pass_scheme = MD5-CRYPT
#
# Comment the above out and uncomment below
# for stronger encryption:
#default_pass_scheme - SHA256-CRYPT
# Define the query to obtain a user password.
password_query = \
SELECT username as user, password, '/var/vmail/%d/%n' as userdb_home, \
'maildir:/var/vmail/%d/%n' as userdb_mail, 150 as userdb_uid, 8 as userdb_gid \
FROM mailbox WHERE username = '%u' AND active = '1'
# Define the query to obtain user information.
user_query = \
SELECT '/var/vmail/%d/%n' as home, 'maildir:/var/vmail/%d/%n' as mail, \
150 AS uid, 8 AS gid, concat('dirsize:storage=', quota) AS quota \
FROM mailbox WHERE username = '%u' AND active = '1'
```
Once done, save and exit this configuration file.
**Authentication Definition File**
We are now going to back up the authentication definition file `/etc/dovecot/conf.d/10-auth.conf` and create a new one.
```
mv /etc/dovecot/conf.d/10-auth.conf /etc/dovecot/conf.d/10-auth.conf.original
nano /etc/dovecot/conf.d/10-auth.conf
```
Now copy the below content into the definition file.
```
# Disable LOGIN command and all other plaintext authentications unless
# SSL/TLS is used (LOGINDISABLED capability). Note that if the remote IP
# matches the local IP (ie. you're connecting from the same computer), the
# connection is considered secure and plaintext authentication is allowed.
disable_plaintext_auth = yes
# Space separated list of wanted authentication mechanisms:
# plain login digest-md5 cram-md5 ntlm rpa apop anonymous gssapi otp skey
# gss-spnego
# NOTE: See also disable_plaintext_auth setting.
auth_mechanisms = plain login
##
## Password and user databases
##
#
# Password database is used to verify user's password (and nothing more).
# You can have multiple passdbs and userdbs. This is useful if you want to
# allow both system users (/etc/passwd) and virtual users to login without
# duplicating the system users into virtual database.
#
#
#
# User database specifies where mails are located and what user/group IDs
# own them. For single-UID configuration use "static" userdb.
#
#
# Use the SQL database configuration rather than any of the others.
!include auth-sql.conf.ext
```
Once done, save and exit the file.
**Mail Definition File**
Next, we are going to tell Dovecot where to store the virtual users’ mail. We will be backing up the mail definition file `/etc/dovecot/conf.d/10-mail.conf` and creating a new one.
```
mv /etc/dovecot/conf.d/10-mail.conf /etc/dovecot/conf.d/10-mail.conf.original
nano /etc/dovecot/conf.d/10-mail.conf
```
Now copy the below content into the definition file.
```
# Location for users' mailboxes. The default is empty, which means that Dovecot
# tries to find the mailboxes automatically. This won't work if the user
# doesn't yet have any mail, so you should explicitly tell Dovecot the full
# location.
#
# If you're using mbox, giving a path to the INBOX file (eg. /var/mail/%u)
# isn't enough. You'll also need to tell Dovecot where the other mailboxes are
# kept. This is called the "root mail directory", and it must be the first
# path given in the mail_location setting.
#
# There are a few special variables you can use, eg.:
#
# %u - username
# %n - user part in user@domain, same as %u if there's no domain
# %d - domain part in user@domain, empty if there's no domain
# %h - home directory
#
# See doc/wiki/Variables.txt for full list. Some examples:
#
# mail_location = maildir:~/Maildir
# mail_location = mbox:~/mail:INBOX=/var/mail/%u
# mail_location = mbox:/var/mail/%d/%1n/%n:INDEX=/var/indexes/%d/%1n/%n
#
#
#
mail_location = maildir:/var/vmail/%d/%n
# System user and group used to access mails. If you use multiple, userdb
# can override these by returning uid or gid fields. You can use either numbers
# or names.
mail_uid = vmail
mail_gid = mail
# Valid UID range for users, defaults to 500 and above. This is mostly
# to make sure that users can't log in as daemons or other system users.
# Note that denying root logins is hardcoded to dovecot binary and can't
# be done even if first_valid_uid is set to 0.
#
# Use the vmail user uid here.
first_valid_uid = 150
last_valid_uid = 150
# If you need to set multiple mailbox locations or want to change default
# namespace settings, you can do it by defining namespace sections.
#
# You can have private, shared and public namespaces. Private namespaces
# are for user's personal mails. Shared namespaces are for accessing other
# users' mailboxes that have been shared. Public namespaces are for shared
# mailboxes that are managed by sysadmin. If you create any shared or public
# namespaces you'll typically want to enable ACL plugin also, otherwise all
# users can access all the shared mailboxes, assuming they have permissions
# on filesystem level to do so.
namespace inbox {
# Namespace type: private, shared or public
#type = private
# Hierarchy separator to use. You should use the same separator for all
# namespaces or some clients get confused. '/' is usually a good one.
# The default however depends on the underlying mail storage format.
#separator =
# Prefix required to access this namespace. This needs to be different for
# all namespaces. For example "Public/".
#prefix =
# Physical location of the mailbox. This is in same format as
# mail_location, which is also the default for it.
#location =
# There can be only one INBOX, and this setting defines which namespace
# has it.
inbox = yes
# If namespace is hidden, it's not advertised to clients via NAMESPACE
# extension. You'll most likely also want to set list=no. This is mostly
# useful when converting from another server with different namespaces which
# you want to deprecate but still keep working. For example you can create
# hidden namespaces with prefixes "~/mail/", "~%u/mail/" and "mail/".
#hidden = no
# Show the mailboxes under this namespace with LIST command. This makes the
# namespace visible for clients that don't support NAMESPACE extension.
# "children" value lists child mailboxes, but hides the namespace prefix.
#list = yes
# Namespace handles its own subscriptions. If set to "no", the parent
# namespace handles them (empty prefix should always have this as "yes")
#subscriptions = yes
}
```
Once done, save and exit the file.
**SSL Definition File**
If you have an SSL certificate that you would like to install, you will need to modify the Dovecot SSL definition file `/etc/dovecot/conf.d/10-ssl.conf` with your valid certificate. Remember, you will have to also include your CA certificate bundle if one has been provided by the certificate issuer.
**Dovecot Master Definition File**
We are now going to update the Dovecot master definition file `/etc/dovecot/10-master.conf` to include the system user account and the postfix settings.
```
nano /etc/dovecot/conf.d/10-master.conf
```
Search for the config definition `service auth` and replace the definition block with the following.
```
service auth {
# auth_socket_path points to this userdb socket by default. It's typically
# used by dovecot-lda, doveadm, possibly imap process, etc. Users that have
# full permissions to this socket are able to get a list of all usernames and
# get the results of everyone's userdb lookups.
#
# The default 0666 mode allows anyone to connect to the socket, but the
# userdb lookups will succeed only if the userdb returns an "uid" field that
# matches the caller process's UID. Also if caller's uid or gid matches the
# socket's uid or gid the lookup succeeds. Anything else causes a failure.
#
# To give the caller full permissions to lookup all users, set the mode to
# something else than 0666 and Dovecot lets the kernel enforce the
# permissions (e.g. 0777 allows everyone full permissions).
unix_listener auth-userdb {
mode = 0600
user = vmail
group = mail
}
# Postfix smtp-auth
unix_listener /var/spool/postfix/private/auth {
mode = 0660
# Assuming the default Postfix userid and groupid
user = postfix
group = postfix
}
}
```
Once done, save and exit the file.
**LDA Definition File**
In some cases, you may have to explicitly define the postmaster email address for your server. To do this, you will need to edit the LDA definition file `/etc/dovecot/conf.d/15-lda.conf`. If you see error messages like `Invalid settings: postmaster_address setting not given` showing up in the mail server logs, then this configuration change is the likely fix for that error.
```
nano /etc/dovecot/conf.d/15-lda.conf
```
Search for the definition `postmaster_address` and update the value to include your domain’s postmaster account.
```
# Address to use when sending rejection mails.
# Default is postmaster@. %d expands to recipient domain.
#postmaster_address =
postmaster_address = postmaster@linuxbuz.com
```
Once done, save and exit the file.
We now need to update the Dovecot configuration directory to be accessible to the Dovecot service account as well as the vmail system account.
```
chown -R vmail:dovecot /etc/dovecot
chmod -R o-rwx /etc/dovecot
```
You have now completed the configuration of the Dovecot service and we can now move on to the antivirus and anti-spam services.
[Back to top]
## 13 – Configuring Amavis, ClamAV, and SpamAssassin
What are these packages?
– [Amavis](https://amavis.sourceforge.net/) is an interface between Postfix and content filtering packages such as SpamAssassin and ClamAV.
– [ClamAV](https://www.clamav.net/) is a high-performance antivirus engine for detecting trojans, viruses, malware & other malicious threats.
– [SpamAssassin](https://spamassassin.apache.org/) is a high-performance anti-spam platform famous for its Bayesian spam filtering capabilities. It gives system administrators a filter to classify messages and block unsolicited bulk email.
We will now walk you through the process of installing some protection for your mail server. For the most part, the default configurations are sufficient for a good line of defense against spam and viruses getting through your mail server. If you have special requirements, you can, of course, spend a good amount of time crafting intricate processing rules.
Let’s first create the two system user accounts, amavis and clamav, and allow them to collaborate together.
```
adduser clamav amavis
adduser amavis clamav
```
We are now going to enable the Amavis daemon by editing the `/etc/amavis/conf.d/15-content_filter_mode` configuration file.
```
nano /etc/amavis/conf.d/15-content_filter_mode
```
By default, the Amavis software is disabled. To enable the Amavis software, all you need to do is remove the comment tags from the `bypass` configuration lines.
```
use strict;
# You can modify this file to re-enable SPAM checking through spamassassin
# and to re-enable antivirus checking.
#
# Default antivirus checking mode
# Please note, that anti-virus checking is DISABLED by
# default.
# If You wish to enable it, please uncomment the following lines:
@bypass_virus_checks_maps = (
%bypass_virus_checks, @bypass_virus_checks_acl, $bypass_virus_checks_re);
#
# Default SPAM checking mode
# Please note, that anti-spam checking is DISABLED by
# default.
# If You wish to enable it, please uncomment the following lines:
@bypass_spam_checks_maps = (
%bypass_spam_checks, @bypass_spam_checks_acl, $bypass_spam_checks_re);
1; # ensure a defined return
```
Once done, you can save and exit the file.
We are now going to enable the SpamAssassin software by editing the `/etc/default/spamassassin` configuration file.
```
nano /etc/default/spamassassin
```
Now search for the variable `CRON=0` in the configuration file and change the value to 1.
```
# Cronjob
# Set to anything but 0 to enable the cron job to automatically update
# spamassassin's rules on a nightly basis
CRON=1
```
Next, enable the SpamAssassin software with the following command:
```
update-rc.d spamassassin enable
```
We are now going to set up Amavis to use the database from Postfix Admin to identify mail that is arriving for local delivery. By default, SpamAssassin and Amavis will only check mail that is determined to be arriving for local delivery. Because we are set up to use virtual user mailboxes, we have to tell the services where to locate the user accounts.
To do this, we need to update the configuration file `/etc/amavis/conf.d/50-user`.
```
nano /etc/amavis/conf.d/50-user
```
Replace the contents of this configuration file with the below. Be sure to update the MySQL database password to use the password for the database user “mail” that you entered in Step #7.
```
use strict;
#
# Place your configuration directives here. They will override those in
# earlier files.
#
# See /usr/share/doc/amavisd-new/ for documentation and examples of
# the directives you can use in this file
#
# Three concurrent processes. This should fit into the RAM available on an
# AWS micro instance. This has to match the number of processes specified
# for Amavis in /etc/postfix/master.cf.
$max_servers = 3;
# Add spam info headers if at or above that level - this ensures they
# are always added.
$sa_tag_level_deflt = -9999;
# Check the database to see if mail is for local delivery, and thus
# should be spam checked.
@lookup_sql_dsn = (
['DBI:mysql:database=mail;host=127.0.0.1;port=3306',
'mail',
'mypassword']);
$sql_select_policy = 'SELECT domain from domain WHERE CONCAT("@",domain) IN (%k)';
# Uncomment to bump up the log level when testing.
# $log_level = 2;
#------------ Do not modify anything below this line -------------
1; # ensure a defined return
```
Once done, save and exit the configuration file.
We will now need to restart the Amavis and SpamAssassin services so that they see the new configuration settings.
```
service amavis restart
services spamassassin restart
```
[Back to top]
## 14 – Configuring Postfix
We are now ready to configure the Postfix mail server. Postfix handles all of the incoming and outgoing mail via the SMTP protocol, and we are going to configure it to integrate will all of the other software packages that we have just configured.
From a high level view, we are needing Postfix to hand off incoming mail to the SpamAssassin and ClamAV scanners for filtering, and then to pass unblocked mail messages on to the Dovecot services for final mailbox delivery. Postfix will also authenticate the virtual users who connect via SMTP in order to send email messages.
We are going to create a definition file for Postfix to identify users and mailboxes. Please note that the “hosts” directive in these configuration files must be exactly the same as the “bind-address” in the `/etc/mysql/my.cnf` configuration files.
First, let’s look up the value of the bind-address in the MySQL configuration files.
```
cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep bind-address
```
```
<< output >>
bind-address = 127.0.0.1
```
Now that we have the configuration value, we are going to create the required Postfix definition files.
Copy and paste the content for each file. Make sure to update the password value with the password for the database user “mail” that you entered in Step #7.
#### /etc/postfix/mysql_virtual_
#### alias_domainaliases_maps.cf
/etc/postfix/mysql_virtual_alias_maps.cf
```
user = mail
password = mypassword
hosts = 127.0.0.1
dbname = mail
query = SELECT goto FROM alias,alias_domain WHERE alias_domain.alias_domain = '%d' AND alias.address=concat('%u', '@', alias_domain.target_domain) AND alias.active = 1
```
Once done, save and exit the configuration file.
#### /etc/postfix/
#### mysql_virtual_alias_maps.cf
```
nano /etc/postfix/mysql_virtual_alias_maps.cf
```
```
user = mail
password = mypassword
hosts = 127.0.0.1
dbname = mail
table = alias
select_field = goto
where_field = address
additional_conditions = and active = '1'
```
Once done, save and exit the configuration file.
#### /etc/postfix/
#### mysql_virtual_domains_maps.cf
```
user = mail
password = mypassword
hosts = 127.0.0.1
dbname = mail
table = domain
select_field = domain
where_field = domain
additional_conditions = and backupmx = '0' and active = '1'
```
Once done, save and exit the configuration file.
#### /etc/postfix/mysql_virtual
#### _mailbox_domainaliases_maps.cf
```
user = mail
password = mypassword
hosts = 127.0.0.1
dbname = mail
query = SELECT maildir FROM mailbox, alias_domain
WHERE alias_domain.alias_domain = '%d'
AND mailbox.username=concat('%u', '@', alias_domain.target_domain )
AND mailbox.active = 1
```
Once done, save and exit the configuration file.
#### /etc/postfix/mysql_
#### virtual_mailbox_maps.cf
```
user = mail
password = mypassword
hosts = 127.0.0.1
dbname = mail
table = mailbox
select_field = CONCAT(domain, '/', local_part)
where_field = username
additional_conditions = and active = '1'
```
Once done, save and exit the configuration file.
We are now going to create the Postfix header-checking directives. These directives remove certain headers when relaying mail through the system. This helps improve privacy for sending users by removing specific headers like origin IP Address and the mail software identifiers. Copy and paste the below content into the file.
```
nano /etc/postfix/header_checks
```
```
/^Received:/ IGNORE
/^User-Agent:/ IGNORE
/^X-Mailer:/ IGNORE
/^X-Originating-IP:/ IGNORE
/^x-cr-[a-z]*:/ IGNORE
/^Thread-Index:/ IGNORE
```
Once done, save and exit.
We are now ready to make some changes to the system default Postfix `/etc/postfix/main.cf` configuration file.
> This file contains a large amount of complex choices and options for a Postfix server installation. It is far beyond the scope of this article to explain every option or best practice available, so we strongly suggest that you read through the Postfix configuration options `/usr/share/postfix/main.cf.dist` or the [software vendor online manual](https://www.postfix.org/postconf.5.html). O’Reilly has also published a very good book named [*Postfix: The Definitive Guide*](https://shop.oreilly.com/product/9780596002121.do).
First, we are going to create a backup of the original `main.cf` configuration file and then create a new copy of the file.
```
mv /etc/postfix/main.cf /etc/postfix/main.cf.original
nano /etc/postfix/main.cf
```
Now, copy the below content into the `/etc/postfix/main.cf` configuration file.
```
# See /usr/share/postfix/main.cf.dist for a commented, more complete version
# The first text sent to a connecting process.
smtpd_banner = $myhostname ESMTP $mail_name
biff = no
# appending .domain is the MUA's job.
append_dot_mydomain = no
readme_directory = no
# SASL parameters
# ---------------------------------
# Use Dovecot to authenticate.
smtpd_sasl_type = dovecot
# Referring to /var/spool/postfix/private/auth
smtpd_sasl_path = private/auth
smtpd_sasl_auth_enable = yes
broken_sasl_auth_clients = yes
smtpd_sasl_security_options = noanonymous
smtpd_sasl_local_domain =
smtpd_sasl_authenticated_header = yes
# TLS parameters
# ---------------------------------
# Replace this with your SSL certificate path if you are using one.
smtpd_tls_cert_file=/etc/ssl/certs/ssl-cert-snakeoil.pem
smtpd_tls_key_file=/etc/ssl/private/ssl-cert-snakeoil.key
# The snakeoil self-signed certificate has no need for a CA file. But
# if you are using your own SSL certificate, then you probably have
# a CA certificate bundle from your provider. The path to that goes
# here.
#smtpd_tls_CAfile=/path/to/ca/file
smtp_tls_note_starttls_offer = yes
smtpd_tls_loglevel = 1
smtpd_tls_received_header = yes
smtpd_tls_session_cache_timeout = 3600s
tls_random_source = dev:/dev/urandom
#smtpd_tls_session_cache_database = btree:${data_directory}/smtpd_scache
#smtp_tls_session_cache_database = btree:${data_directory}/smtp_scache
# Note that forcing use of TLS is going to cause breakage - most mail servers
# don't offer it and so delivery will fail, both incoming and outgoing. This is
# unfortunate given what various governmental agencies are up to these days.
# These are Postfix 2.2 only.
#
# Enable (but don't force) use of TLS on incoming smtp connections.
smtpd_use_tls = yes
smtpd_enforce_tls = no
# Enable (but don't force) use of TLS on outgoing smtp connections.
smtp_use_tls = yes
smtp_enforce_tls = no
# These are Postfix 2.3 and later.
#
# Enable (but don't force) all incoming smtp connections to use TLS.
smtpd_tls_security_level = may
# Enable (but don't force) all outgoing smtp connections to use TLS.
smtp_tls_security_level = may
# See /usr/share/doc/postfix/TLS_README.gz in the postfix-doc package for
# information on enabling SSL in the smtp client.
# SMTPD parameters
# ---------------------------------
# Uncomment the next line to generate "delayed mail" warnings
#delay_warning_time = 4h
# will it be a permanent error or temporary
unknown_local_recipient_reject_code = 450
# how long to keep message on queue before return as failed.
# some have 3 days, I have 16 days as I am backup server for some people
# whom go on holiday with their server switched off.
maximal_queue_lifetime = 7d
# max and min time in seconds between retries if connection failed
minimal_backoff_time = 1000s
maximal_backoff_time = 8000s
# how long to wait when servers connect before receiving rest of data
smtp_helo_timeout = 60s
# how many address can be used in one message.
# effective stopper to mass spammers, accidental copy in whole address list
# but may restrict intentional mail shots.
smtpd_recipient_limit = 16
# how many error before back off.
smtpd_soft_error_limit = 3
# how many max errors before blocking it.
smtpd_hard_error_limit = 12
# This next set are important for determining who can send mail and relay mail
# to other servers. It is very important to get this right - accidentally producing
# an open relay that allows unauthenticated sending of mail is a Very Bad Thing.
#
# You are encouraged to read up on what exactly each of these options accomplish.
# Requirements for the HELO statement
smtpd_helo_restrictions = permit_mynetworks, warn_if_reject reject_non_fqdn_hostname, reject_invalid_hostname, permit
# Requirements for the sender details
smtpd_sender_restrictions = permit_sasl_authenticated, permit_mynetworks, warn_if_reject reject_non_fqdn_sender, reject_unknown_sender_domain, reject_unauth_pipelining, permit
# Requirements for the connecting server
# This is primarily the RBL (Realtime Blacklist) Filtering
smtpd_client_restrictions = reject_rbl_client b.barracudacentral.org, reject_rbl_client zen.spamhaus.org, reject_rbl_client spam.dnsbl.sorbs.net
# Requirement for the recipient address. Note that the entry for
# "check_policy_service inet:127.0.0.1:10023" enables Postgrey.
smtpd_recipient_restrictions = reject_unauth_pipelining, permit_mynetworks, permit_sasl_authenticated, reject_non_fqdn_recipient, reject_unknown_recipient_domain, reject_unauth_destination, check_policy_service inet:127.0.0.1:10023, permit
smtpd_data_restrictions = reject_unauth_pipelining
# This is a new option as of Postfix 2.10+, and is required in addition to
# smtpd_recipient_restrictions for things to work properly in this setup.
smtpd_relay_restrictions = reject_unauth_pipelining, permit_mynetworks, permit_sasl_authenticated, reject_non_fqdn_recipient, reject_unknown_recipient_domain, reject_unauth_destination, check_policy_service inet:127.0.0.1:10023, permit
# require proper helo at connections
smtpd_helo_required = yes
# waste spammers time before rejecting them
smtpd_delay_reject = yes
disable_vrfy_command = yes
# General host and delivery info
# ----------------------------------
myhostname = email.linuxbuz.com
myorigin = /etc/hostname
# Some people see issues when setting mydestination explicitly to the server
# subdomain, while leaving it empty generally doesn't hurt. So it is left empty here.
# mydestination = mail.example.com, localhost
mydestination =
# If you have a separate web server that sends outgoing mail through this
# mailserver, you may want to add its IP address to the space-delimited list in
# mynetworks, e.g. as 111.222.333.444/32.
mynetworks = 127.0.0.0/8 [::ffff:127.0.0.0]/104 [::1]/128
mailbox_size_limit = 0
recipient_delimiter = +
inet_interfaces = all
mynetworks_style = host
# This specifies where the virtual mailbox folders will be located.
virtual_mailbox_base = /var/vmail
# This is for the mailbox location for each user. The domainaliases
# map allows us to make use of Postfix Admin's domain alias feature.
virtual_mailbox_maps = mysql:/etc/postfix/mysql_virtual_mailbox_maps.cf, mysql:/etc/postfix/mysql_virtual_mailbox_domainaliases_maps.cf
# and their user id
virtual_uid_maps = static:150
# and group id
virtual_gid_maps = static:8
# This is for aliases. The domainaliases map allows us to make
# use of Postfix Admin's domain alias feature.
virtual_alias_maps = mysql:/etc/postfix/mysql_virtual_alias_maps.cf, mysql:/etc/postfix/mysql_virtual_alias_domainaliases_maps.cf
# This is for domain lookups.
virtual_mailbox_domains = mysql:/etc/postfix/mysql_virtual_domains_maps.cf
# Integration with other packages
# ---------------------------------------
# Tell postfix to hand off mail to the definition for dovecot in master.cf
virtual_transport = dovecot
dovecot_destination_recipient_limit = 1
# Use amavis for virus and spam scanning
content_filter = amavis:[127.0.0.1]:10024
# Header manipulation
# --------------------------------------
# Getting rid of unwanted headers. See: https://posluns.com/guides/header-removal/
header_checks = regexp:/etc/postfix/header_checks
# getting rid of x-original-to
enable_original_recipient = no
```
Once done, save and exit.
We are now ready to move on to the Postfix `/etc/postfix/master.cf` configuration file. This configuration file also contains a large number of complex choices and options for a Postfix server installation that is far beyond the scope of this article to explain.
We are going to create a backup of the original `master.cf` configuration file and then create a new file.
```
mv /etc/postfix/master.cf /etc/postfix/master.cf.original
nano /etc/postfix/master.cf
```
Now, copy the below content into the `/etc/postfix/master.cf` configuration file.
```
#
# Postfix master process configuration file. For details on the format
# of the file, see the master(5) manual page (command: "man 5 master").
#
# Do not forget to execute "postfix reload" after editing this file.
#
# ==========================================================================
# service type private unpriv chroot wakeup maxproc command + args
# (yes) (yes) (yes) (never) (100)
# ==========================================================================
# SMTP on port 25, unencrypted.
smtp inet n - - - - smtpd
#smtp inet n - - - 1 postscreen
#smtpd pass - - - - - smtpd
#dnsblog unix - - - - 0 dnsblog
#tlsproxy unix - - - - 0 tlsproxy
# SMTP with TLS on port 587.
submission inet n - - - - smtpd
-o syslog_name=postfix/submission
-o smtpd_tls_security_level=encrypt
-o smtpd_sasl_auth_enable=yes
-o smtpd_enforce_tls=yes
-o smtpd_client_restrictions=permit_sasl_authenticated,reject_unauth_destination,reject
-o smtpd_sasl_tls_security_options=noanonymous
# SMTP over SSL on port 465.
smtps inet n - - - - smtpd
-o syslog_name=postfix/smtps
-o smtpd_tls_wrappermode=yes
-o smtpd_sasl_auth_enable=yes
-o smtpd_tls_auth_only=yes
-o smtpd_client_restrictions=permit_sasl_authenticated,reject_unauth_destination,reject
-o smtpd_sasl_security_options=noanonymous,noplaintext
-o smtpd_sasl_tls_security_options=noanonymous
#628 inet n - - - - qmqpd
pickup fifo n - - 60 1 pickup
-o content_filter=
-o receive_override_options=no_header_body_checks
cleanup unix n - - - 0 cleanup
qmgr fifo n - n 300 1 qmgr
#qmgr fifo n - n 300 1 oqmgr
tlsmgr unix - - - 1000? 1 tlsmgr
rewrite unix - - - - - trivial-rewrite
bounce unix - - - - 0 bounce
defer unix - - - - 0 bounce
trace unix - - - - 0 bounce
verify unix - - - - 1 verify
flush unix n - - 1000? 0 flush
proxymap unix - - n - - proxymap
proxywrite unix - - n - 1 proxymap
smtp unix - - - - - smtp
relay unix - - - - - smtp
# -o smtp_helo_timeout=5 -o smtp_connect_timeout=5
showq unix n - - - - showq
error unix - - - - - error
retry unix - - - - - error
discard unix - - - - - discard
local unix - n n - - local
virtual unix - n n - - virtual
lmtp unix - - - - - lmtp
anvil unix - - - - 1 anvil
scache unix - - - - 1 scache
#
# ====================================================================
# Interfaces to non-Postfix software. Be sure to examine the manual
# pages of the non-Postfix software to find out what options it wants.
#
# Many of the following services use the Postfix pipe(8) delivery
# agent. See the pipe(8) man page for information about ${recipient}
# and other message envelope options.
# ====================================================================
#
# maildrop. See the Postfix MAILDROP_README file for details.
# Also specify in main.cf: maildrop_destination_recipient_limit=1
#
maildrop unix - n n - - pipe
flags=DRhu user=vmail argv=/usr/bin/maildrop -d ${recipient}
#
# ====================================================================
#
# Recent Cyrus versions can use the existing "lmtp" master.cf entry.
#
# Specify in cyrus.conf:
# lmtp cmd="lmtpd -a" listen="localhost:lmtp" proto=tcp4
#
# Specify in main.cf one or more of the following:
# mailbox_transport = lmtp:inet:localhost
# virtual_transport = lmtp:inet:localhost
#
# ====================================================================
#
# Cyrus 2.1.5 (Amos Gouaux)
# Also specify in main.cf: cyrus_destination_recipient_limit=1
#
#cyrus unix - n n - - pipe
# user=cyrus argv=/cyrus/bin/deliver -e -r ${sender} -m ${extension} ${user}
#
# ====================================================================
# Old example of delivery via Cyrus.
#
#old-cyrus unix - n n - - pipe
# flags=R user=cyrus argv=/cyrus/bin/deliver -e -m ${extension} ${user}
#
# ====================================================================
#
# See the Postfix UUCP_README file for configuration details.
#
uucp unix - n n - - pipe
flags=Fqhu user=uucp argv=uux -r -n -z -a$sender - $nexthop!rmail ($recipient)
#
# Other external delivery methods.
#
ifmail unix - n n - - pipe
flags=F user=ftn argv=/usr/lib/ifmail/ifmail -r $nexthop ($recipient)
bsmtp unix - n n - - pipe
flags=Fq. user=bsmtp argv=/usr/lib/bsmtp/bsmtp -t$nexthop -f$sender $recipient
scalemail-backend unix - n n - 2 pipe
flags=R user=scalemail argv=/usr/lib/scalemail/bin/scalemail-store ${nexthop} ${user} ${extension}
mailman unix - n n - - pipe
flags=FR user=list argv=/usr/lib/mailman/bin/postfix-to-mailman.py
${nexthop} ${user}
# The next two entries integrate with Amavis for anti-virus/spam checks.
amavis unix - - - - 3 smtp
-o smtp_data_done_timeout=1200
-o smtp_send_xforward_command=yes
-o disable_dns_lookups=yes
-o max_use=20
127.0.0.1:10025 inet n - - - - smtpd
-o content_filter=
-o local_recipient_maps=
-o relay_recipient_maps=
-o smtpd_restriction_classes=
-o smtpd_delay_reject=no
-o smtpd_client_restrictions=permit_mynetworks,reject
-o smtpd_helo_restrictions=
-o smtpd_sender_restrictions=
-o smtpd_recipient_restrictions=permit_mynetworks,reject
-o smtpd_data_restrictions=reject_unauth_pipelining
-o smtpd_end_of_data_restrictions=
-o mynetworks=127.0.0.0/8
-o smtpd_error_sleep_time=0
-o smtpd_soft_error_limit=1001
-o smtpd_hard_error_limit=1000
-o smtpd_client_connection_count_limit=0
-o smtpd_client_connection_rate_limit=0
-o receive_override_options=no_header_body_checks,no_unknown_recipient_checks
# Integration with Dovecot - hand mail over to it for local delivery, and
# run the process under the vmail user and mail group.
dovecot unix - n n - - pipe
flags=DRhu user=vmail:mail argv=/usr/lib/dovecot/dovecot-lda -d $(recipient)
```
Once done, save and exit.
We are now ready to restart all of the mail services and test the server.
```
service postfix restart
service spamassassin restart
service clamav-daemon restart
service amavis restart
service dovecot restart
```
While testing your new mail server, make sure to watch the log files closely for any errors or unusual responses.
The mail server log files are located here:
- General Logging: `/var/log/mail.log`
- Error Logging: `/var/log/mail.err`
[Back to top]
## 15 – Reverse DNS Lookup
You will now need to set up reverse DNS lookup for your mail server.
Reverse DNS is IP-address-to-domain-name mapping – the opposite of forward (normal) DNS which maps domain names to IP addresses. Reverse DNS is mostly used by people for such things as tracking where a website visitor came from or where an email message originated, for example. Reverse DNS is also important for mail server applications. Many email servers on the Internet are configured to reject incoming emails from any IP address which does not have reverse DNS record configured.
Unless you also administer your own DNS server, you can update reverse DNS with your ISP (Internet Service Provider) or via the hosting provider of your server.
[Back to top]
## 16 – Install RoundCube Webmail
Now we are going to install the [RoundCube Webmail](https://roundcube.net/) application. This application will allow your remote users to connect to their mailbox through a web browser.
```
apt-get install roundcube roundcube-mysql roundcube-plugins roundcube-plugins-extra
```
During the installation process, the system will ask you the prerequisite install questions. Note: you will need the password for the MySQL *root* user you set up in Step 2.
```
Configure database for roundcube with dbconfig-common?
>> Select 'YES'
Database type to be used by roundcube:
>> Select 'mysql'
Password of the database's administrative user:
>> Enter the 'root' MySQL password that you created.
MySQL application password for roundcube:
>> Enter a new secure password for the RoundCube application to use.
```
Once you are finished with the pre-installation questions, you should see the following output. Double check the output to make sure there are not errors posted during the installation process.
```
dbconfig-common: writing config to /etc/dbconfig-common/roundcube.conf
Creating config file /etc/dbconfig-common/roundcube.conf with new version
Creating config file /etc/roundcube/debian-db.php with new version
granting access to database roundcube for roundcube@localhost: success.
verifying access for roundcube@localhost: success.
creating database roundcube: success.
verifying database roundcube exists: success.
populating database via sql... done.
dbconfig-common: flushing administrative password
Creating config file /etc/roundcube/config.inc.php with new version
apache2_invoke: Enable configuration roundcube.conf
* Reloading web server apache2
*
* Reloading web server apache2
*
Setting up roundcube (1.4.3) ...
Setting up roundcube-plugins (1.4.3) ...
Setting up roundcube-plugins-extra (0.9.2-20130819) ...
Processing triggers for dictionaries-common (1.20.5) ...
aspell-autobuildhash: processing: en [en-common]
aspell-autobuildhash: processing: en [en-variant_0]
aspell-autobuildhash: processing: en [en-variant_1]
aspell-autobuildhash: processing: en [en-variant_2]
aspell-autobuildhash: processing: en [en-w_accents-only]
aspell-autobuildhash: processing: en [en-wo_accents-only]
aspell-autobuildhash: processing: en [en_CA-variant_0]
aspell-autobuildhash: processing: en [en_CA-variant_1]
aspell-autobuildhash: processing: en [en_CA-w_accents-only]
aspell-autobuildhash: processing: en [en_CA-wo_accents-only]
aspell-autobuildhash: processing: en [en_GB-ise-w_accents-only]
aspell-autobuildhash: processing: en [en_GB-ise-wo_accents-only]
aspell-autobuildhash: processing: en [en_GB-ize-w_accents-only]
aspell-autobuildhash: processing: en [en_GB-ize-wo_accents-only]
aspell-autobuildhash: processing: en [en_GB-variant_0]
aspell-autobuildhash: processing: en [en_GB-variant_1]
aspell-autobuildhash: processing: en [en_US-w_accents-only]
aspell-autobuildhash: processing: en [en_US-wo_accents-only]
Setting up aspell (0.60.7~20110707-1ubuntu1) ...
Processing triggers for dictionaries-common (1.20.5) ...
Setting up aspell-en (7.1-0-1) ...
Processing triggers for libc-bin (2.19-0ubuntu6.6) ...
Processing triggers for dictionaries-common (1.20.5) ...
root@host#
```
Next, we need to customize some of the RoundCube configuration files. First, we are going to add the RoundCube application into our current Apache configuration files using path alias directives. The default configuration file is installed at `/etc/apache2/conf-available/roundcube.conf`
```
nano /etc/apache2/conf-available/roundcube.conf
```
We now need to remove the two comment flags in front of the alias directives. If you would like to use a different alias name, you can change that here as well. The default alias will use the URL `http:///roundcube/`
```
Alias /roundcube/program/js/tiny_mce/ /usr/share/tinymce/www/
Alias /roundcube /var/lib/roundcube
```
Once done, save and exit the file.
Now we are going to modify the `/etc/roundcube/config.inc.php` configuration file. This file is where you can customize the RoundCube advanced settings.
```
nano /etc/roundcube/config.inc.php
```
Locate the following directives and update the values to match the following.
```
$config['default_host'] = '';
$config['smtp_server'] = 'localhost';
$config['smtp_port'] = 25;
$config['smtp_user'] = '%u';
$config['smtp_pass'] = '%p';
$config['support_url'] = '';
```
Once done, save and exit the configuration file.
Finally, restart the apache service to apply the changes:
```
systemctl restart apache2
```
You should now be able to use your new RoundCube webmail application for sending and receiving message.
[Back to top]
### Congratulations!
You have now set up a fully functional and secure mail server on your [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
Learn more about our [VPS hosting](https://www.atlantic.net/vps-hosting/) services and [Virtual private servers.](https://www.atlantic.net/vps-hosting/)
---
# Should Your VPS-Hosted Website Use WordPress, Joomla, or Drupal?
> URL: https://www.atlantic.net/vps-hosting/should-your-vps-hosted-website-use-wordpress-joomla-or-drupal/ | Published: 2021-03-08 | Updated: 2025-09-19 | Author: Alexander Wise
When you first began entertaining the idea of creating a website, you may not have realized how many choices you would have to make. Many decisions need to be made when designing a website. One of your first choices will be whether to use a dedicated physical server, a Virtual Private Server (VPS), or a shared hosting arrangement. Another option that meets some more advanced customers’ needs is a bare metal solution which can be addressed with physical resources in conjunction with virtual resources.
While a shared hosting solution may initially be less expensive, it limits the degree of customization that can be performed on your website. In many cases, you will find that a VPS offering is the most attractive as it provides the best combination of security, scalability, and customization at a reasonable price point. It’s the most flexible, functional, and economical way to host your website.
One of the most important decisions you will make regarding your website is the content management system (CMS) that will be used to organize and display the information on your site. We are going to look at three of the most popular CMS solutions and provide information that allows you to make an informed choice regarding which one best suits your needs and level of technical expertise.
## What is a CMS?
A CMS is an application that is used to build and manage a website without the need to perform extensive coding. You can create, manage, and publish content easily through the solution’s user-friendly interface. Much of the customization you want to do can be accomplished through templates or extensions instead of digging into the code. Multiple users can be granted different levels of authority over the processes required to create, modify, and publish information on the website.
A CMS is made up of two core components. The content management application (CMA) is the part you interact with when adding and managing the website’s content. When you add a new page to your site, you are using the CMA. A content delivery application (CDA) works in the background, storing the input to the CMA and displaying it to your visitors.
There are substantial differences in the functionality and complexity of competing CMS solutions. Making the wrong initial choice in a content management system can make it extremely difficult to migrate your website to a different platform. It can also be frustrating either because it is too complex or does not support all of the features you would like to implement. The selection of your CMS must be made carefully.
## Three Popular Content Management System Solutions
WordPress, Joomla, and Drupal are three popular, open-source CMS solutions for building VPS-hosted websites. The three platforms support MySQL as their database management system and are primarily written in PHP. Themes, plugins, and extensions are used extensively to add customization and functionality in each of these community-driven content management systems.
Each solution has strengths and weaknesses that may make them a more attractive option for different types of users. Let’s take an objective look at how these three CMS platforms address the needs of VPS-hosted [website builders](https://www.shno.co/blog/free-website-builders-with-custom-domain).
### [WordPress](https://wordpress.org/)
Let’s investigate WordPress first. [WordPress is currently the most popular CMS](https://trends.builtwith.com/cms) and dominates the market. It has reached this level of acceptance for many very good reasons, but it is not without its flaws. Let’s begin by identifying the strong points of using WordPress as your CMS.
- **User-friendliness** – The WordPress dashboard is reasonably intuitive and makes it easy for users to create or edit posts, format web pages, and update WordPress itself. Changing themes is a straightforward operation and plugins can be added with a few clicks.
- **Simplicity** – Very little technical proficiency is required to create and manage a website with WordPress. There is essentially no learning curve as most processes such as updating plugins and installing security patches can be done with a single click. Ease of use is one of the main reasons for the popularity of this CMS.
- **Community support** – Due to the number of WordPress-based websites, there is a large and active community of users and developers. The result is an incredible amount of blogs and websites filled with tips that allow users to use WordPress more efficiently. Community members also regularly create new themes and plugins that customize websites and give them enhanced functionality.
These factors have made WordPress the most popular CMS solution for website builders. Its simplicity and user-friendliness are what attract a large percentage of individuals new to website design. The amount of community support available is comforting when embarking on an unfamiliar endeavor like creating a website.
Not everything about WordPress is perfect. Following are some characteristics of WordPress that may lead you to consider other CMS options.
- **Security** – As the most popular CMS on the web, WordPress offers an inviting target for hackers. WordPress sites are regularly attacked by hackers and many sites contain spam. Users must make sure that they install security patches as soon as they become available.
- **A low initial degree of functionality** – Without using plugins, the functionality of a WordPress site is limited. This should not pose a serious problem for designers, although they will have to browse a large set of plugins to find what they need.
- **Flexibility** – The required use of plugins and themes can limit the degree of flexibility afforded to website designers.
Atlantic.Net offers a One-Click [Word Press VPS Hosting](https://www.atlantic.net/vps-hosting/wordpress-vps-hosting/) Application.
### [Joomla](https://www.joomla.org/)
Joomla does not enjoy as large a user base as WordPress but has some features that may make it a better solution for your VPS-hosted website.
- **More initial functionality** – Joomla provides a high degree of out-of-the-box functionality. A basic installation allows content to be optimized for search engines without the use of plugins.
- **Enhanced customization** – You can extend the functionality of your Joomla website with components, plugins, modules, and extensions. With these items, you can easily add things like news feeds and buttons to your website.
- **A potential app development platform** – Developers can use Joomla’s basic code as the foundation for web applications. Coding will be necessary to make use of this feature.
The disadvantages of using Joomla include:
- **A substantial learning curve** – Finding the correct options and using extensions effectively can be challenging for new users. It takes a little more time to be comfortable using all of Joomla’s powerful features.
- **Basic coding knowledge is required** – Taking advantage of the [web app development](https://www.netsolutions.com/insights/how-to-build-a-web-app/) framework offered by Joomla requires CSS and PHP coding knowledge.
### [Drupal](https://www.drupal.org/)
Drupal is the last CMS we will look at in this article. It also has a powerful feature set but is not as easy to use as WordPress. Its features include:
- **Enhanced security** – Drupal is the choice of many government agencies due to its robust security capabilities.
- **A large selection of modules** – An advantage of Drupal modules is that multiple modules can be combined to add additional custom functionality.
- **Powerful content management features** – Content types and custom views enable the presentation of web pages to be fine-tuned. Its cache management system handles traffic spikes to keep your website running smoothly.
Here are some of the potential issues associated with using Drupal:
- **A very steep learning curve** – While Drupal is a very powerful and secure CMS solution, it takes a substantial time investment to get up to speed with the tool.
- **Slower implementation time** – It can take a long time to correctly configure your website with the desired functionality using Drupal.
## Conclusion
Simply choosing a CMS based on its popularity might not be the best way to go. Each solution we reviewed addresses the needs of a segment of the overall user community. Individuals with little technical experience who are interested in developing an online presence should look at WordPress first. More experienced users who want extended functionality at the cost of additional complexity may find that Joomla works better for them. Drupal offers enterprise-grade security and functionality that may be better suited for larger, more professional websites.
Many CMS solutions are available for use on your website in addition to these three. [OctoberCMS](https://octobercms.com/) is another open-source content management system that is easy to learn and use. It’s a lightweight solution that isn’t packed with little-used features. OctoberCMS is one of the one-click additions available from [Atlantic.Net](https://www.atlantic.Net) to tailor your VPS-hosted website to your specific requirements.
We suggest that you investigate these CMS solutions and make your selection before engaging a VPS-hosting provider. Make sure that the provider you pick offers an easy way to add the CMS to your site.
**One Year of Free Cloud VPS Hosting:**
Atlantic.Net stands ready to assist you with a world-class Cloud VPS platform, backed by always available USA-based support. Get started today and take advantage of our G3.2GB Cloud [VPS](https://www.atlantic.net/vps-hosting/) free offer for a year and be up and running in seconds.
---
# How to Install Plausible on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-plausible-on-ubuntu-20-04/ | Published: 2021-03-09 | Updated: 2023-11-26 | Author: Hitesh Jethva
Plausible is a free and open-source web analytics tool that helps you to track your website visitors. This lightweight solution is an alternative to Google Analytics. With Plausible, you can see all your site stats and metrics on a modern-looking, simple-to-use, and fast-loading dashboard. It is self-hosted, which means you can install it on any physical or [virtual private server](https://www.atlantic.net/vps-hosting/).
In this post, we will show how to install Plausible Analytics with Docker on Ubuntu 20.04.
## Step 1 – Install Docker CE and Docker Compose
Before starting, you will need to install Docker CE and Docker compose on your server. By default, the latest Docker CE package is not available in the Ubuntu 20.04 default repository, so you will need to add the Docker CE official repository to your server.
First, install all required dependencies with the following command:
```
apt-get update -y
apt-get install git apt-transport-https ca-certificates curl software-properties-common -y
```
Next, add the GPG key and repository with the following command:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
```
Once the repository has been added, install Docker and Docker Compose with the following command:
```
apt-get install docker-ce docker-compose -y
```
Once the installation is completed, verify the Docker version with the following command:
```
docker --version
```
You should see the following output:
```
Docker version 20.10.5, build 55c4c88
```
## Step 2 – Download Plausible
Next, you will need to download Plausible from the Git repository. You can download it with the following command:
```
git clone https://github.com/plausible/hosting
```
Once the download is completed, change the directory to the downloaded directory and generate a secrete password with the following command:
```
cd hosting
openssl rand -base64 64
```
You should get the following output:
```
ZWOn9ulvt24T0nJUpZsyIyAL16AdyZWzY3bpw0sL/c5KuAUCNruX8JhQeMLJcJ8Y
51UtPG4/r8nXFxv0A67rWA==
```
Next, edit the Plausible environment configuration file and define your email, admin username, password, and secret key:
```
nano plausible-conf.env
```
Change the following lines:
```
ADMIN_USER_EMAIL=admin@example.com
ADMIN_USER_NAME=admin
ADMIN_USER_PWD=adminpassword
BASE_URL=http://plausible.example.com
SECRET_KEY_BASE=ZWOn9ulvt24T0nJUpZsyIyAL16AdyZWzY3bpw0sL/c5KuAUCNruX8JhQeMLJcJ8Y51UtPG4/r8nXFxv0A67rWA==
```
Save and close the file when you are finished.
## Step 3 – Launch the Plausible Container
Next, you will need to run a docker-compose command inside the hosting directory to launch the Plausible container:
```
docker-compose up --detach
```
You should get the following output:
```
Digest: sha256:ab22a669cfe20cb54fa0d237f8ff7592793204d16ea5f588ceef4f63639cfc24
Status: Downloaded newer image for plausible/analytics:latest
Creating hosting_mail_1 ... done
Creating hosting_plausible_events_db_1 ... done
Creating hosting_plausible_db_1 ... done
Creating hosting_plausible_1 ... done
```
You can check all Docker images downloaded by the above command as shown below:
```
docker images
```
Output:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
yandex/clickhouse-server latest eeafa0a212bf 2 days ago 557MB
postgres 12 85f1c84fe307 2 weeks ago 314MB
plausible/analytics latest 213327b74c3b 5 weeks ago 149MB
bytemark/smtp latest cd5c77c3bcd8 2 years ago 130MB
```
Now, check all the running containers with the following command:
```
docker ps
```
Output:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
071b49800d01 plausible/analytics:latest "/entrypoint.sh sh -…" 7 seconds ago Up 5 seconds 0.0.0.0:8000->8000/tcp hosting_plausible_1
0cdae715308b postgres:12 "docker-entrypoint.s…" 18 minutes ago Up 6 seconds 5432/tcp hosting_plausible_db_1
90fb544b4425 yandex/clickhouse-server:latest "/entrypoint.sh" 18 minutes ago Up 6 seconds 8123/tcp, 9000/tcp, 9009/tcp hosting_plausible_events_db_1
750a908682be bytemark/smtp "docker-entrypoint.s…" 18 minutes ago Up 7 seconds 25/tcp hosting_mail_1
```
## Step 4 – Access Plausible Web Interface
At this point, the Plausible container is started and listening on port 8000. You can access it using the URL http://plausible.example.com:8000.
Click on the Register button to register in Plausible and start working.
## Conclusion
Congratulations! You have successfully installed Plausible analytics on Ubuntu 20.04. You can now add your website and track the website visitors from the central dashboard from your [Atlantic.Net VPS](https://www.atlantic.net/vps-hosting/).
---
# How to Install TensorFlow with Docker on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-tensorflow-on-ubuntu-20-04/ | Published: 2021-03-13 | Updated: 2024-08-17 | Author: Hitesh Jethva
Tensorflow is a free and end-to-end open-source machine learning platform created by the Google Brain team. It is a library used for numerical computation and large-scale machine learning. You can install it in a Python virtual environment or using Anaconda, as a docker container. It comes with a set of libraries and community resources that helps you to develop machine learning programs and applications.
In this tutorial, we will show you how to install Tensorflow with Docker on Ubuntu 20.04.
## Step 1 – Install Docker CE
First, install all required dependencies with the following command:
```
apt-get install git apt-transport-https ca-certificates curl software-properties-common -y
```
Next, add the Docker GPG key and repository with the following command:
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
```
Once the repository has been added, install the Docker and Docker compose with the following command:
```
apt-get install docker-ce -y
```
Once the installation is completed, verify the Docker version with the following command:
```
docker --version
```
You should see the following output:
```
Docker version 20.10.5, build 55c4c88
```
## Step 2 – Launch Tensorflow Container
Docker provides a Tensorflow container for building machine learning applications.
First, download the Tensorflow container using the following command:
```
docker pull tensorflow/tensorflow:latest
```
You should get the following output:
```
latest: Pulling from tensorflow/tensorflow
d519e2592276: Pull complete
d22d2dfcfa9c: Pull complete
b3afe92c540b: Pull complete
c12ceea561ed: Pull complete
1f0ffb4d2509: Pull complete
961442e8e0e4: Pull complete
0b2b6f75fc95: Pull complete
e266fced02fa: Pull complete
c29b15b084af: Pull complete
5d43e8c7056a: Pull complete
Digest: sha256:0118f3db64ddadf5d16f4b8d85ffb14228e194c0211c690562fb5dfd16fc86c0
Status: Downloaded newer image for tensorflow/tensorflow:latest
docker.io/tensorflow/tensorflow:latest
```
Next, create a Tensorflow container from the downloaded image with the following command:
```
docker run -it -p 8888:8888 tensorflow/tensorflow:latest
```
You will be redirected inside the Tensorflow container:
```
________ _______________
___ __/__________________________________ ____/__ /________ __
__ / _ _ \_ __ \_ ___/ __ \_ ___/_ /_ __ /_ __ \_ | /| / /
_ / / __/ / / /(__ )/ /_/ / / _ __/ _ / / /_/ /_ |/ |/ /
/_/ \___//_/ /_//____/ \____//_/ /_/ /_/ \____/____/|__/
WARNING: You are running this container as root, which can cause new files in
mounted volumes to be created as the root user on your host machine.
To avoid this, run the container by specifying your user's userid:
$ docker run -u $(id -u):$(id -g) args...
root@f8968eb6e582:/#
```
You can now write and run any application inside the container. You can exit from the container anytime using the following command:
```
exit
```
## Step 3 – Launch Tensorflow Jupyter Container
Docker also provides a Tensorflow container with Jupyter notebook that allows you to write and run code through the Jupyter notebook dashboard.
You can download and launch the Tensorflow Jupyter container with the following command:
```
docker run -it -p 8088:8088 tensorflow/tensorflow:latest-jupyter
```
You should get the following output:
```
latest-jupyter: Pulling from tensorflow/tensorflow
d519e2592276: Already exists
d22d2dfcfa9c: Already exists
b3afe92c540b: Already exists
c12ceea561ed: Already exists
1f0ffb4d2509: Already exists
961442e8e0e4: Already exists
0b2b6f75fc95: Already exists
e266fced02fa: Already exists
c29b15b084af: Already exists
5d43e8c7056a: Already exists
c09e41c80475: Pull complete
4928d4fd53b4: Pull complete
4f8c501e8020: Pull complete
9a927eacde80: Pull complete
cca85cdd242a: Pull complete
c491a3ee7337: Pull complete
70252b385326: Pull complete
c385e49aff55: Pull complete
32a1800a0df4: Pull complete
56ac089c301a: Pull complete
32b4fcc94634: Pull complete
62fbf7c8b492: Pull complete
a184bae0471c: Pull complete
3138b3afe589: Pull complete
322ff03a149a: Pull complete
Digest: sha256:15ca1ea5083f1f9fcc2b006df4f1d51c3d0b6f2616fa14c12ff6dc7c4bc83588
Status: Downloaded newer image for tensorflow/tensorflow:latest-jupyter
[I 03:08:37.757 NotebookApp] Writing notebook server cookie secret to /root/.local/share/jupyter/runtime/notebook_cookie_secret
jupyter_http_over_ws extension initialized. Listening on /http_over_websocket
[I 03:08:38.106 NotebookApp] Serving notebooks from local directory: /tf
[I 03:08:38.107 NotebookApp] Jupyter Notebook 6.2.0 is running at:
[I 03:08:38.107 NotebookApp] http://40959756271a:8088/?token=2cbdd5bc2250270506f38954ed7f891a146cc71e50bc46fb
[I 03:08:38.108 NotebookApp] or http://127.0.0.1:8088/?token=2cbdd5bc2250270506f38954ed7f891a146cc71e50bc46fb
[I 03:08:38.108 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 03:08:38.114 NotebookApp]
To access the notebook, open this file in a browser:
file:///root/.local/share/jupyter/runtime/nbserver-1-open.html
Or copy and paste one of these URLs:
http://40959756271a:8088/?token=2cbdd5bc2250270506f38954ed7f891a146cc71e50bc46fb
or http://127.0.0.1:8088/?token=
```
You can now access the Jupyter notebook using the URL http://your-server-ip:8088/?token=2cbdd5bc2250270506f38954ed7f891a146cc71e50bc46fb. You should see the following screen:
## Conclusion
Congratulations! You have successfully installed Tensorflow with Docker on Ubuntu 20.04. You can now easily write and run a machine learning program with Tensorflow. Try it today on an Atlantic.Net [VPS](https://www.atlantic.net/vps-hosting/)!
---
# How to Install Relic Server Monitoring on CentOS 8
> URL: https://www.atlantic.net/vps-hosting/how-to-install-relic-server-monitoring-on-centos-8/ | Published: 2021-03-15 | Updated: 2023-11-26 | Author: Hitesh Jethva
New Relic is one of the most popular web-based monitoring applications that monitors server performance in real-time. It is used by web hosting companies for resource and network monitoring including CPU, RAM, Disk Usage, and specific user-defined events.
You just need to create an account on New Relic, get the installation code, run the code inside your server, and New Relic will do the rest of things for you.
In this post, we will show you how to install New Relic on CentOS 8 and start monitoring your server.
## Step 1 – Create an Account on New Relic
First, you will need to create an account on the [New Relic](https://newrelic.com/signup) as shown below:
After sign up, log in to the New Relic. You should see the following page:
Select your operating system and click on the **Continue** button. You should get an installation code as shown below:
Copy the above code and proceed to the next step.
## Step 2 – Install New Relic
Now, log in to your CentOS 8 server and run the code as shown below:
```
curl -Ls https://raw.githubusercontent.com/newrelic/newrelic-cli/master/scripts/install.sh | bash && NEW_RELIC_API_KEY=NRAK-KKNV6Z6A8EJ7AW8U21AQG72OKWC NEW_RELIC_ACCOUNT_ID=3086649 /usr/local/bin/newrelic install
```
Once the installation has been completed, you should get the following output:
```
Starting installation.
Installing New Relic CLI v0.19.0
Installing to /usr/local/bin
WARNING unknown region, using default: US
INFO profile default added
INFO setting default as default profile
_ _ ____ _ _
| \ | | _____ __ | _ \ ___| (_) ___
| \| |/ _ \ \ /\ / / | |_) / _ | | |/ __|
| |\ | __/\ V V / | _ | __| | | (__
|_| \_|\___| \_/\_/ |_| \_\___|_|_|\___|
Welcome to New Relic. Let's install some instrumentation.
Questions? Read more about our installation process at
https://docs.newrelic.com/
The guided installation will begin by installing the New Relic Infrastructure agent, which is
required for additional instrumentation.
? Please choose from the additional recommended instrumentation to be installed: Logs integration
The following will be installed:
Infrastructure Agent
Logs integration
==> Installing infrastructure-agent-installer...
Importing GPG key 0x8ECCE87C:
Userid : "infrastructure-eng "
Fingerprint: A758 B3FB CD43 BE8D 123A 3476 BB29 EE03 8ECC E87C
From : https://download.newrelic.com/infrastructure_agent/gpg/newrelic-infra.gpg
==> Installing logs-integration...success.
---
Instrumentation recommendations
We discovered some additional instrumentation opportunities:
- Node Agent Installer
- Python Agent Installer
Please refer to the "Detected observability gaps" section in the link to your data.
---
New Relic installation complete!
Your data is available at https://one.newrelic.com/redirect/entity/MzA4NjY0OXxJTkZSQXxOQXw4ODA3MjE5MDg0OTUzODQ4NTMz
```
Please remember the New Relic URL as shown in the above output. You will need it to access the New Relic web interface.
## Step 3 – Access the New Relic Web Interface
Now, open your web browser and access the New Relic web interface using the URL
[https://one.newrelic.com](https://one.newrelic.com/redirect/entity/MzA4NjY0OXxJTkZSQXxOQXw4ODA3MjE5MDg0OTUzODQ4NTMz.)
You should see the New Relic dashboard on the following page:
## Conclusion
Congratulations! You have successfully installed New Relic on CentOS 8. You can now monitor your [virtual server](https://www.atlantic.net/vps-hosting/) from the central location.
---
# How to Set Up Remote Access to Docker Daemon
> URL: https://www.atlantic.net/vps-hosting/how-to-set-up-remote-access-to-docker-daemon/ | Published: 2021-03-17 | Updated: 2023-11-18 | Author: Hitesh Jethva
If you are a system administrator and manage multiple Docker hosts, then you will need to connect to each Docker host and run a command to manage Docker. This can be a time-consuming process. This is where Docker daemon comes into the picture. Docker daemon allows you to connect to a remote docker host over TCP. This way, you can manage multiple Docker hosts from your local system without having to log in to each Docker host individually.
In this post, we will show you how to configure Docker daemon to manage the Docker host over TCP.
## Step 1 – Install Docker CE
First, install all required dependencies with the following command:
```
apt-get install git apt-transport-https ca-certificates curl software-properties-common -y
```
Next, add the Docker GPG key with the following command:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add –
Next, add the Docker repository with the following command:
```
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
```
Once the repository has been added, install Docker and Docker compose with the following command:
```
apt-get install docker-ce docker-compose -y
```
Once the installation is completed, verify the Docker version with the following command:
```
docker --version
```
You should see the following output:
```
Docker version 20.10.5, build 55c4c88
```
## Step 2 – Configure Docker Daemon
First, you will need to create a directory to store the Docker daemon configuration file. You can create it with the following command:
```
mkdir -p /etc/systemd/system/docker.service.d
```
Next, create a new file to store the daemon options.
```
nano /etc/systemd/system/docker.service.d/options.conf
```
Add the following lines:
```
[Service]
ExecStart=
ExecStart=/usr/bin/dockerd -H unix:// -H tcp://0.0.0.0:2375
```
Save and close the file, then reload the systemd daemon to apply the changes:
```
systemctl daemon-reload
```
Next, restart the Docker service to apply the changes:
```
systemctl restart docker
```
At this point, the Docker daemon is configured and listening on port 2375. You can check it with the following command:
```
ps aux | grep dockerd
```
You should get the following output:
```
root 48453 1.2 2.4 1005080 98520 ? Ssl 00:58 0:00 /usr/bin/dockerd -H unix:// -H tcp://0.0.0.0:2375
root 48775 0.0 0.0 12108 992 pts/0 S+ 00:58 0:00 grep --color=auto dockerd
```
## Step 3 – Configure Local System to Connect to the Docker Daemon
Before starting, make sure Docker and Docker compose are installed on your local system. Now, you will need to configure your local system to connect to the Docker daemon on the remote Docker host.
You can use a single one-liner to direct connect to the Docker daemon and run command on the remote Docker host. You can use the DOCKER_HOST variable to define the Docker daemon address.
For example, run the following command to run the docker info command on the remote Docker host:
```
DOCKER_HOST=tcp://remote-docker-host-ip:2375 docker info
```
Or
```
docker -H tcp://remote-docker-host-ip:2375 docker info
```
You should get the output of the docker info command as below:
```
Containers: 2
Images: 3
Storage Driver: overlay2
Backing Filesystem: xfs
Supports d_type: true
Native Overlay Diff: true
Execution Driver:
Kernel Version: 4.18.0-193.6.3.el8_2.x86_64
Operating System: CentOS Linux 8 (Core)
CPUs: 2
Total Memory: 3.846 GiB
Name: centos8
ID: S56P:VPIW:CMGZ:GAFN:YZNG:22CE:OBY3:SKEW:JAMT:DLD4:FG5K:QXYR
Http Proxy:
Https Proxy:
No Proxy:
Labels:
```
You can also run the docker-compose command on the remote host as shown below:
```
docker-compose -H tcp://remote-docker-host-ip:2375 --version
```
You can also set DOCKER_HOST variable in your .bashrc file. So you don’t need to specify every time when executing docker or docker-compose command.
You can set it with the following command:
```
echo "export DOCKER_HOST=tcp://remote-docker-host-ip:2375" >> ~/.bashrc
```
Next, activate the configuration with the following command:
```
source ~/.bashrc
```
Now, you can manage remote Docker host by just running the docker and docker-compose command locally.
For example, run the following command to check the Docker version on the remote host:
```
docker --version
```
## Conclusion
In the above guide, you learned how to configure Docker daemon to connect the remote Docker host over TCP and manage it from the local system. I hope this will make your day-to-day Docker tasks much easier. Start using Docker daemon today on a [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# VPS vs VPN – Similar Names, But Completely Different Functions
> URL: https://www.atlantic.net/vps-hosting/vps-vs-vpn-similar-names-but-completely-different-functions/ | Published: 2021-03-19 | Updated: 2024-09-24 | Author: Gilad Maayan
## **Difference Between VPS and VPN**
The technology industry is full of acronyms, and although VPS Hosting and VPN have similar names, they are different things altogether. Though the acronyms look and sound similar, in reality, they are individual technologies that have very little to do with one another.
Naming convention similarities can indeed cause confusion, especially for individuals outside of the tech industry, but you can rest easy, as we will explain the difference and help you to understand which technology is best for your current needs.
Let’s break these acronyms down. **VPS **stands for Virtual Private Server and **VPN **stands for Virtual Private Network. They are two completely different technologies, so it is important to understand what the difference is to ensure you are getting the correct service.
## What Is a VPS?
A VPS is a server, typically a server that users can lease from a hosting provider. The VPS is an isolated virtual machine with finite local resources. Resources are allocated from a physical host, and the hosting provider will likely have many VPS hosts in a data center; they essentially split up the host into multiple Virtual Private Servers.
A typical standard VPS configuration will usually not be interconnected with other services and does not share resources. You simply purchase some server space and get to work. However, there are alternative solutions available, and Cloud VPS can share resources and interconnect with other cloud services such as backups, edge services, and many other managed services. You can also get a Dedicated Host that you can place VPS on, an entirely private host for your personal use.
## What Are the Advantages of a VPS?
VPS is popular for a reason, and there are several advantages of using a VPS. Primarily, they are typically less expensive than other cloud server offerings. Another advantage is that the user rarely knows that they are working on a shared tenancy as performance is usually very good, and all neighboring VPS are completely isolated from one another by the host. Your neighbors can reboot, upgrade operating systems, and pretty much do what they like, and it will not affect you.
## Cloud VPS
Atlantic.Net also offers a Cloud VPS service that guarantees system resources without the need for a dedicated host (although we offer that too). Cloud VPS includes additional high availability configurations and access to other ACP Cloud Services such as onsite and offsite backups, snapshots, and Secure Block Storage.
Our Cloud VPS servers are built to stringent security best practices, and all servers have root access (or Windows Administrator) privileges enabled and available upon launch. The Atlantic.Net Cloud VPS combines simplicity, security, and scalability with the reliability of the latest virtualization and cloud hosting platform technology.
You can scale up when needed, you only have to pay for what you use, and you can cancel the Cloud VPS at any time with no commitments, saving you significant time and money.
## What Is a VPN?
Now know what a VPS is, so let’s take a look at VPNs to understand why they are different from VPSes! A virtual private network (VPN) is a secure, private and encrypted network connection between two endpoints. A [secured VPN](https://vpnoverview.com/best-vpn/top-5-best-vpn/) tunnel is created peer-to-peer to encapsulate all network traffic, even if being used over the public internet.
The technology is widely used by home workers to create a private network connection between you and a workplace computer network. This is done over a home internet connection. It enables the user to access workplace resources and use your computer as if you were sitting at your office desk.
The VPN creates a secured network tunnel where the end-user can safely transmit sensitive data without the risk of any data being compromised. With today’s rapid internet speeds, there is no noticeable difference in the user experience on a VPN connection compared with accessing the infrastructure directly outside of latency depending on physical distance from the data center. The miles between the end-user and the data center are why Atlantic.Net has so many different physical locations across the globe.
## Why Are VPNs So Popular?
Virtual Private Networks are incredibly popular because the technology not only allows the secure and private transfer of data between many different authorized endpoints, but also is very simple to use. It’s relatively easy to set up, too; long gone are the days where you need to purchase expected hardware VPN devices. Now you can configure a VPN as a software device in a matter of minutes. Popular VPN applications used by Atlantic.Net customers include [StrongSwan](https://www.atlantic.net/vps-hosting/how-to-install-and-configure-strongswan-vpn-on-ubuntu/) and [Wireguard](https://www.atlantic.net/vps-hosting/how-to-set-up-wireguard-vpn-on-centos-8/).
Most VPN clients are very user-friendly, and since almost all workplaces have a VPN in place, the usage of the technology is becoming commonplace.
## What Are the Key Features of a VPN?
[Data encryption](https://cloudian.com/guides/secure-data-storage/data-encryption/) is one of the primary features of a VPN as encryption protected the transfer of sensitive information. A VPN enforces the confidentiality, integrity, and availability of business data. The encryption ciphers used are so advanced that it is almost impossible to break 2048 bit encryption with today’s technology.
Access Controls can be applied to VPNs, and integration to business directory services (such as Active Directory) is very simple. One of the principal purposes of a VPN is to control access to digital resources. When a VPN is deployed, only authorized users can register a VPN account.
Strict access controls can be created that include locking down access to specific users, specific laptops, or workstations. Once a user is on the VPN, access controls can be set to control what and where the user can or cannot access the network. All VPN traffic can be logged and access logs are easy to decipher to who has accessed the network at a particular time; this is very useful for auditing businesses.
## How Can Atlantic.Net Help?
You will be glad to know that Atlantic.Net can help you if you need a Cloud VPS, or if you need a VPN by provisioning a cloud VPS. For more than 30 years, Atlantic.Net has helped thousands of businesses with industry-leading hosting solutions, and we can do the same for you too.
Atlantic.Net Cloud VPS is a far superior alternative to standard VPS, providing full control of your server software backed by dedicated and premium hardware resources. Get started today with a free-to-use [Cloud VPS Hosting](https://www.atlantic.net/vps-hosting/) for one full year today!
---
#### Read More About Remote Management and VPNs
- [What Is a VPN?](https://www.atlantic.net/vps-hosting/what-is-vpn/)
- Best [Remote Management Tools](https://www.atlantic.net/vps-hosting/top-10-remote-management-tools/)
---
---
# The Best One-Click Apps for VPS Hosting
> URL: https://www.atlantic.net/vps-hosting/the-best-one-click-apps-for-vps-hosting/ | Published: 2021-03-22 | Updated: 2025-09-19 | Author: Alexander Wise
Requisitioning a Virtual Private Server (VPS) is often one of the first steps individuals or organizations take when looking to develop a web presence. Other options, like hosting the website on a physical server or sharing a server with other customers, are either more expensive or less flexible. In most cases, a VPS is the best choice. It offers clients a secure and economical method of getting up and running on the web.
One of the factors that can influence your choice of a VPS hosting provider is the availability of software tools and packages to run on your server. Even the most high-performing and technologically advanced virtual server makes a poor website without the addition of the right software. Once you have settled on a hosting solution, it’s time to make it functional by installing software that addresses your requirements.
A perk that many top-notch web-hosting providers offer their customers is the availability of one-click software installation. Depending on your needs, some providers may have a more attractive portfolio of one-click apps than others. This article will look at the best one-click apps for clients hosting their websites on virtual private servers.
## Why Do You Want One-Click Apps?
One-click apps are beneficial for all web-hosting customers for one main reason. The simplicity of a one-click methodology removes the complexity of manual installations of software on web servers. Hosting providers offer a streamlined installation path as a perk to their clients that allows them to more easily construct the type of website they want.
Traditional software installation methods can be challenging for even the most experienced technophiles. Many new VPS customers are not technically proficient developers. A lot of prospective web-hosting clients have average computing skills at best but are looking to develop a web presence for business reasons or to present information to a worldwide audience.
At a minimum, installing software on the web requires multiple steps. Many new hosting clients would find it very difficult to perform these procedures without engaging professional help or incurring undue stress. A common installation involves:
**Determining system requirements** – Before initiating any software installation, it’s necessary to verify that a system meets the minimum requirements. This can be complicated and may require some serious research and a substantial time investment.
**Ensuring code support** – Language support on the VPS is an essential ingredient in getting applications to run successfully. You need to make sure that the PHP version required by an app is compatible with your server and other software with which it will interact.
**Setting permissions correctly** – Setting permissions is vitally important for website security. It can also be a very complex undertaking. A small permission error can enable unauthorized access to your server, making it imperative that the procedure is performed correctly.
**Creating databases** -A database needs to be created to store and manage information on the website. This too can be complicated and beyond the technical skills of many potential VPS customers.
**Installing third-party application extensions** – Third-party code libraries, applications, and extensions may be necessary to complete the installation of the original app.
The complexity involved with getting an application to run smoothly on a VPS can make the process extremely challenging. That’s the reason hosting providers offer a one-click installation path. The complications we have just outlined are eliminated when installing one-click apps. With one-click apps, providers make it easy for their customers to make the most efficient use of their valuable time and virtual private servers.
## What Are Some of the Best One-Click Apps?
Now that you have a sense of why VPS hosting providers offer one-click app installation, the next question to consider is which apps will be the most useful when developing, designing, and maintaining your website. Here are our choices for the most beneficial one-clicks apps to use with a virtual private server.
### WordPress
[WordPress is an extremely popular content management system (CMS)](https://hostingtribunal.com/blog/wordpress-statistics/#gref) that powers millions of websites. Its popularity derives from its simplicity, ease-of-use, and large user support community. This has made it very attractive for setting up a website or blog by non-technical customers.
A WordPress site is customizable using the many themes and plugins made available by the professional and user community. The application makes it easy to create impressive personal or business websites and gets them up and running fast. There is a large range of technical users from beginners to advanced that utilize WordPress for their website needs.
### cPanel
[cPanel](https://cpanel.net/)is the industry-leading hosting platform that makes it easy for users to automate the management tasks necessary when operating a website. It features a simple and intuitive interface that facilitates efficient website administration. cPanel is very customizable and can be used by resellers to promote their business through improved branding along with more advanced hosting options for that next level of a web presence.
Some of the tasks simplified by cPanel include setting up and managing email accounts, database management, and handling backup and recovery processes. cPanel eliminates many of the technical hurdles faced by new website designers while providing a graphical user interface to make navigating and administrating your website easy.
### October CMS
This app is a modern CMS that provides an alternative to WordPress. October CMS is primarily designed for use by developers and is not as easy to use as WordPress. It can also function as a flat-file CMS, eliminating the need for a database. October CMS is more lightweight than WordPress and enables more granular control and management of new features.
### NextCloud
This app is a self-hosted productivity platform that helps users collaborate and share information. [NextCloud](https://nextcloud.com/) enables data to be protected, controlled, and monitored across the whole organization. The app allows secure emails and video chats without the risk of data leaks. NextCloud is a must-have One-Click App that solves a lot of company-related needs especially in the new economy where some of your workers will now be remote.
### LAMP
LAMP is an acronym for Linux, Apache, MySQL, and PHP. It’s a development stack used for developing and building dynamic websites. Linux provides the operating system, Apache is the web server software, MySQL is the database solution, and PHP is the programming language used to tie it all together. It’s the most popular development stack on the web. This One-Click app is mostly for developers and to get the website project underway as quick as possible. This is not a beginner-oriented One-Click app.
### LEMP
LEMP is a similar development stack that replaces the Apache web server component with Nginx. It offers users the tools necessary to create and customize websites using the simpler and potentially faster Nginx web server software. This One-Click app, just like a LAMP stack above, is mostly for developers and to get the website project underway as quickly as possible. This is not a beginner-oriented One-Click app.
### MySQL
MySQL is the leading open-source relational database management system (RDBMS) in the world. Its popularity is demonstrated by its inclusion in the LAMP and LEMP development stacks. MySQL has a large user community that can help provide online support and help keep the RDBMS solution secure.
### Docker
[Docker](https://www.docker.com/why-docker) is a development framework that streamlines the process of creating innovative apps in software containers. Containers isolate an application from its environment, making it easier to create more robust and cloud-based solutions. It has become the de-facto industry standard for building containerized apps.
### Node.js
Node.js is an open-source server environment that runs on multiple platforms including Windows, Linux, and macOS. It employs asynchronous programming, which is more memory-efficient and potentially much faster than routines written in PHP or ASP.
## Where Can I Get These One-Click Apps?
Atlantic.Net is a full-service web hosting provider that offers customers a wide range of options enabling them to tailor a [VPS](https://www.atlantic.net/vps-hosting/) to their business requirements. All the one-click apps discussed above are available when you choose Atlantic.Net for your [VPS hosting provider](https://www.atlantic.net/vps-hosting/). They provide an excellent platform for getting your website implemented quickly with all the features it needs to succeed.
---
# How to Install Invoice Ninja on Debian
> URL: https://www.atlantic.net/vps-hosting/how-to-install-invoice-ninja-on-debian/ | Published: 2021-03-23 | Updated: 2025-09-03 | Author: Hitesh Jethva
Invoice Ninja is a free, open-source, self-hosted application for invoicing and billing customers. It is written in PHP with a Laravel framework. Invoice Ninja is specially designed for freelancers & businesses for invoicing, accept payments, track expenses, create proposals, and time tasks. It allows you to create and send invoices to clients with your own domain name and brand. Invoice Ninja supports 40+ payment gateways including WePay, GoCardless, PayPal, Authorize.net, 2Checkout, and more.
In this post, we will show you how to install Invoice Ninja with Nginx on Debian 12.
## Prerequisites
- A fresh Debian 12 server
- A valid domain name pointed to your [virtual private server](https://www.atlantic.net/vps-hosting/)
- A root password configured on your server
## Step 1 – Install LEMP Server
First, you will need to install Nginx, MariaDB, PHP, and other PHP extensions on your server. You can install all of them with the following command:
```
apt-get install nginx mariadb-server php php-zip php-bcmath php-fpm php-cli php-common php-curl php-gd php-mysql php-xml php-mbstring unzip -y
```
Once all the packages are installed, stop the Apache, start the Nginx and MariaDB service if not started.
```
systemctl stop apache2
systemctl start nginx
systemctl start mariadb
```
## Step 2 – Create a Database
Next, you will need to create a database and user for Invoice Ninja. First, log in to MariaDB with the following command:
```
mysql
```
Once connected, create a database and user with the following command:
```
CREATE DATABASE ninja;
GRANT ALL PRIVILEGES ON ninja.* TO 'ninja'@'localhost' IDENTIFIED BY 'password';
```
Next, flush the privileges and exit from the MariaDB with the following command:
```
FLUSH PRIVILEGES;
EXIT;
```
## Step 3 – Download Invoice Ninja
Next, download the latest version of Invoice Ninja with the following command:
```
wget https://github.com/invoiceninja/invoiceninja/releases/download/v5.11.72/invoiceninja.tar.gz
```
Once the download is completed, extract the downloaded file to the Nginx root directory:
```
cd /var/www/html
tar -xvzf invoiceninja.tar.gz
```
Next, copy the example environment file.
```
cp .env.example .env
```
Next, change the ownership of the invoiceninja directory to www-data:
```
chown -R www-data:www-data /var/www/html/
```
Set proper permissions.
```
chmod -R 775 *
```
## Step 4 – Configure Nginx for Invoice Ninja
Next, you will need to create an Nginx virtual host configuration file for Invoice Ninja.
You can create it with the following command:
```
nano /etc/nginx/conf.d/ninja.conf
```
Add the following lines:
```
server {
listen 80;
server_name ninja.example.com;
root /var/www/html/public;
index index.php index.html index.htm;
client_max_body_size 20M;
charset utf-8;
access_log /var/log/nginx/ininja.access.log;
error_log /var/log/nginx/ininja.error.log;
gzip on;
gzip_types application/javascript application/x-javascript text/javascript text/plain application/xml application/json;
gzip_proxied no-cache no-store private expired auth;
gzip_min_length 1000;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
if (!-e $request_filename) {
rewrite ^(.+)$ /index.php?q= last;
}
location ~ \.php$ {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass unix:/run/php/php8.2-fpm.sock;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_intercept_errors off;
fastcgi_buffer_size 16k;
fastcgi_buffers 4 16k;
}
}
```
Save and close the file, then verify the Nginx for any syntax errors with the following command:
```
nginx -t
```
Finally, restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 5 – Access Invoice Ninja
Now, open your web browser and access the Invoice Ninja web interface using the URL **http://ninja.example.com**. You will be redirected to the following page:
Provide your Invoice Ninja URL, database details, and administrative user information, and click on the **Next** button. You will be redirected to the Invoice Ninja login page:
Provide your admin username and password and click on the **Login** button. You should see the Invoice Ninja dashboard on the following page:
## Conclusion
Congratulations! You have successfully installed and configured Invoice Ninja on Debian 12. You can now implement Invoice Ninja in your organization and start invoicing and billing customers with your [VPS](https://www.atlantic.net/vps-hosting/) from Atlantic.Net.
---
# Atlantic.Net now accepts PayPal payments
> URL: https://www.atlantic.net/press-releases/atlantic-net-now-accepts-paypal-payments/ | Published: 2021-03-25 | Updated: 2024-06-11 | Author: Editorial Team
**ORLANDO, FLA. (March 25, 2021)** – [Atlantic.Net](https://www.atlantic.net/), a leading cloud services provider, now accepts PayPal as a payment option for all its services and solutions.
“Based on the feedback we have received and to better serve an ever-growing customer base, we are introducing the ability for all our customers to pay with PayPal. As we continue to expand our business and footprint internationally, PayPal payments will help further accelerate our growth in all markets,” said Marty Puranik, CEO and Founder of Atlantic.Net. “Having an additional payment option for our customers is particularly important as we plan to introduce additional international cloud locations to the market.”
PayPal is an online payments system with 305 million active customers across most countries. It serves as an electronic alternative to traditional payment methods like checks, money orders, and credit/debit cards, allowing people to transfer funds electronically between individuals and businesses directly from their PayPal account. This presents a significant opportunity to increase overall revenues by opening services up to clients that do not wish to use a credit or debit card or prefer to pay in advance for their services.
The Atlantic.Net Cloud Platform, which is engineered to provide fault-tolerant, ultra-fast performance, includes award-winning Cloud Servers, Secure Block Storage, one-click applications, DNS, Dedicated Hosts, private networking, RESTful API, data backup, a full suite of managed services, 24/7/365 expert U.S.-based support, and more. This infrastructure is ideally suited to support businesses and organizations as they evolve toward a distributed or hybrid remote work environment to help mitigate the health risks of COVID-19.
**About Atlantic.Net**
Atlantic.Net is a global cloud services provider with over 25 years of experience, serving thousands of developers and small, medium, and large clients in more than one hundred countries. Atlantic.Net specializes in managed and non-managed Windows, Linux, and FreeBSD server hosting solutions and has served dynamic business clients including Lenovo, Newegg, NASA, and Hilton, among others. With a focus on security, compliance, and simplifying the user experience, Atlantic.Net provides business-class dedicated and cloud hosting solutions, backed by 24/7/365 support in New York, London, San Francisco, Toronto, Dallas, Ashburn, and Orlando. For more information, please visit [Atlantic.Net](https://www.atlantic.net/).
---
# Atlantic.Net Now Accepts PayPal Payments
> URL: https://www.atlantic.net/announcements/atlantic-net-now-accepts-paypal-payments/ | Published: 2021-03-25 | Updated: 2025-09-19 | Author: Alexander Wise
## PayPal payments are now accepted for all Atlantic.Net services and solutions
Today we began accepting PayPal payments for all our services and solutions. PayPal is an online payments system with 305 million active customers across most countries. It serves as an electronic alternative to traditional payment methods like checks, money orders, and credit/debit cards by allowing people to transfer funds electronically between individuals and businesses directly from their PayPal account. This presents a significant opportunity to increase our revenues by opening our services up to clients that do not wish to use a credit or debit card or prefer to pay in advance for their services.
“Based on feedback we have received and to better serve an ever-growing customer base, we are introducing the ability for our customers to pay with PayPal. As we continue to expand our business and footprint internationally, PayPal payments will help further accelerate our growth in all markets,” said Marty Puranik, CEO and Founder of Atlantic.Net. “Having an additional payment option for our customers is particularly important as we plan to introduce additional international cloud locations to the market.”
To learn more about making payments for your Atlantic.Net Cloud services, please visit: [https://www.atlantic.net/community/howto/paying-with-paypal/](https://www.atlantic.net/vps-hosting/paying-with-paypal/)
---
# What Makes Dedicated Cloud Hosting a Perfect Choice for Resellers?
> URL: https://www.atlantic.net/dedicated-server-hosting/what-makes-dedicated-cloud-hosting-a-perfect-choice-for-resellers/ | Published: 2021-03-27 | Updated: 2025-09-19 | Author: Richard Bailey
Cloud Hosting is experiencing significant growth right now, and cloud reselling is also becoming hugely popular, as small businesses and entrepreneurs realize the affordability of offering Cloud Hosting. Dedicated cloud servers are driving this transformation initiative, allowing resellers to harness the power of new, high-performance server hardware at a fraction of the cost of setting up your own data center.
The reseller performs the role of the hosting company, and they can charge their clients their own fee, making it easy to turn a profit. The reseller can create their own hosting plans that are personalized to their customers. The customer will not know that server space is being resold from a principal cloud hosting provider.
## What Is Reseller Hosting?
You may be unsure exactly what reseller hosting is, so in the interests of clarity, reseller hosting is when an individual or small business leverages an existing hosting company’s infrastructure, rebrands it, and resells it to its own customer base. Website hosting is particularly popular for resellers, and frequently resellers offer servers for cryptocurrency mining. Typically a reseller will purchase one (or many) dedicated cloud hosts, then split up the resources and resell them.
Hosting providers often offer incentives to resellers, such as discounts or performance perks depending on how much server space is purchased. The reseller only has to worry about reselling computer resources; they don’t have to worry about keeping the data center lights on, the cost of power and cooling, or maintaining a strong service level agreement, as all these responsibilities are owned by the principal hosting provider.
## What Is a Dedicated Cloud Host?
A dedicated cloud host is a physical server that is sold or leased in its entirety to the customer. Techies might refer to it as a dedicated piece of tin. In a typical data center, [dedicated hosting](https://www.atlantic.net/dedicated-server-hosting/) will be used by businesses for complex, data-intensive tasks or for reselling purposes.
Depending on the provider, a dedicated cloud host will have a hypervisor installed and will be connected to a pre-existing cloud platform. Resellers usually have a personalized cloud portal for their customers, or they may offer a solution like cPanel to lease personalized server space.
The principal cloud provider’s software then manages the server and opens up the substantial benefits of having cloud connectivity. This makes provisioning availability near-instant, as a customer can lease the server in minutes. Despite cloud connectivity, there is no direct sharing of server resources, and resources are exclusive for the reseller to manage.
Some of the major benefits include the ability to add secure block storage on-demand and scale up the server on demand – great if your reseller business grows rapidly. Also, snapshots, onsite and offsite backup integration, replication, DNS integration, and so on are useful features.
The resellers have complete control to create, manage and remove Cloud Servers on the Dedicated Cloud Host and the freedom and flexibility to provision any resources offered on a plan by the principal hosting company.
## A Perfect Match for Resellers?
With evolving technology increasing our dependence on newer developments, it can be difficult for resellers and integrators to manage modern server infrastructure. This is why there is a greater need and desire for services to help make the reseller’s and integrators’ jobs easier.
The reseller has complete control over the disk space, network bandwidth, and CPU allocations per client, enabling the creation of a white label hosting company. The reseller gets all the perks of working with the hosting provider, including 24/7 support options, uptime guarantees, and the option to leverage professional services.
For many years, managed servers helped to fuel business growth for resellers, but a saturation point has been reached where system management overhead overtakes the ability to continue growing profitably. This is not the case with a dedicated cloud host, as most of the emphasis is on the reseller’s customers to manage their own VPS.
Imagine being a reseller with the ability to turn up one-click applications, or the ability to resize a [dedicated server](https://www.atlantic.net/dedicated-server-hosting/) with additional resources, not only providing greater power but also meeting regulatory compliance standards.
Dedicated Cloud Nodes are now available that help resellers to become more efficient with their time and help them bring focus to the core business functions. Client cloud servers are available in minutes and come with all the benefits of highly available infrastructure and the option to purchase additional services from the principal hosting company.
The reseller has complete control to create, manage and remove Cloud Servers on the Dedicated Cloud Host, including complete and detailed logging of each VMS, making it easier to charge your customers accurately and enabling the freedom and flexibility to provision any cloud hosting plan.
## What Should I Look for in a Hosting Provider?
Hopefully, you can now understand the major benefits of using dedicated cloud hosts as a reseller, but what else should you look for?
- Integration to a cloud control panel
- (or) Integration with cPanel
- High performance dedicated cloud hosts
- Solid State Hard drives used throughout the infrastructure
- Flexible bandwidth options
- Bolt-on secure block storage capability
- Scalability
- Ability to manage DNS and Nameservers
- Around the clock support
- 100% uptime guarantee
- Professional Service Agreements for consulting work
- Ability to integrate with other cloud services and managed service offerings, such as a backup-as-a-service, firewall as a service, intrusion prevention as a service, and more
If you are a growing business, require the advanced features for disaster recovery and business continuity, have unpredictable growth patterns, have a SAAS offering, have a high traffic website, or want the ability to become a cloud reseller (where you can lease/resell cloud resources to another client), a dedicated cloud host is a perfect match. Not only do you get a powerful server, but the dedicated cloud host also allows you to provision multiple servers in seconds with a fully orchestrated and built cloud mechanism.
With [Dedicated Hosts](https://www.atlantic.net/dedicated-server-hosting/dedicated-hosts/), the tools to accomplish a full DR plan while planning ahead for business growth are already waiting and ready to make your life easier. Atlantic.Net is a market-leading Dedicated Cloud Host, with a presence in eight international data center locations.
With Atlantic.Net Dedicated Cloud Host, you can launch Cloud Servers within minutes, backed by highly available infrastructure. You get complete control to create, manage and remove Cloud Servers with a full log of your servers and VMS, making it easy for you to bill your customers. If you would like to learn more about our Dedicated Cloud Host solution for resellers, please visit our [Dedicated Host page](https://www.atlantic.net/dedicated-server-hosting/dedicated-hosts/), email [sales@atlantic.net](mailto:sales@atlantic.net), or call +1 (321) 206- 3734.
---
# Breaking News: Acer Hit with $50 million Ransomware Demand
> URL: https://www.atlantic.net/vps-hosting/breaking-news-acer-hit-with-50-million-ransomware-demand/ | Published: 2021-03-29 | Updated: 2026-03-02 | Author: Richard Bailey
*Atlantic.Net is providing this security advisory as a news item; we want to reassure our customers that Atlantic.Net does not use any of these products affected by this exploit internally or in any of our service offerings.*
Over the last few days, reports have emerged of what could turn out to be the biggest ransomware demand in history. The reported victim is Acer Inc., the Taiwanese multinational tech giant that is famous for manufacturing business and personal computer hardware including laptops, computers, tablets, and visual displays.
The news began breaking on the 19th March 2020 by tech and security website [Bleeping Computer](https://www.bleepingcomputer.com/news/security/computer-giant-acer-hit-by-50-million-ransomware-attack/). The hacking group REvil has demanded a $50 million ransom from Acer after what they claim to be a successful data breach and ransomware attack.
REvil (previously known as Sodinokibi) is believed to be a Russian-based ransomware-as-a-service operation. They have previously successfully targeted the UK HQ of motoring giant [Honda](https://www.bbc.co.uk/news/technology-52982427), and U.S law firm [Grubman Shire Meiselas & Sack](https://www.infosecurity-magazine.com/news/revil-to-auction-stolen-madonna/). The Grubman breach made international news as they represented many famous people including Madonna, Lady Gaga, Donald Trump, and Lebron James.
As part of the Grubman breach, legal documents were leaked as part of the extortion, but they sensibly never paid the ransom (unlike UK travel currency company Travelex who reportedly paid REvil over $2.3 million).
## What Do We Know About the Acer Breach?
At the time of writing, there has been no official statement from Acer Inc. If reports are to be believed, only the back-office email system was targeted at Acer and no production environments were compromised. However, REvil has given Acer 9 days to pay a [$50 million bounty](https://www.bleepstatic.com/images/news/ransomware/attacks/a/acer/tor-payment-site.jpg); this is the largest ransom ever reported, and the group has published ‘evidence’ of the successful breach on their [hidden TOR website](https://www.bleepstatic.com/images/news/ransomware/attacks/a/acer/acert-leak-site.jpg).
Despite the rise in Exchange Online and Microsoft 365 cloud services, a huge number of businesses still operate on-premise Microsoft Exchange server farms, and it is believed that the breach may have taken advantage of a recently uncovered Microsoft Exchange vulnerability. Due to the very nature of the Exchange email delivery method, at least part of the network infrastructure has to be exposed to the public internet, usually in the form of a DMZ or perimeter proxy. As a result, any vulnerability can potentially expose a business to malicious actors.
On the 2nd March 2021, Microsoft scrambled to patch a “Microsoft Exchange Server Remote Code Execution Vulnerability” documented in [CVE-2021-26855](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26855). The security bulletin states that Exchange 2013, 2016, or 2019 were vulnerable when running on Windows Server 2008 R2, Server 2012, Server 2012 R2, Server 2016, and Server 2019.
Microsoft has subsequently released a patching [tool on GitHub](https://github.com/microsoft/CSS-Exchange/tree/main/Security) for system administrators. The tool scans the environment to see if the infrastructure is vulnerable. If the scan confirms the system is vulnerable, the security updates are installed.
## What Is the Next Move?
Unless Acer Inc. goes public, we may never know the true extent of the breach, but to demand $50 million, many expect the hacking group to have some valuable data on the company. If not that, the hackers are just being bullish in an attempt to extort money.
With Acer being tight-lipped, this is very much a case of “wait and see.” Have they paid the ransom? Have they even been hacked? Truthfully, no one knows yet, and while some suggested evidence has been released, there is no way to validate whether it’s genuine.
If your business is concerned about cybersecurity, please feel welcome to reach out to Atlantic.Net. We are specialists in Managed Services, Cloud Hosting, and HIPAA compliance. Security of our infrastructure is of paramount importance, and we work hard to ensure we have the best security processes in place.
There is no doubt that this cyberattack will go down in history, and we feel concerned for our friends in the industry that might be affected by this. Atlantic.Net has a full suite of [Managed Security Services](https://www.atlantic.net/pci-compliant-hosting/pci-security-services/), to help be proactive and prepare in advance for any security issues. [Get in touch today.](https://www.atlantic.net/about-us/corporate-contact/)
---
# Announcement: Meet Our Customer Service Champion for Q1 2021: Alex C.
> URL: https://www.atlantic.net/announcements/meet-our-customer-service-champion-for-q1-2021-alex-c/ | Published: 2021-03-30 | Updated: 2025-09-19 | Author: Alexander Wise
We are pleased to announce that Alex C. is our Customer Service Champion for Q1 2021!
Alex C. is one of our top Account Executives. He enjoys sports, and his biggest new year goal is to ride bikes and exercise more frequently with his family. He likes how close everyone is at Atlantic.Net, and he says that Atlantic.Net even feels like a family sometimes.
For 2021, Alex says he is grateful he is part of a team that is willing to share knowledge with him to be able to continue to work during the pandemic.
Great work, Alex!
We thank you and we appreciate all your hard work!
---
# VPS Hosting, Dedicated Hosts and Dedicated Servers – When Should I Upgrade?
> URL: https://www.atlantic.net/dedicated-server-hosting/vps-hosting-dedicated-hosts-and-dedicated-servers-when-should-i-upgrade/ | Published: 2021-04-07 | Updated: 2025-09-19 | Author: Richard Bailey
When a business begins to consider upgrading from [VPS hosting](https://www.atlantic.net/vps-hosting/) to a [dedicated host](https://www.atlantic.net/dedicated-server-hosting/dedicated-hosts/) or server, it is often because the total cost of ownership (TCO) is starting to become a concern. One of the greatest benefits of using a Cloud VPS is the flexibility the users have when customizing server specifications. However, there comes a point when a customer outgrows the VPS model, not only will VPS pricing become uneconomical, but the performance trade-off between a VPS and dedicated hardware becomes negligible.
The saturation point will vary between customers, but at Atlantic.Net, our engineers witness customers switching to dedicated hardware when an organization’s VPS host starts to demand around 32GB to 48GB of RAM, usually when the base monthly cost of the VPS starts to become a burden on company finances. However, to understand the best upgrade to make, and lessen the burden of cost or mediocre performance, it is a clever idea to have a basic understanding of the differences between VPS hosting and dedicated servers.
## What Is A VPS (Virtual Private Server)?
VPS is an acronym for a virtual private server. The term is, of course, self-explanatory: a VPS is a virtual machine that is allocated a set value of CPU, disk, and memory from a cloud hypervisor host. The VPS works just like any normal server, it is pretty much impossible to tell the difference. The VPS logically exists as numerous flat files located network-attached storage, and the cloud hypervisor mimics the functionality of a [dedicated server](https://www.atlantic.net/dedicated-server-hosting/), writing the server state to disk. With VPS hosting, the server’s operating system environment and all the necessary apps come pre-built, ready to go within seconds.
We already know that each VPS is allocated CPU, disk, and memory, but these values are dependent on the type of cloud plan the user purchases. Each cloud plan varies; some concentrate on lots of processing power, others provide huge amounts of memory for advanced number crunching, and others focus on high-speed disk for breakneck I/O performance.
A cloud hypervisor’s job is to reserve the specific number of CPU cores and RAM chosen for the individual user’s virtual machine plan. Once allocated, the resources are guaranteed, and this on-demand performance is why VPS hosting is recommended to businesses looking for on-demand web servers far more often than shared web hosting might be. Cloud plans make it extremely easy to upgrade individual VPS components as needed. If you need more memory but are okay with your number of CPU cores, look at the available hosting plans to see which matches your needs.
### The Pros and Cons of Using VPS Hosting
VPS hosting has many advantages. The most noticeable advantage is that it is much cheaper to operate than a dedicated server is. Another powerful advantage is greater flexibility when integrating with additional cloud services, such as managed services, backups, and more. All of these advantages come without costing much more than a shared tenancy hosting platform.
VPS hosting is also easy to upgrade and comes with simple, automated backups. Best of all, a VPS comes configured for remote access, can be cloned within minutes, and comes with built-in monitoring tools.
You have full control over your VPS with Atlantic.Net, as we provide root access to the server. There is no shared kernel, and if your application requires a certain version of the software, no problem, you can install it! On shared hosting, you have to request it from the hosting company, and occasionally the request may be rejected. This only usually happens with legacy software or applications with complicated licensing models such as Java; if it happens to you, you are dead in the water. With these assets in mind, it is easy to see why VPS hosting is popular with web app developers and system administrators.
However, there are a few cons with using VPS hosting. The TCO for VPS hosting can be a lot more expensive than the cost of a dedicated server if a business needs a lot of computing power, data, or bandwidth. While web hosts do an excellent job with their server farms’ physical and logical security, they cannot anticipate each customer’s unique security needs. Companies that need custom security or compliance protocols in place may feel more at ease with a dedicated server.
## What Is A Dedicated Server?
A dedicated server involves the leasing of an entire physical server. A dedicated server gives the user exclusive access to the entire physical computer. Dedicated servers may come pre-built and ready to go, or you can opt for a barebones configuration – the choice is yours! Atlantic.Net can provide consultancy services if you require a specific build of a server; our professional services teams will do the setup for the customer and assist with any additional changes required.
The most significant danger with a business using a dedicated server is jumping into owning one prematurely. If a dedicated server is not required to handle the workload, then that business is spending significantly more than it needs to. You must weigh the benefits; while a dedicated host may effectively future-proof an investment, there may be a chance the server will sit relatively dormant.
### The Pros and Cons of Using a Dedicated Server
The most apparent advantage of a dedicated server is that it focuses on the individual business instead of on a group of customer accounts. Dedicated server solutions offer custom-tailored hardware, software, and services. Atlantic.Net can provide customer Cloud Servers / VPSes to custom-fit the customer’s needs. Nothing can beat the long-term value of a dedicated server in high-demand business environments.
Some cons go with dedicated servers, however. If the customer chooses to operate everything in-house, then expect large capex invoices for purchasing and licensing cloud server equipment. To avoid a high upfront cost, leasing a dedicated server from a cloud services provider will give you all the power needed without an immediate large investment. Instead, a predictable, monthly opex cost will be charged.
Additionally, future upgrades can become complicated, messy, and expensive if not executed by a pragmatic IT team. Migrating to a dedicated server from shared or VPS hosting can also be a difficult transition to make. Because of this, businesses who want a dedicated server but lack their own IT departments can reach out to Atlantic.Net to migrate their existing network infrastructure and to plan/implement any future upgrades.
## Signs It Is Time to Upgrade to a Dedicated Server
There are some clear-cut signs that a business is ready to upgrade to a dedicated server. These might include:
- The existing server is unable to keep up with application demand
- The existing server is suffering from high I/O disk latency
- System monitoring tools consistently showing high system load
- Customers/users are complaining about poor performance
- Network bandwidth limits being reached or VPS plan being exceeded
- Complex compliance needs of the business, such as managing a database containing HIPAA-Compliant data
- The business is hosting a large online community or digital media for its customers
- The business wants to work with data analytics or big data, and have the ability to spike usage then remove the compute VMs while still retaining the data in the cloud. At Atlantic.Net we provide options for On-Demand or Monthly term commits (as well as 1-year and 3-year) but the short term commits enable companies to burst their compute power to tackle projects without having to buy expensive hardware
Determine what signs of strain need to show in daily operations before pursuing a dedicated server upgrade—knowing ahead of time what symptoms to look out for keeps the business prepared to make the switch as soon as possible.
Additionally, determine which IT firm is best to hire for the VPS hosting migration ahead of time. That creates enough time to review different IT agencies to determine the best fit for industry needs, so the decision is not rushed later when the need for upgrading is imminent. A flexible, logical, and well-organized IT team meets the demands of both the individual business and changes in industry technologies. They make any VPS hosting migration to a dedicated server efficient and graceful.
## Ready to Upgrade to a Dedicated Host?
Learn more about our [Dedicated Hosting](https://www.atlantic.net/dedicated-server-hosting/) and talk to a hosting expert today by emailing [sales@atlantic.net](mailto:sales@atlantic.net). We can help you decide whether it’s time to upgrade to a Dedicated Host.
---
# How to Set Up a Mail Server with Modoboa on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-set-up-a-mail-server-with-modoboa-on-ubuntu-20-04/ | Published: 2021-04-08 | Updated: 2023-11-18 | Author: Hitesh Jethva
Modoboa is a free, open-source, complete mail server solution that comes with Postfix and Dovecot. It is written in Python and allows you to set up a fully functional mail server within a minute. You can create an unlimited number of mailboxes and domains from a web-based interface. It has Let’s Encrypt integration and also includes Amavis frontend to block spam and detect viruses in email.
If you are a beginner and don’t know how to set up a mail server, then Modoboa is the best option for you. In this post, we will learn how to set up a mail server with Modoboa on Ubuntu 20.04 server.
## Step 1 – Install Required Dependencies
Before starting, you will need to install Python and other required dependencies to your server. You can install all of them with the following command:
```
apt-get install python3-virtualenv python3-pip git curl gnupg2
```
Once all the packages are installed, set up an FQDN hostname with the following command:
```
hostnamectl set-hostname email.linuxbuz.com
```
## Step 2 – Install and Configure Modoboa
First, download the latest version of Modoboa with the following command:
```
git clone https://github.com/modoboa/modoboa-installer
```
Once the download is completed, change the directory to the downloaded directory and check the configuration file with the following command:
```
cd modoboa-installer
python3 ./run.py --stop-after-configfile-check linuxbuz.com
```
You should see that the Modoboa configuration file is not found:
```
Welcome to Modoboa installer!
Configuration file installer.cfg not found, creating new one.
```
Next, create a configuration file for Modoboa with the following command:
```
nano installer.cfg
```
Change the following lines that match your domain name and email address:
```
[general]
hostname = email.%(domain)s
[certificate]
generate = true
type = letsencrypt
[letsencrypt]
email = admin@gmail.com
[database]
engine = postgres
host = 127.0.0.1
install = true
```
Save and close the file, then start the Modoboa installation with the following command:
```
python3 ./run.py --interactive linuxbuz.com
```
Once the installation has been finished, you should get the following output:
```
Welcome to Modoboa installer!
Warning:
Before you start the installation, please make sure the following DNS records exist for domain 'linuxbuz.com':
email IN A
IN MX email.linuxbuz.com.
Your mail server will be installed with the following components:
modoboa automx amavis clamav dovecot nginx razor postfix postwhite spamassassin uwsgi radicale opendkim
Do you confirm? (Y/n) y
The process can be long, feel free to take a coffee and come back later ;)
Starting...
Generating new certificate using letsencrypt
Installing amavis
Installing spamassassin
Installing razor
Installing clamav
Installing modoboa
Installing automx
Installing radicale
Installing uwsgi
Installing nginx
Installing opendkim
Installing postfix
Installing postwhite
Installing dovecot
Congratulations! You can enjoy Modoboa at https://email.linuxbuz.com (admin:password)
```
Next, you will need to edit the Nginx main configuration file and increase the hash_bucket size limit:
```
nano /etc/nginx/nginx.conf
```
Add the following line after http{
```
server_names_hash_bucket_size 64;
```
Save and close the file, then restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 3 – Access Modoboa Web UI
Now, open your web browser and access the Modoboa web UI using the URL **https://email.linuxbuz.com**. You will be redirected to the Modoboa login page:
Provide default admin username and password as admin / password and click on the **Login** button. You should see the Modoboa dashboard in the following page:
## Conclusion
Congratulations! You have successfully installed the Modoboa mail server on Ubuntu 20.04. You can now add a mailbox from the Modaboa admin panel and start sending mail from the web UI using your [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
---
# How to Install Talkyard Forum with Nginx on Ubuntu 18.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-talkyard-forum-with-nginx-on-ubuntu-18-04/ | Published: 2021-04-09 | Updated: 2023-11-18 | Author: Hitesh Jethva
Talkyard is a free and open-source community discussion platform that helps you to share knowledge with your co-workers, customers, volunteers, users. It is an alternative to other discussion platforms including StackOverflow, Slack, Discourse, and Reddit. You can use it as a knowledge base, customer support, discussion forum, and much more.
In this post, we will show you how to install Talkyard Forum with Nginx on Ubuntu 18.04.
## Step 1 – Install Required Dependencies
First, you will need to install some required dependencies to your server. You can install all of them with the following command:
```
apt-get install git curl gnupg2 unzip -y
```
Once all the dependencies are installed, you can proceed to the next step.
## Step 2 – Download Talkyard
First, you will need to download the Talkyard from the Git Hub repository. You can download it with the following command:
```
git clone -b w-km2 --single-branch https://github.com/debiki/talkyard-prod-one.git talkyard
```
Once the download is completed, change the directory to talkyard and install the required packages with the following command:
```
cd talkyard
./scripts/prepare-ubuntu.sh
```
## Step 3 – Install Docker and Docker Compose
Next, you will need to install the Docker and Docker compose to your system. You can install them by running the following script:
```
./scripts/install-docker-compose.sh
```
Once both are installed, edit the play-framework.conf file and change some required values:
```
nano conf/play-framework.conf
```
Change the following lines:
```
talkyard.becomeOwnerEmailAddress="admin@example.com"
talkyard.hostname="talkyard.example.com"
play.http.secret.key="your-secure-key"
```
Save and close the file, then edit the .env file and define your database password:
```
nano .env
```
Change the following line:
```
POSTGRES_PASSWORD=your-database-password
```
Save and close the file when you are finished.
## Step 4 – Copy Docker Compose File
Next, you will need to copy a desired Docker Compose file depending on how much RAM your server has. If your server has 2GB RAM, copy the following file:
```
cp mem/2g.yml docker-compose.override.yml
```
If your server has 4GB RAM, copy the following file:
```
cp mem/4g.yml docker-compose.override.yml
```
## Step 5 – Install Talkyard
Now, you will need to install the Talkyard with all the required app. You can start the installation by running the following script:
```
./scripts/upgrade-if-needed.sh
```
You should get the following output:
```
2021-03-13T07:23:03+00:00 upgrade-script: Installing: Starting version v0.2021.08-639ccf013...
Creating network "talkyard_internal_net" with driver "bridge"
Creating talkyard_cache_1 ... done
Creating talkyard_rdb_1 ... done
Creating talkyard_search_1 ... done
Creating talkyard_app_1 ... done
Creating talkyard_web_1 ... done
2021-03-13T07:23:09+00:00 upgrade-script: Installing: Setting current version number to v0.2021.08-639ccf013...
2021-03-13T07:23:09+00:00 upgrade-script: Done. Bye.
```
Once the installation is completed, you can check all running containers with the following command:
```
docker ps
```
You should see the following output:
```
CONTAINER ID I
MAGE COMMAND CREATED STATUS PORTS NAMES
5793fefc561b debiki/talkyard-web:v0.2021.08-639ccf013 "/bin/sh -c '/etc/ng…" 31 seconds ago Up 28 seconds 0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp talkyard_web_1
b3fee6dd28b8 debiki/talkyard-app:v0.2021.08-639ccf013 "/bin/sh -c 'rm -f /…" 32 seconds ago Up 3 seconds 3333/tcp, 9000/tcp, 9443/tcp, 9999/tcp talkyard_app_1
0898dbac769d debiki/talkyard-cache:v0.2021.08-639ccf013 "docker-entrypoint.s…" 36 seconds ago Up 32 seconds 6379/tcp talkyard_cache_1
e583d8a4d553 debiki/talkyard-rdb:v0.2021.08-639ccf013 "/chown-logs-then-ex…" 36 seconds ago Restarting (1) 5 seconds ago talkyard_rdb_1
878e757d274d debiki/talkyard-search:v0.2021.08-639ccf013 "/docker-entrypoint.…" 36 seconds ago Up 33 seconds 9200/tcp, 9300/tcp talkyard_search_1
```
## Step 6 – Setup Cron Job
Next, you will need to set up a cron job to schedule auto backup and enable automatic upgrades. You can set up it by running the following scripts:
```
./scripts/schedule-logrotate.sh
./scripts/schedule-daily-backups.sh
./scripts/schedule-automatic-upgrades.sh
```
You can also check the Talkyard container log with the following command:
```
docker-compose logs app
docker-compose logs rdb
```
## Step 7 – Access Talkyard
At this point, Talkyard is installed and configured. Now, open your web browser and access the URL **http://talkyard.example.com**. You will be redirected to the following page:
Click on the **Continue** button. You should see the following page:
Provide your admin email, username, and password, and click on the **Create Account** button. You will be redirected to the following page:
Provide your community name and click on the **Next** button. You should see the Talkyard dashboard on the following page:
## Conclusion
Congratulations! You have successfully installed and configured Talkyard on Ubuntu 18.04. You can now create your own discussion forum with Talkyard easily using your [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net.
---
# How to Install EteSync Server on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-etesync-server-on-ubuntu-20-04/ | Published: 2021-04-12 | Updated: 2023-11-23 | Author: Hitesh Jethva
EteSync is a free, open-source, and end-to-end tool used to sync your contacts, calendars, tasks, and notes. It can be easily integrated with your existing apps. You just need one password for login and encryption. EteSync has the ability to share data with other users and synchronization between multiple devices. It also provides an add-on for Mozilla Thunderbird and a client for Web, Desktop, Android, and iOS.
In this post, we will show you how to install EteSync on Ubuntu 20.04 server.[jumpbox]
## Step 1 – Install and Configure MariaDB Database
EteSync uses MariaDB as a database backend, so the latest version of MariaDB must be installed on your server.
First, install the required dependencies with the following command:
```
apt-get update -y
apt-get install software-properties-common curl git gnupg2 -y
```
Next, download and add the GPG key and repository with the following command:
```
apt-key adv --recv-keys --keyserver hkp://keyserver.ubuntu.com:80 0xF1656F24C74CD1D8
add-apt-repository 'deb [arch=amd64,arm64,ppc64el] http://mirror.lstn.net/mariadb/repo/10.5/ubuntu focal main'
```
Next, install the latest version of the MariaDB server with the following command:
```
apt-get install mariadb-server -y
```
Next, connect to the MariaDB and create a database and user:
```
mysql
```
Once connected, create a database and user with the following command:
```
create database etebase;
create user etebase@localhost identified by 'password';
```
Next, grant all the privileges to the etebase database with the following command:
```
grant all privileges on etebase.* to etebase@localhost;
```
Next, flush the privileges and exit from the MariaDB with the following command:
```
flush privileges;
exit;
```
## Step 2 – Install EteSync
First, you will need to install all Python dependencies to your server. You can install all of them with the following command:
```
apt-get install python3-virtualenv python3-pip gcc build-essential libmysqlclient-dev -y
```
Once all the dependencies are installed, download the latest version of EteSync with the following command:
```
git clone https://github.com/etesync/server.git etebase
```
Next, change the directory to the downloaded directory and create a Python virtual environment with the following command:
```
cd etebase
virtualenv -p python3 .venv
```
Next, activate the virtual environment with the following command:
```
source .venv/bin/activate
```
Next, install all required dependencies with the following command:
```
pip install -r requirements.txt
```
Next, rename the example configuration file:
```
cp etebase-server.ini.example etebase-server.ini
```
Next, edit the configuration file with the following command:
```
nano etebase-server.ini
```
Change the following lines:
```
media_root = /mnt
allowed_host1 = etebase.example.com
;engine = django.db.backends.sqlite3
;name = db.sqlite3
engine = django.db.backends.mysql
name = etebase
user = etebase
password = password
host = 127.0.0.1
port = 3306
```
Save and close the file, then install the Django web socket server and MariaDB client with the following command:
```
pip3 install daphne mysqlclient aioredis
```
Next, create Django’s static files with the following command:
```
./manage.py collectstatic
```
Next, initialize the application with the following command:
```
./manage.py migrate
```
Next, start the EteSync server with the following command:
```
daphne -b 0.0.0.0 -p 8001 etebase_server.asgi:application
```
You should get the following output:
```
2021-03-13 04:30:04,102 INFO Starting server at tcp:port=8001:interface=0.0.0.0
2021-03-13 04:30:04,103 INFO HTTP/2 support not enabled (install the http2 and tls Twisted extras)
2021-03-13 04:30:04,103 INFO Configuring endpoint tcp:port=8001:interface=0.0.0.0
2021-03-13 04:30:04,104 INFO Listening on TCP address 0.0.0.0:8001
```
Press CTRL+C to stop the server.
## Step 3 – Create a Systemd Service File for EteSync
Next, you will need to create a systemd service file for EteSync. You can create it with the following command:
```
nano /etc/systemd/system/etebase.service
```
Add the following lines:
```
[Unit]
Description=EteSync: End-to-End Encryption to Sync Calendar, Contacts, Tasks and Notes.
[Service]
WorkingDirectory=/root/etebase/
ExecStart=/root/etebase/.venv/bin/daphne -b 127.0.0.1 -p 8001 -u /tmp/etebase_server.sock etebase_server.asgi:application
User=root
Group=root
Restart=always
RestartSec=5s
[Install]
WantedBy=multi-user.target
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start the EteSync service and enable it to start at system reboot with the following command:
```
systemctl start etebase
systemctl enable etebase
```
Next, verify the status of the EteSync service with the following command:
```
systemctl status etebase
```
You should get the following output:
```
● etebase.service - EteSync: End-to-End Encryption to Sync Calender, Contacts, Tasks and Notes.
Loaded: loaded (/etc/systemd/system/etebase.service; disabled; vendor preset: enabled)
Active: active (running) since Sat 2021-03-13 04:30:57 UTC; 6s ago
Main PID: 13641 (daphne)
Tasks: 1 (limit: 2353)
Memory: 48.5M
CGroup: /system.slice/etebase.service
└─13641 /root/etebase/.venv/bin/python /root/etebase/.venv/bin/daphne -b 127.0.0.1 -p 8001 -u /tmp/etebase_server.sock etebase_se>
Mar 13 04:30:57 ubuntu2004 systemd[1]: Started EteSync: End-to-End Encryption to Sync Calender, Contacts, Tasks and Notes..
Mar 13 04:30:58 ubuntu2004 daphne[13641]: 2021-03-13 04:30:58,437 INFO Starting server at tcp:port=8001:interface=127.0.0.1, unix:/tmp/ete>
Mar 13 04:30:58 ubuntu2004 daphne[13641]: 2021-03-13 04:30:58,438 INFO HTTP/2 support not enabled (install the http2 and tls Twisted extra>
Mar 13 04:30:58 ubuntu2004 daphne[13641]: 2021-03-13 04:30:58,439 INFO Configuring endpoint tcp:port=8001:interface=127.0.0.1
Mar 13 04:30:58 ubuntu2004 daphne[13641]: 2021-03-13 04:30:58,441 INFO Listening on TCP address 127.0.0.1:8001
Mar 13 04:30:58 ubuntu2004 daphne[13641]: 2021-03-13 04:30:58,441 INFO Configuring endpoint unix:/tmp/etebase_server.sock
```
## Step 4 – Configure Nginx for EteSync
Next, install the Nginx with the following command:
```
apt-get install nginx -y
```
Once installed, create an Nginx virtual host configuration file with the following command:
```
nano /etc/nginx/conf.d/etebase.conf
```
Add the following lines:
```
upstream etebase {
server unix:/tmp/etebase_server.sock;
}
server {
listen 80;
server_name etebase.example.com;
charset utf-8;
access_log /var/log/nginx/etebase.access;
error_log /var/log/nginx/etebase.error;
# max upload size
client_max_body_size 75M;
location /static/ {
alias /root/etebase/static/;
}
location / {
proxy_pass http://etebase;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_redirect of/f;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Host $server_name;
}
}
```
Save and close the file, then restart the Nginx service to apply the changes:
```
systemctl restart nginx
```
## Step 5 – Create an Admin User
Next, you will need to create an administrative user for EteSync.
First, change the directory to etebase and activate the virtual environment if not activated:
```
cd etebase
source .venv/bin/activate
```
Next, create a superuser with the following command:
```
./manage.py createsuperuser
```
Provide all information as shown below:
```
Username: admin
Email address: admin@example.com
Password:
Password (again):
Superuser created successfully.
```
## Step 6 – Access EteSync
Now, open your web browser and access your EteSync web interface using the URL **http://etebase.example.com/admin**. You should see the following page:
Provide your username, password and click on the **Login** button. You should see the EteSync dashboard on the following page:
## Conclusion
Congratulations! You have successfully installed and configured EteSync on Ubuntu 20.04 server. You can now easily sync your contacts, calendars, tasks, and notes using [VPS hosting](https://www.atlantic.net/vps-hosting/) from Atlantic.Net!
---
# How to Install Socioboard on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-socioboard-on-ubuntu-20-04/ | Published: 2021-04-13 | Updated: 2024-01-18 | Author: Hitesh Jethva
Socioboard is a free, open-source social media management tool used for managing multiple social media channels from a central dashboard. It is used by small and medium-sized businesses for lead generation, marketing, customer support, and automated engagement. It comes with a rich set of features including advanced scheduling & publishing tools, social CRM tools, customizability, scalability, customer support, Helpdesk integration, and more.
In this post, we will show you how to install Socioboard with Apache on Ubuntu 20.04.
## Step 1 – Install Apache, PHP and MariaDB
First, Apache, PHP, MariaDB, and other required packages by running the following command:
```
apt-get update -y
apt-get install apache2 mariadb-server php libapache2-mod-php7.4 php7.4-cli php7.4-mysql php7.4-common php7.4-json php7.4-opcache php7.4-readline php7.4-curl php7.4-gd php7.4-xml git curl gnupg2 -y
```
After installing all the packages, you can proceed to the next step.
## Step 2 – Create a MariaDB Database
Next, you will need to create a database and user for Socioboard. First, connect to MariaDB with the following command:
```
mysql
```
Once connected, create a database and user with the following command:
```
create database socioboarddb;
create user socioboarduser@localhost identified by 'password';
```
Next, grant all the privileges with the following command:
```
grant all privileges on socioboarddb.* to socioboarduser@localhost;
```
Next, flush the privileges and exit from MariaDB with the following command:
```
flush privileges;
exit;
```
## Step 3 – Install and Configure MongoDB
Next, you will need to install MongoDB and create a database for Socioboard.
First, add the MongoDB repository with the following command:
```
wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | apt-key add -
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-4.4.list
```
Next, update the repository and install MongoDB with the following command:
```
apt-get update -y
apt-get install mongodb-org -y
```
Next, start the MongoDB service with the following command:
```
systemctl start mongod
```
Next, connect MongoDB and create a database and user with the following command:
```
mongo
use socioboarddb
db.new_collection.insert({ some_key: "some_value" })
db.createUser(
{
user: "socioboarduser",
pwd: "password",
roles: [ { role: "readWrite", db: "socioboarddb" } ]
}
)
```
Next, exit from the Mongo shell with the following command:
```
exit
```
## Step 4 – Install Node.js
First, install the necessary dependencies using the following command.
```
apt-get install -y ca-certificates curl gnupg
```
Next, download the Node.js GPG key.
```
mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
```
Next, add the NodeSource repo to the APT source list.
```
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_18.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
```
Then, update the repository index and install the Ndoe.js with the following command.
```
apt update
apt-get install -y nodejs
```
Next, verify the Node.js version using the following command.
```
node -v
```
Output.
```
v18.19.0
```
## Step 5 – Install Socioboard
First, download the latest version of Socioboard and copy it to the Apache web root directory:
```
git clone https://github.com/socioboard/Socioboard-4.0.git
mv Socioboard-4.0 /var/www/html/socioboard
```
Next, change the ownership of the socioboard directory to www-data:
```
chown -R www-data:www-data /var/www/html/socioboard
```
Next, edit the config.json file and define your MariaDB database settings:
```
nano /var/www/html/socioboard/socioboard-api/library/sequelize-cli/config/config.json
```
Change the following lines:
```
{
"development": {
"username": "socioboarduser",
"password": "password",
"database": "socioboarddb",
"host": "127.0.0.1",
"dialect": "mysql",
"operatorsAliases": false,
"pool": {
"max": 100,
"min": 0,
"acquire": 1000000,
"idle": 200000
},
```
Save and close the file, then change the directory to feeds, library, notification, and publish directory and install all the dependencies for each:
```
cd /var/www/html/socioboard/socioboard-api/feeds
npm install
npm audit fix
cd /var/www/html/socioboard/socioboard-api/library
npm install
cd /var/www/html/socioboard/socioboard-api/notification
npm install
cd /var/www/html/socioboard/socioboard-api/publish
npm install
cd /var/www/html/socioboard/socioboard-api/user
npm install
```
Next, initialize the database with the following command:
```
cd /var/www/html/socioboard/socioboard-api/library/sequelize-cli/
NODE_ENV=development sequelize db:migrate
```
Next, list all files inside seeders directory:
```
ls /var/www/html/socioboard/socioboard-api/library/sequelize-cli/seeders/
```
Output:
```
20190213051930-initialize_application_info.js
20190507065043-initialize_dummy_users.js
20190507122417-initialize_socialaccounts.js
20190509121650-unauthorized_unittest_accounts.js
```
Next, pick the file that ends with initialize_application_info.js and run the following command:
```
NODE_ENV=development sequelize db:seed --seed 20190213051930-initialize_application_info.js
```
Next, edit the development.json and define your MongoDB database:
```
nano /var/www/html/socioboard/socioboard-api/user/config/development.json
```
Change the following lines:
```
"mongo": {
"username": "socioboarduser",
"password": "password",
"host": "localhost",
"db_name": "socioboarddb"
},
```
Save and close the file then edit each of the following files and define your MongoDB database settings:
```
nano /var/www/html/socioboard/socioboard-api/feeds/config/development.json
nano /var/www/html/socioboard/socioboard-api/notification/config/development.json
nano /var/www/html/socioboard/socioboard-api/publish/config/development.json
```
## Step 6 – Create a Systemd Service File for Socioboard
First, create a systemd service file for Socioboard user with the following command:
```
nano /etc/systemd/system/socioboard-user.service
```
Add the following lines:
```
[Unit]
Description=SocioBoard User Microservice
After=multi-user.target
[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/html/socioboard/socioboard-api/user/
Environment=NODE_ENV=development
ExecStart=/usr/bin/nodemon app.js
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
```
Save and close the file, then create a systemd service file for Socioboard publish with the following command:
```
nano /etc/systemd/system/socioboard-publish.service
```
Add the following lines:
```
[Unit]
Description=SocioBoard Publish Microservice
After=multi-user.target
[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/html/socioboard/socioboard-api/publish/
Environment=NODE_ENV=development
ExecStart=/usr/bin/nodemon app.js
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
```
Save and close the file, then create a systemd service file for Socioboard feeds with the following command:
```
nano /etc/systemd/system/socioboard-feeds.service
```
Add the following lines:
```
[Unit]
Description=SocioBoard Feeds Microservice
After=multi-user.target
[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/html/socioboard/socioboard-api/feeds/
Environment=NODE_ENV=development
ExecStart=/usr/bin/nodemon app.js
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
```
Save and close the file, then create a systemd service file for Socioboard notification:
```
nano /etc/systemd/system/socioboard-notification.service
```
Add the following lines:
```
[Unit]
Description=SocioBoard Notification Microservice
After=multi-user.target
[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/html/socioboard/socioboard-api/notification/
Environment=NODE_ENV=development
ExecStart=/usr/bin/nodemon app.js
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
```
Save and close the file, then reload the systemd daemon with the following command:
```
systemctl daemon-reload
```
Next, start all the services and enable them to start at system reboot:
```
systemctl start socioboard-user socioboard-publish socioboard-feeds socioboard-notification
systemctl enable socioboard-user socioboard-publish socioboard-feeds socioboard-notification
```
Next, verify the status of all services with the following command:
```
systemctl status socioboard-user socioboard-publish socioboard-feeds socioboard-notification
```
## Step 7 – Configure Socioboard-web-php
Next, change the directory to socioboard-web-php with the following command:
```
cd /var/www/html/socioboard/socioboard-web-php/
```
Note: If you encounter any issues with the following, retry after disabling IPV6
```
sysctl -w net.ipv6.conf.all.disable_ipv6=1
```
Next, install the Composer with the following command:
```
apt-get install composer -y
```
Next, install the Laravel components with the following command:
```
composer global require laravel/installer
```
Next, rename the environment variable file with the following command:
```
mv environmentfile.env .env
```
Next, edit the .env file:
```
nano .env
```
Change the following lines:
```
APP_URL=http://socioboard.linuxbuz.com/
API_URL=http://localhost:3000/
API_URL_PUBLISH=http://localhost:3001/
API_URL_FEEDs=http://localhost:3002/
API_URL_NOTIFY=http://localhost:3003/
```
Save and close the file, then update the composer with the following command:
```
composer update
```
Next, generate the Laravel app key with the following command:
```
php artisan key:generate
```
## Step 8 – Configure Apache for Socioboard
Next, create an Apache virtual host configuration file for Socioboard:
```
nano /etc/apache2/sites-available/socioboard.conf
```
Add the following lines:
```
ServerName socioboard.linuxbuz.com
DocumentRoot /var/www/html/socioboard/socioboard-web-php/public/
DirectoryIndex index.php
Options +FollowSymLinks
AllowOverride All
Require all granted
ErrorLog ${APACHE_LOG_DIR}/socioboard.error.log
CustomLog ${APACHE_LOG_DIR}/socioboard.access.log combined
```
Save and close the file, then enable the Apache virtual host and rewrite module with the following command:
```
a2ensite socioboard.conf
a2enmod rewrite
```
Next, restart the Apache and Socioboard services with the following command:
```
systemctl restart apache2
systemctl restart socioboard-user socioboard-publish socioboard-feeds socioboard-notification
```
## Step 9 – Access Socioboard
Now, open your web browser and access the Socioboar using the URL **http://socioboard.linuxbuz.com**. You should see the following page:
Click on the **Create** **New** button to create a new account. You should see the following page:
Provide all the details and click on the **Create an account now** button.
Socioboard tries to send a verification email, but it can not send an email. You will need to activate the account from the MariaDB console.
Connect to the MariaDB with the following command:
```
mysql
```
Once connected, change the database to socioboarddb and activate the account with the following command:
```
use socioboarddb;
update user_activations set activation_status = 1;
```
Next, change the account to Platinum plan with the following command:
```
update user_activations set user_plan = 7;
```
Next, exit from the MariaDB with the following command:
```
exit;
```
Now go back to your web interface, enter your email and password which you have provided during the registration process, and click on the Login button. You should see the Socioboard dashboard on the following page:
## Conclusion
In the above guide, you learned how to install Socioboard on Ubuntu 20.04. You can implement it in your organizations and manage all social media channels from the central dashboard on your [VPS hosting](https://www.atlantic.net/vps-hosting/) account from Atlantic.Net!
---
# Broward County Schools Ransomware Attack
> URL: https://www.atlantic.net/dedicated-server-hosting/broward-county-schools-ransomware-attack/ | Published: 2021-04-14 | Updated: 2026-05-03 | Author: Richard Bailey
*Atlantic.Net is providing this security advisory as a news item; we want to reassure our customers that Atlantic.Net does not use any of these products affected by this exploit internally or in any of our service offerings.*
Local news reported that Florida-based Broward County Public Schools are in the midst of a serious cybersecurity incident. Experts believe a cybersecurity attack took place against Broward IT Systems in early [March](https://www.sun-sentinel.com/local/schools/fl-ne-broward-schools-computer-malware-20210309-6sjzaxdmyvcuhjmlxefpqrinfi-story.html). Broward County is home to approximately 240 public schools, ranging from elementary to high schools, and some 260,000 students attend schools in this Florida district.
[Reports](https://www.wptv.com/news/state/broward/computer-hackers-demand-40-million-ransom-from-broward-county-public-schools) suggest that the schools’ computer systems have been targeted by a ransomware attack. Most shockingly, the cybercriminals are demanding a payment of $40 million or they will release “personal information” about students and staff. So far, Broward County Schools have remained tight-lipped, neither confirming nor denying the cybersecurity threat.
## What do we know about the Broward County Schools breach?
The Hackers claim to have stolen 1.5TB of data from the Broward County Schools backend IT systems. In a [transcript of phone messages published online](https://www.scribd.com/document/501190779/Broward-County-Public-Schools-ransom-chat#fullscreen&from_embed), the hackers claim that “personal data, including financial, contracts, databases and other documents containing (Social Security numbers) addresses (dates of birth) and other information about students and teachers” had been stolen.
Many students are still having to learn remotely due to the Covid-19 pandemic, and these students and parents reported issues with some of Broward County IT Systems on the 9th of March 2021. Students were unable to access the primary learning platform known as Canvas. Other applications were reported offline including Pinnacle (a grading and attendance tool), and access to some of the school databases was cut.
The[South Florida Sun-Sentinel](https://www.sun-sentinel.com/local/schools/fl-ne-broward-schools-computer-malware-20210309-6sjzaxdmyvcuhjmlxefpqrinfi-story.html) started to receive information from parents and teachers that “Pinnacle was scheduled to be back online at noon Wednesday [10th March]. A program called Virtual Counselor would be back up at noon Saturday [13th March] and one called BASIS, which hosts a variety of student data, would be up at 10 a.m. Monday [15th March].” This information seems to add credibility that the ransomware attack was genuine.
The hackers are believed to be the group known as Conti. Not much is known about Conti, but they are thought to be based in Russia, and there is online chatter that the group is a successor to Ryuk. They do have a reputation; British retailer[FatFace paid Conti £2 million](https://www.cybernewsgroup.co.uk/fat-face-pays-2m-to-conti-ransomware-gang/) in March 2021, so there is a good chance that they are expecting Broward County Schools to pay the ransom.
According to a leaked Scribd conversation allegedly between Conti and Broward County, an offer of $500,000 was made to the hackers. We don’t know if this was accepted or what has happened, there has been radio silence from the Conti dark web leak site that published the information. Maybe they have been paid? We simply do not know!
## What are the likely causes of the breach?
We can only speculate at the moment because the schools have not released anything directly, but we expect this breach to be caused by a lack of training. Either a member of staff or a student with access to the internal systems clicked on a phishing email, a malicious URL link, or a TrickBot website, or they downloaded a compromised attachment embedded with malware.
Broward Schools manage and support their own private IT network, and it is believed to be operated in-house and managed at their [head office](https://www.browardschools.com/domain/13490). It’s possible a system was secured with a weak, guessable password. It is also likely that they were targeted simply because they are a school, as public schools have strict, limited budgets and cybersecurity may not always be the number one priority.
Schools are data-rich environments; they hold sensitive data on students who are approaching adulthood and will soon be applying for bank accounts, credit cards, and student loans. The data is valuable as it could potentially be used for fraud.
Broward Schools may have been targeted because of the enforced remote working for students and teachers, In December 2020, the [Cybersecurity and Infrastructure Security](https://www.cisa.gov/stopransomware/official-alerts-statements-cisa) Agency, a federal agency, said cybercriminals like Conti have been aiming their sights more on schools due to the transition to remote learning during the COVID-19 pandemic.
## What happens next?
With Broward County Schools being tight-lipped, it is very much a case of “wait and see what happens.” Have they paid the ransom? Have they even been hacked? Truthfully no one knows yet, and while some suggestive evidence has been released, there is no way of validating if it’s genuine.
If your business is concerned about cybersecurity. please feel welcome to reach out to Atlantic.Net. We are specialists in Managed Services, Cloud Hosting, and HIPAA compliance. Security of our infrastructure is of paramount importance, and we work hard to ensure we have the best security processes in place.
There is no doubt that this cyberattack is a very sensitive incident. Targeting schools is very demoralizing, and we feel concerned for any of our friends in the state of Florida that might be affected by this. Atlantic.Net has a full suite of [Managed Security Services](https://www.atlantic.net/pci-compliant-hosting/pci-security-services/) to help be proactive and prepare in advance for any security issues. Get in touch today.
---
# How to Upgrade Ubuntu 20.04 to Ubuntu 21.04
> URL: https://www.atlantic.net/vps-hosting/how-to-upgrade-ubuntu-20-04-to-ubuntu-21-04/ | Published: 2021-04-26 | Updated: 2023-11-27 | Author: Hitesh Jethva
The new Ubuntu 21.04 (Hirsute Hippo) has been released on 22 April 2021. Ubuntu 20.04 is long-term support and will be supported for five years. Ubuntu 21.04 is not a long-term support release, meaning it will be kept until January 2022 (9 months).
Before upgrading to Ubuntu 21.04 version, you should be aware of the following things:
- The upgrade will download a couple of GBs of data so you will need a good internet connection.
- Backing your essential files to an external hard disk is always recommended.
- After upgrading to a newer version, you can revert to the older version.
- Upgrading to a newer version will turn off the third-party repositories that you have added on your own.
This post will show you how to upgrade from Ubuntu 20.04 to Ubuntu 21.04.
## Step 1 – Update the System
Before starting, check the current version of Ubuntu with the following command:
```
lsb_release -a
```
You should see the following output:
```
Distributor ID: Ubuntu
Description: Ubuntu 20.04 LTS
Release: 20.04
Codename: focal
```
Next, update your system to the latest packages with the following command:
```
apt-get update -y
apt-get upgrade -y
apt-get dist-upgrade -y
```
Next, install the update-manager-core with the following command:
```
apt-get install update-manager-core -y
```
Next, remove all unwanted packages with the following command:
```
apt-get clean
apt-get --purge autoremove
```
Next, restart your system to apply the changes:
```
reboot
```
## Step 2 – Upgrade 20.04 to Ubuntu 21.04
Ubuntu 21.04 is a non-LTS version, so you will need to edit the file /etc/update-manager/release-upgrades and change the LTS version to normal:
```
nano /etc/update-manager/release-upgrades
```
Find the following line:
```
Prompt=lts
```
Replaced it with the next line:
```
Prompt=normal
```
Save and close the file when you are finished.
Run the following command to upgrade to Ubuntu 20.10 first. After that, follow the same steps to upgrade to Ubuntu 21.04.
```
do-release-upgrade
```
Follow the on-screen installation instructions to finish the process.
Once the upgrade process has been completed, your system will be restarted automatically.
After restarting, log in to your system and verify the version of your Ubuntu with the following command:
```
lsb_release -a
```
```
Distributor ID: Ubuntu
Description: Ubuntu 20.10
Release: 20.10
Codename: groovy
```
Now, run the following command to upgrade from Ubuntu 20.10 to 21.04:
```
do-release-upgrade -d
```
After restarting, log in to your system and verify the version of your Ubuntu with the following command:
```
lsb_release -a
```
You should see that your system will be updated to Ubuntu 21.04:
```
Distributor ID: Ubuntu
Description: Ubuntu 21.04
Release: 21.04
Codename: hirsute
```
## Conclusion
The above guide taught you how to upgrade from Ubuntu 20.04 to Ubuntu 21.04. Ubuntu 21.04 is a non-LTS version, so stick with the Ubuntu 20.04 version if you need a stable version. If you don’t, try it on your [virtual private server](https://www.atlantic.net/vps-hosting/) today!
---
# How to Install ClickHouse on Ubuntu 20.04
> URL: https://www.atlantic.net/vps-hosting/how-to-install-clickhouse-on-ubuntu-20-04/ | Published: 2021-04-27 | Updated: 2023-11-17 | Author: Hitesh Jethva
ClickHouse is a free, open-source, fast OLAP database management system used to generate analytical reports using SQL queries in real-time. It is column-oriented and has other important characteristics like user-friendliness, scalability, and security. It stores records in blocks grouped by columns instead of rows. Compared to row-based systems, column-oriented databases spend less time reading and computing the data.
In this post, we will show you how to install and ClickHouse on Ubuntu 20.04 server.
## Step 1 – Add ClickHouse Repository
By default, ClickHouse is not included in the Ubuntu 20.04 default repository, so you will need to add the ClickHouse repository to your system.
First, install the required dependencies using the following command:
```
apt-get install curl gnupg2 wget git apt-transport-https ca-certificates -y
```
Once all the dependencies are installed, add the GPG key with the following command:
```
apt-key adv --keyserver keyserver.ubuntu.com --recv E0C56BD4
```
Output:
```
Executing: /tmp/apt-key-gpghome.kaYYOnkSVy/gpg.1.sh --keyserver keyserver.ubuntu.com --recv E0C56BD4
gpg: key C8F1E19FE0C56BD4: public key "ClickHouse Repository Key " imported
gpg: Total number processed: 1
gpg: imported: 1
```
Next, add the ClickHouse repository to APT with the following command:
```
echo "deb http://repo.yandex.ru/clickhouse/deb/stable/ main/" | tee /etc/apt/sources.list.d/clickhouse.list
```
Next, update the repository with the following command:
```
apt-get update -y
```
## Step 2 – Install ClickHouse
Now, install the ClickHouse server and client with the following command:
```
apt-get install clickhouse-server clickhouse-client -y
```
Once the ClickHouse is installed, start the ClickHouse service and enable it to start at system reboot:
```
systemctl start clickhouse-server
systemctl enable clickhouse-server
```
You can now verify the status of the ClickHouse with the following command:
```
systemctl status clickhouse-server
```
Output:
```
● clickhouse-server.service - ClickHouse Server (analytic DBMS for big data)
Loaded: loaded (/etc/systemd/system/clickhouse-server.service; enabled; vendor preset: enabled)
Active: active (running) since Wed 2021-05-05 03:17:41 UTC; 4s ago
Main PID: 26649 (clckhouse-watch)
Tasks: 46 (limit: 2353)
Memory: 46.4M
CGroup: /system.slice/clickhouse-server.service
├─26649 clickhouse-watchdog --config=/etc/clickhouse-server/config.xml --pid-file=/run/clickhouse-server/clickhouse-server>
└─26650 /usr/bin/clickhouse-server --config=/etc/clickhouse-server/config.xml --pid-file=/run/clickhouse-server/clickhouse-server>
May 05 03:17:41 ubuntu2004 systemd[1]: Started ClickHouse Server (analytic DBMS for big data).
May 05 03:17:41 ubuntu2004 clickhouse-server[26649]: Processing configuration file '/etc/clickhouse-server/config.xml'.
May 05 03:17:41 ubuntu2004 clickhouse-server[26649]: Logging trace to /var/log/clickhouse-server/clickhouse-server.log
May 05 03:17:41 ubuntu2004 clickhouse-server[26649]: Logging errors to /var/log/clickhouse-server/clickhouse-server.err.log
May 05 03:17:41 ubuntu2004 clickhouse-server[26650]: Processing configuration file '/etc/clickhouse-server/config.xml'.
May 05 03:17:41 ubuntu2004 clickhouse-server[26650]: Saved preprocessed configuration to '/var/lib/clickhouse/preprocessed_configs/config.xml'.
May 05 03:17:41 ubuntu2004 clickhouse-server[26650]: Processing configuration file '/etc/clickhouse-server/users.xml'.
May 05 03:17:41 ubuntu2004 clickhouse-server[26650]: Saved preprocessed configuration to '/var/lib/clickhouse/preprocessed_configs/users.xml'.
```
## Step 3 – Set ClickHouse Password
By default, ClickHouse is configured without a password, so you will need to set the password for the default user. You can set it by editing the file users.xml:
```
nano /etc/clickhouse-server/users.xml
```
Find the following line:
```
```
And, replaced it with the following command:
```
MyPassword
```
Save and close the file, then restart the ClickHouse service to apply the changes:
```
systemctl restart clickhouse-server
```
## Step 4 – Working with ClickHouse
In this section, we will show you how to interact with the ClickHouse database.
First, connect ClickHouse using the following command:
```
clickhouse-client --password
```
You will be asked to provide a password for the default user as shown below:
```
ClickHouse client version 21.4.6.55 (official build).
Password for user (default):
```
Provide your password and hit **ENTER**. Once you are connected, you will be redirected to the ClickHouse shell:
```
Connecting to localhost:9000 as user default.
Connected to ClickHouse server version 21.4.6 revision 54447.
ubuntu2004 :)
```
To create a database named mydb, run the following command:
```
ubuntu2004 :) CREATE DATABASE mydb;
```
Output:
```
CREATE DATABASE mydb
Query id: 9f82c771-a072-495e-b2a7-cc9618d9b73f
Ok.
0 rows in set. Elapsed: 0.008 sec.
```
Change the database to mydb, run the following command:
```
ubuntu2004 :) USE mydb;
```
Output:
```
USE mydb
Query id: d94a4fb5-f3fd-41a9-a27f-0bb9efa9e020
Ok.
0 rows in set. Elapsed: 0.002 sec.
```
To create a table named data, run the following command:
```
ubuntu2004 :) CREATE TABLE data ( id UInt64, name String, url String, created DateTime ) ENGINE = MergeTree() PRIMARY KEY id ORDER BY id;
```
Output:
```
CREATE TABLE data
(
`id` UInt64,
`name` String,
`url` String,
`created` DateTime
)
ENGINE = MergeTree
PRIMARY KEY id
ORDER BY id
Query id: 6039b4d9-c296-4115-b4bb-06a1bbe5499f
Ok.
0 rows in set. Elapsed: 0.011 sec.
```
Insert some data into the table with the following command:
```
ubuntu2004 :) INSERT INTO data VALUES (1, 'hitesh', 'http://example.com', '2021-05-01 00:01:01');
```
Output:
```
INSERT INTO data VALUES
Query id: f7dfd959-688a-4481-8fb8-85e49c669b9e
Ok.
1 rows in set. Elapsed: 0.022 sec.
```
To add a new column, run the following command:
```
ubuntu2004 :) ALTER TABLE data ADD COLUMN location String;
```
Output:
```
ALTER TABLE data
ADD COLUMN `location` String
Query id: 7d40bfee-0d0c-4113-bcd9-fd89ac42b82b
Ok.
0 rows in set. Elapsed: 0.038 sec.
```
To retrieve the data from the table, run the following command:
```
ubuntu2004 :) SELECT url, name FROM data WHERE url = 'http://example.com' LIMIT 1;
```
Output:
```
SELECT
url,
name
FROM data
WHERE url = 'http://example.com'
LIMIT 1
Query id: 60dd1e11-f2d9-4b33-8403-6e1859fa266a
┌─url────────────────┬─name───┐
│ http://example.com │ hitesh │
└────────────────────┴────────┘
1 rows in set. Elapsed: 0.007 sec.
```
To delete a column from the data table, run the following command:
```
ubuntu2004 :) ALTER TABLE data DROP COLUMN location;
```
Output:
```
ALTER TABLE data
DROP COLUMN location
Query id: 6feffa20-7d33-490f-b8b5-a2d3c1ad93a1
Ok.
0 rows in set. Elapsed: 0.017 sec.
```
To delete a data table, run the following command:
```
ubuntu2004 :) DROP TABLE data;
```
Output:
```
DROP TABLE data
Query id: bbac3bd1-8f1d-40b9-8f35-e5816de45855
Ok.
0 rows in set. Elapsed: 0.008 sec.
```
To delete a mydb database, run the following command:
```
ubuntu2004 :) DROP DATABASE mydb;
```
Output:
```
DROP DATABASE mydb
Query id: 6fa79629-e2a9-4dcc-ba11-4a6684a085c3
Ok.
0 rows in set. Elapsed: 0.002 sec.
```
Next, exit from the ClickHouse shell with the following command:
```
ubuntu2004 :) exit;
```
## Step 5 – Enable ClickHouse Web UI
By default, ClickHouse web UI is disabled. You will need to enable it by editing the file config.xml:
```
nano /etc/clickhouse-server/config.xml
```
Uncomment and change the **listen_host** line and **http_server_default_response** as shown below:
```
0.0.0.0