And while many SaaS tools can monitor your site, they often charge high monthly fees for simple alerts.

My goal with this article is to help you stop paying those expensive fees by showing you a powerful, free, open-source alternative called Uptime Kuma.

In this guide, you'll learn how to use Docker to deploy Uptime Kuma safely on a local Ubuntu machine.

By the end of this tutorial, you'll have set up your own private server monitoring dashboard in less than 10 minutes and created an automated Discord alert to ping your phone if your website goes offline.

Table of Contents

• Prerequisites

• Step 1: Update Packages and Prepare the Firewall

• Step 2: Create the Docker Compose File

• Step 3: Start the Application

• Step 4: Access the Dashboard

• Step 5: Use Case – Monitor a Website and Send Discord Alerts

• Conclusion

Prerequisites

Before you start, make sure you have:

• An Ubuntu machine (like a local server, VM, or desktop).

• Docker and Docker Compose installed.

• Basic knowledge of the Linux terminal.

Step 1: Update Packages and Prepare the Firewall

First, you'll want to make sure your system has the newest updates. Then, you'll install the Uncomplicated Firewall (UFW) and open the network "door" (port) that Uptime Kuma uses for the dashboard. You'll also need to allow SSH so you don't lock yourself out.

Run these commands in your terminal:

1. Update your packages:

sudo apt update && sudo apt upgrade -y

1. Install the firewall:

sudo apt install ufw -y

1. Allow SSH and open port 3001:

sudo ufw allow ssh
sudo ufw allow 3001/tcp

1. Enable the firewall:

sudo ufw enable
sudo ufw reload

Step 2: Create the Docker Compose File

Using a docker-compose.yml file is the professional way to manage Docker containers. It keeps your setup organised in one single place.

To start, create a new folder for your project and enter it:

mkdir uptime-kuma && cd uptime-kuma

Then create the configuration file:

nano docker-compose.yml

Paste the following code into the editor:

services:
  uptime-kuma:
    image: louislam/uptime-kuma:2
    restart: unless-stopped
    volumes:
      - ./data:/app/data
    ports:
      - "3001:3001"

Note: The ./data:/app/data line is very important. It saves your database in a normal folder on your machine, making it easy to back up later.

Finally, save and exit: Press CTRL + X, then Y, then Enter.

Step 3: Start the Application

Now, tell Docker to read your file and start the monitoring service in the background.

docker compose up -d

How to verify: Docker will download the files. When it finishes, your terminal should print Started uptime-kuma.

Step 4: Access the Dashboard

To access the dashboard, first open your web browser and go to http://localhost:3001 (or your machine's local IP address).

When asked to choose the database, select SQLite. It's simple, fast, and requires no extra setup.

Then create an account and choose a secure admin username and password.

Step 5: Use Case – Monitor a Website and Send Discord Alerts

Now you'll put Uptime Kuma to work by monitoring a live website and setting up an alert. Just follow these steps:

1. Click Add New Monitor.

2. Set the Monitor Type to HTTP(s).

3. Give it a Friendly Name (e.g., "My Blog") and enter your website's URL.

Pro-Tip: How to Fix "Down" Errors (Bot Protection)

If your site uses strict security, it might block Uptime Kuma and say your site is "Down" with a 403 Forbidden error.

The Fix: Scroll down to Advanced, find the User Agent box, and paste this text to make Uptime Kuma look like a normal Chrome browser:

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Add a Discord Alert

To get a message on your phone when your site goes down:

1. On the right side of the monitor screen, click Setup Notification.

2. Select Discord from the dropdown list.

3. Paste a Discord Webhook URL (you can create one in your Discord server settings under Integrations).

4. Click Test to receive a test ping, then click Save.

Conclusion

Congratulations! You just took control of your server health. By deploying Uptime Kuma, you replaced an expensive SaaS subscription with a powerful, free monitoring tool that alerts you the second a project goes offline.

Let’s connect! I am a developer and technical writer specialising in writing step-by-step guides and workflows. You can find my latest projects on my Technical Writing Portfolio or reach out to me directly on LinkedIn.

We’ll start with basic message transmission. Then you'll progress to creating a file transfer system, and you’ll ultimately develop a secure chat application with encryption.

Here’s what we’ll cover:

• Prerequisites

• Install Netcat

• Your First Network Connection

• How to Build a Simple File Transfer Tool

• How to Create a Secure Chat System

• Conclusion

• Practice Your Skills

Prerequisites

Before we start, you'll need:

• A Linux-based system: I recommend Ubuntu. Alternatively, you can use the Online Linux Terminal if you don't have Linux installed.

• Basic terminal knowledge (how to use cd and ls)

Don't worry if you're new to networking - I’ll explain everything as we go!

Install Netcat

Netcat is like a digital "pipe" between computers – anything you put in one end comes out the other. Before we start using it, let's get it installed on your system.

Open your terminal and run these commands:

# Update your system's package list
sudo apt update

# Install Netcat
sudo apt install netcat -y

To check if the installation worked, run:

nc -h

You should see a message starting with "OpenBSD netcat". If you do, great! If not, try running the installation commands again.

Your First Network Connection

Before we dive into building tools, let's understand what a network connection actually is. Think of it like a phone call: one person needs to wait for the call (the listener), and another person needs to make the call (the connector).

In networking, we use "ports" to make these connections. You can think of ports like different phone lines – they let multiple conversations happen at the same time.

Let's try making our first connection:

1. Open a terminal window and create a listener:

nc -l 12345

What did we just do? The -l tells Netcat to "listen" for a connection, and 12345 is the port number we chose. Your terminal will look like it's frozen – that's normal! It's waiting for someone to connect.

2. Open another terminal window and connect to your listener:

nc localhost 12345

Here, localhost means "this computer" – we're connecting to ourselves for practice. If you want to connect to another computer, you can replace localhost with its IP address.

Now try typing a message (like "hi") in either window and press Enter. Cool, right? The message appears in the other window! This is exactly how basic network communication works.

To stop the connection, press Ctrl+C in both windows.

What Just Happened?

You just created your first network connection! The first terminal was like someone waiting by a phone, and the second terminal was like someone calling that phone. When they connected, they could send messages back and forth.

How to Build a Simple File Transfer Tool

Now that we understand basic connections, let's build something more useful: a tool to transfer files between computers.

First, let's create a test file to send:

# Create a file with some content
echo "This is my secret message" > secret.txt

To transfer this file, we'll need two terminals again, but this time we'll use them differently:

1. In the first terminal, set up the receiver:

nc -l 12345 > received_file.txt

This tells Netcat to:

• Listen for a connection (-l)

• Save whatever it receives to a file called received_file.txt (>)

2. In the second terminal, send the file:

nc localhost 12345 < secret.txt

The < tells Netcat to send the contents of our file.

3. Press Ctrl+C in both terminals to stop the transfer. Then check if it worked:

cat received_file.txt

You should see your message!

This is similar to our chat system, but instead of typing messages, we're:

1. Taking content from a file

2. Sending it through our network connection

3. Saving it to a new file on the other end

Think of it like sending a document through a fax machine!

How to Create a Secure Chat System

Our previous examples sent everything as plain text – anyone could read it if they intercepted the connection. Let's make something more secure by adding encryption.

First, let's understand what encryption does:

• It's like putting your message in a locked box

• Only someone with the right key can open it

• Even if someone sees the box, they can't read your message

We'll create two scripts: one for sending messages and one for receiving them.

1. Create the sender script:

nano secure_sender.sh

Copy this code into the file:

#!/bin/bash

echo "Secure Chat - Type your messages below"
echo "Press Ctrl+C to exit"

while true; do
  # Get the message
  read message

  # Encrypt and send it
  echo "$message" | openssl enc -aes-256-cbc -salt -base64 \
    -pbkdf2 -pass pass:chatpassword 2>/dev/null | \
    nc -N localhost 12345
done

This script will:

1. Read messages from user input.

2. Encrypt them using OpenSSL's AES-256-CBC encryption (a strong encryption standard).

3. Send the encrypted message to the specified port.

Press Ctrl+X, then Y, then Enter to save.

2. Create the receiver script:

nano secure_receiver.sh

Copy this code:

#!/bin/bash

echo "Waiting for messages..."

while true; do
  # Receive and decrypt messages
  nc -l 12345 | openssl enc -aes-256-cbc -d -salt -base64 \
    -pbkdf2 -pass pass:chatpassword 2>/dev/null
done

This script will:

1. Listen for incoming encrypted messages.

2. Decrypt them using the same encryption key.

3. Display the decrypted messages.

Save this file too.

3. Make both scripts executable:

chmod +x secure_sender.sh secure_receiver.sh

4. Try it out:

• In one terminal: ./secure_receiver.sh

• In another terminal: ./secure_sender.sh

Type a message in the sender terminal. The receiver will show your decrypted message!

Enhancing Our Chat System

Now that we have a working basic chat system, let's make it more user-friendly and informative. We'll add features like timestamps, color-coded messages, and encryption status updates. This enhanced version will help you better understand what's happening during the encryption and transmission process.

If you're comfortable with the basic version, try this improved version:

1. Create an enhanced sender script (save it as secure_sender_v2.sh):

#!/bin/bash

# Set up color codes for better visibility
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

echo -e "${GREEN}Secure Chat Sender - Started at $(date)${NC}"
echo -e "${BLUE}Type your messages below. Press Ctrl+C to exit${NC}"
echo "----------------------------------------"

while true; do
    # Show prompt with timestamp
    echo -ne "${GREEN}[$(date +%H:%M:%S)]${NC} Your message: "

    # Get the message
    read message

    # Skip if message is empty
    if [ -z "$message" ]; then
        continue
    fi

    # Add timestamp to message
    timestamped_message="[$(date +%H:%M:%S)] $message"

    # Show encryption status
    echo -e "${BLUE}Encrypting and sending message...${NC}"

    # Encrypt and send it, showing the encrypted form
    encrypted=$(echo "$timestamped_message" | openssl enc -aes-256-cbc -salt -base64 \
        -pbkdf2 -iter 10000 -pass pass:chatpassword 2>/dev/null)

    echo -e "${BLUE}Encrypted form:${NC} ${encrypted:0:50}..." # Show first 50 chars
    echo "$encrypted" | nc -N localhost 12345

    echo -e "${GREEN}Message sent successfully!${NC}"
    echo "----------------------------------------"
done

2. Create an enhanced receiver script (save as secure_receiver_v2.sh):

#!/bin/bash

# Set up color codes for better visibility
GREEN='\033[0;32m'
BLUE='\033[0;34m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo -e "${GREEN}Secure Chat Receiver - Started at $(date)${NC}"
echo -e "${BLUE}Waiting for messages... Press Ctrl+C to exit${NC}"
echo "----------------------------------------"

while true; do
    # Receive and show the encrypted message
    echo -e "${BLUE}Waiting for next message...${NC}"

    encrypted=$(nc -l 12345)

    # Skip if received nothing
    if [ -z "$encrypted" ]; then
        continue
    fi

    echo -e "${YELLOW}Received encrypted message:${NC} ${encrypted:0:50}..." # Show first 50 chars
    echo -e "${BLUE}Decrypting...${NC}"

    # Decrypt and display the message
    decrypted=$(echo "$encrypted" | openssl enc -aes-256-cbc -d -salt -base64 \
        -pbkdf2 -iter 10000 -pass pass:chatpassword 2>/dev/null)

    # Check if decryption was successful
    if [ $? -eq 0 ]; then
        echo -e "${GREEN}Decrypted message:${NC} $decrypted"
    else
        echo -e "\033[0;31mError: Failed to decrypt message${NC}"
    fi

    echo "----------------------------------------"
done

3. Make the enhanced scripts executable:

chmod +x secure_sender_v2.sh secure_receiver_v2.sh

Try running both versions to see how the additional feedback helps you better understand the encryption and communication process.

The enhanced version (v2) adds several improvements:

• Colorized output for better readability.

• Timestamps for each message.

• Status updates showing the encryption/decryption process.

• Error handling for failed decryption attempts.

• Preview of encrypted messages before sending/after receiving.

Conclusion

This tutorial taught you how to use Netcat as a versatile networking tool. We started with basic message sending, progressed to building a simple file transfer system, and then created a secure chat system with encryption.

You've gained hands-on experience with:

• Setting up network listeners and connections

• Transferring files securely between systems

• Implementing basic encryption for secure communication

• Adding user-friendly features like timestamps and status updates

The skills you've learned here form a solid foundation for understanding network communication and can be applied to more complex networking projects. To practice the operations from this tutorial, try the interactive hands-on lab.

Practice Your Skills

Now that you've learned the basics of Netcat and built a secure chat system, let's put your skills to the test with a real-world scenario. Try the "Receive Messages Using Netcat" lab challenge where you'll play the role of a junior interstellar communications analyst. Your mission: intercept and log signals from an alien civilization using your newfound Netcat knowledge.

CUDA is also a programming model and an API that enables programmers to write code that can run on both the CPU and GPU while also handling data transfer between them.

By using the CUDA Toolkit, you can improve performance, scalability, and efficiency across a range of applications. These include computing, deep learning, computer vision, gaming, and more.

The toolkit supports programming languages like C, C++, Fortran, Python, and Java. It seamlessly integrates with frameworks and libraries such as TensorFlow, PyTorch OpenCV, and cuDNN.

Also, the use of the CUDA Toolkit extends across different domains, such as healthcare finance, robotics, the automotive industry, and entertainment. If you're looking to speed up image processing or natural language processing, enhance cryptography, or advance ray tracing techniques, the CUDA Toolkit empowers you to solve problems faster and more efficiently.

In terms of compatibility, the CUDA Toolkit offers support for Linux distributions, including Ubuntu, Debian, Fedora, CentOS, and OpenSUSE.

In this article, I will guide you through the process of installing the CUDA Toolkit on Ubuntu 22.04, which happens to be the LTS (Long Term Support) version of Ubuntu.

Prerequisites

To install the CUDA Toolkit on Ubuntu 22.04, you need the following:

• A supported NVIDIA GPU with a minimum compute capability of 3.0

• NVIDIA driver compatible with the CUDA Toolkit version

In this guide I will be using a Paperspace GPU instance with Ubuntu 22.04 LTS operating system.

Please note that you can use any other Cloud Service provider, like Google Cloud and Vultr, or even your own computer, as long as it meets the requirements listed above.

To get started, you'll need to create a new user, like seconduser and then switch to the new user.

Install CUDA Toolkit

You can install CUDA using the release file or alternatively, by using Conda. In this guide, we will be installing CUDA with the release file from the official Toolkit Archive.

Step 1: Download the CUDA release file.

 $ wget https://developer.download.nvidia.com/compute/cuda/12.0.1/local_installers/cuda_12.0.1_525.85.12_linux.run

Step 2: Execute the release file.

 $ sudo sh cuda_12.0.1_525.85.12_linux.run

You will be prompted to accept the End User License Agreement, then press Enter to configure your installation.

Once the installation is complete, you should see an output similar to this:

Configuration and Verification

Step 1: Configure the server

Configure the server to work with the CUDA toolkit. Move the CUDA path to the system’s PATH, then add the CUDA Toolkit library path to the LD_LIBRARY_PATH so that the CUDA toolkit link loader will be updated with the location of shared libraries.

  $ echo "export PATH=/usr/local/cuda-12.0/bin${PATH:+:${PATH}}" >> /home/seconduser/.bashrc

  $ echo "export LD_LIBRARY_PATH=/usr/local/cuda-12.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}" >> /home/seconduser/.bashrc

Step 2: Activate Environment

After configuring the server to work with the CUDA toolkit, activate the environment variable changes so that the system can find and use CUDA.

$ source /home/seconduser/.bashrc

Step 3: Verify Installation

 $ nvidia-smi

Output:

Step 4: Check Package Installation.

Verify that the package from the CUDA Toolkit is successfully installed on your server.

 $ nvcc --version

Output:

Testing

To test your newly installed CUDA programs, you will use some already-made test scripts by CUDA that will allow you to comprehensively verify the compatibility and functionality of your CUDA-enabled environment.

Step 1: Clone the test scripts repository

 $ git clone https://github.com/NVIDIA/cuda-samples.git

Step 2: Go to the directory containing the deviceQuery sample script.

 $ cd cuda-samples/Samples/1_Utilities/deviceQuery

Step 3: Compile the script.

 $ make

Step 4: Run the script.

 $ ./deviceQuery

Your output should look similar to the one below if your CUDA program ran the script successfully:

Conclusion

In this article, you learned how to install the CUDA Toolkit on Ubuntu 22.04.

Some of the best practices for using CUDA on Ubuntu are:

• Keep your system and NVIDIA drivers up to date to ensure the compatibility and stability of the CUDA Toolkit.

• Use the CUDA APT PPA to install and update the CUDA Toolkit easily and quickly.

• Use the nvcc compiler options and flags to optimize and debug your CUDA code.

• Use the CUDA libraries and tools to enhance and simplify your CUDA development process.

• Follow the CUDA coding standards and best practices to write efficient and maintainable CUDA code.

Here are some resources to learn more about CUDA:

• CUDA Official Docs

• CUDA Refresher Tutorial

• Read The Docs: Say Hello to CUDA

But if you use the typical sudo apt install nodejs command, it may install a very old version of Node which can be troublesome for you.

So you'll want to install a specific version, which requires a different command. This will install the LTS (Long-Term Support) version of Node which is useful for devs because it has a longer period for support.

Today, I am going to show you how you can install the latest LTS version of Node on your Ubuntu operating system.

This processes will work on any kind of Debian-based Linux operating system (Ubuntu, Mint, Zorin, Debian, Elementary OS, and so on). It'll work whether you are using that as your main operating system, secondary operating system on dual boot, WSL on Windows, or using in a virtual machine (VMware Workstation, VirtualBox, and so on).

Video Tutorial

I have also created a complete video to show you the process step-by-step. You can watch it here:

At the time of writing this article, the latest LTS version for Node is 18.18.2.

Node download page showing current LTS version

When you install Node following the instructions in this article, it will install the latest LTS version of Nodejs automatically. So you'll be safe without any hassle if you simply follow this article and the accompanying video.

Update Your Operating System

First, you'll want to ensure that you have installed all the updates beforehand. I like to work in the terminal mostly, so I'll install the updates using the terminal directly.

For updating to the latest versions of all the relevant packages, use sudo apt update in the terminal. Use your password when it asks for that.

Updating all relevant packages

Now use sudo apt upgrade -y to upgrade all the upgradable packages.

Upgrading all relevant packages

Install CURL

We're using the Node Version Manager (NVM) here to install Node. There are various advantages when we install Node and npm using the NVM as it also allows us to manage multiple versions of Node.js on our system altogether.

First, you'll need to install curl if it's not installed on your system already. You can install curl by using the command below:

sudo apt install curl -y

Installing CURL

How to Install Node.js

Now you'll need to follow these steps in order to ensure that you've installed Node.js successfully on your system.

Install Node Version Manager (NVM)

Install the Node Version Manager (NVM) by using the following command:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

Installing the Node Version Manager (NVM)

When you run this specific command, the curl downloads the NVM installation script from that specific URL. Afterward, bash executes the same script for installing NVM.

Activate NVM

Activate the NVM using the command below:

source ~/.bashrc

Activating the Node Version Manager (NVM)

Install the latest LTS version of Node

Install the latest Long Term Support version of Node by using the command below:

nvm install --lts

Command for installing the latest LTS version of Node.js

It installs the latest version of the LTS release of Node by default.

Make the default LTS version as NVM

We have installed the latest LTS version of Node, but we also need to set the default version of NVM so that it gets used by default whenever we need it. You can use the command below to do that. Make sure to change the version to the exact LTS version you have installed on your system just now.

nvm alias default 18.18.2

Selecting the appropriate Node version as the default version

If your LTS version is something like 24.1.2 then the command would be like below:

nvm alias default 24.1.2

Confirm that Node was installed

Use the command below to check whether the default version is the exact version you just installed:

node -v npm -v

Showing the current version of Node installed

How to Set Up the Node.js Environment

After installing Node and NPM, you need to set up the Node environment by creating a new Node project.

Use the command below to create a new directory/folder where you want to test a simple "Hello World" type Node project.

mkdir my-node-project

Creating a new directory/folder to test a simple "Hello World" program on Node

Navigate to the my-node-project directory by using the command below:

cd my-node-project

Changing the directory to enter into that newly created directory/folder

Initialize the new Node project like this:

npm init -y

This command will create a "package.json" file containing your project's metadata and dependencies. Here is the JSON output:

Initializing npm in the folder

The JSON output is below:

{
  "name": "my-node-project",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Now run the setup with the simple command. For this, I am going to create a new file called app.js using the nano text editor in the terminal.

sudo nano app.js

Opening app.js file in nano

Once the text editor opens, type the below code:

console.log("Hello, Node.js from Ubuntu!");

Writing a simple console.log code in the app.js file using nano

Use Ctrl+ O to save the file. Use Enter to save the file as app.js:

Save the app.js file with the newly added line of code

Use Ctrl + X to return to the bash terminal again.

Returning to the terminal again

Now, it is time to check the output and see whether it's working or not.

Use the command below:

node app.js

Running the app.js file using Node

It is working!

We have successfully installed the latest LTS release of Node on our Ubuntu/Debian-based Linux operating system.

Cheers! 🥂

Conclusion

Thank you so much for reading the entire article till now.

If you have enjoyed the procedures step-by-step, then don't forget to let me know on Twitter/X or LinkedIn.

You can follow me on GitHub as well if you are interested in open source. Make sure to check my website (https://fahimbinamin.com/) as well!

If you like to watch programming and technology-related videos, then you can check my YouTube channel, too.

All the best for your programming and development journey. 😊

You can do it! Don't give up, never! ❤️

An example of this can be seen when you want to install the latest version of Java on Ubuntu and make it your default Java version. Yes, I know that you're wondering about other Linux distributions like Fedora or Arch, and so on, but each distribution has some specific advantages and disadvantages over others.

Ubuntu is one of the most commonly used Linux distributions, and most people who would like to try out the Linux operating system for the first time usually start their Linux journey with Ubuntu.

However, if you're a Java developer who is migrating from a Windows machine to an Ubuntu based Linux machine, you might find it tedious to configure the latest version of Java on Ubuntu as opposed to Windows where you simply have to download and install the latest version, and add the directory to the path variable.

In this article, I will cover everything you need to know and do to configure your Ubuntu operating system for Java development. I will explain each of the processes with appropriate screenshots and test runs.

I have also created a full-length video showing all of the procedures. You can find the video at the end of this article. By the way, if you're wondering, "Hey Fahim! Who told you that installing Java on Windows is easier?", then you should probably check out my article on how to install Java on Windows.

How to Check Java Version on Ubuntu

Before proceeding further, you might want to check whether you already have Java installed on your Ubuntu.

You can do this using the terminal. If it returns any version, then that means a version of Java is already installed on your machine. But if it returns something different, then we can assume that you do not have Java installed or it is not configured correctly.

Simply open your terminal. You can also use the shortcut keys for opening the terminal on Ubuntu: Ctrl + Alt + T

Open the terminal

Then run the command: java --version

java --version

If it says "java not found" (like you see in the image above), then you can be sure that your system does not have Java installed.

But if it returns any version of Java or JDK (Java Development Kit), then Java is already installed on your machine. Based on the installed version and your need for the other versions, you can remove the older one and install the newer version or you can keep both of them and make one version the default version.

How to Install Java On Ubuntu

There are many ways to install Java on Ubuntu. You can use the CLI (Command Line Interface) where you will install via the terminal, or you can download the package and install it using GUI (Graphical User Interface).

In this article, I am going to show you how you can download the latest Java from Oracle and install it on your Ubuntu machine. But that, you have to choose between installing the JRE (Java Runtime Environment) or the JDK (Java Development Kit) version for Java.

If you don't understand the differences between them or which one you need for your tasks, then here is a comparison for you:

JDK vs JRE in Java

Here are some differences between JDK and JRE in Java:

If you are a developer, then you should install the JDK instead of the JRE. On the other hand, if you are just a normal user who will not program or write code at all, you can install the JRE.

In this article, we'll be installing the JDK version because that covers everything. If you already have a JDK then you do not need to install JRE separately.

How to Update Ubuntu

Before we install Java, we need to ensure that we've installed all the necessary updates for the Ubuntu operating system.

To update the your Ubuntu OS, simply use the sudo apt update command . Then provide your password and hit the enter key.

Update the system

After updating, if you get a message that says something needs to be upgraded then you can upgrade them using sudo apt upgrade.

23 packages can be upgraded on my system right now. In your case, it might be different.

Make sure to press "y" or "Y" while upgrading.

Upgrading the system

The upgrade might take some time depending on the file sizes that it needs to download and your internet speed.

Make sure that everything has been upgraded without creating any errors.

How to Download Oracle JDK

You can download the official JDK from Oracle website.

Once the landing page loads, click on Products on the top navigation bar:

Oracle website navigation options

Then click Java under the Hardware and Software section.

Click Download Java.

Here, you will get all the latest JDK files. For development purposes, it is recommended to use the LTS (Long Term Support) versions as they receive stable version updates for an extended period.

I am going to install the JDK 20 version (which is the latest version as of the time of writing this article). It is not the LTS version of course, but if you follow through with this article, then you'll be able to install any version you want swiftly!

In your case, I would recommend installing the latest LTS version of JDK. But if you want continuous access to latest JDK features (these features might not be stable), then you can download the latest JDK.

To download, select Linux in the operating system section and download the file for x64 Debian Package. Clicking on the download link will start the download for the Debian package file.

Depending on your internet speed, it can take a shorter or longer amount of time. As I am writing this article at night and my internet speed remains slow at night, it is taking longer to download the package file in my system.

How to Install the JDK

I have downloaded the package file using the Mozilla Firefox browser and by default, it downloads files in the Downloads directory.

Simply go to the directory where you downloaded the file and open the terminal there.

Usually, if you go into any directory and right-click, you will see a context menu that says Open in Terminal. By using that, you can open your terminal in that directory.

Alternatively, if you open the terminal elsewhere, you can use the cd command to go into any specific directory.

For example, I have opened my terminal elsewhere. I am using the cd command to go into my Downloads directory as can be seen in the image below:

You can use the ls command to see all the files and folders available on a particular directory:

After downloading the file, you will see that the file name also contains the version name which is necessary, but if you think that would be troublesome to type later on, you can shorten the filename as well.

For this article, we'll use the default filename.

Grab the full directory path where the JDK package file is downloaded. You can use the shortcut Ctrl + L to display the whole directory path.

For me, the current directory path where my JDK Debian file is located is /home/fahim/Downloads/. Make sure to copy the address.

Next, open the terminal. You can do that using the shortcut Ctrl + Alt + T.

I like to install the JDK using the terminal, but if you can also install it using the GUI (Graphical User Interface). But I recommend using the terminal as that would also help you debug any issues you face during installation.

Use the sudo apt install /home/fahim/Downloads/jdk_filename.deb command to start the installation. For me, the entire command is sudo apt install /home/fahim/Downloads/jdk-20_linux-x64_bin.deb.

Hit the enter key:

Input your password and type "y" when it asks for your permission to install the package.

Make sure that you have successfully installed the package before proceeding to the next step.

You might get N: Download is performed unsandboxed as root as file '/home/fahim/Downloads/jdk-20_linux-x64_bin.deb' couldn't be accessed by user '_apt'. - pkgAcquire::Run (13: Permission denied). But don't worry about that because we performed the installation "unsandboxed" intentionally.

You will not face any problems if you use the Debian package downloaded from the right source.

You can clear the terminal using the command clear.

How to Configure Java in Ubuntu

We need to make sure that if it updates, it does not download any downgraded version of Java.

You can do that using the sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk-version/bin/java 1 command.

Since I'm using the "JDK - 20" version, my command would be sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk-20/bin/java 1.

Make sure to change the jdk-version to match your installed JDK version.

We need to do the same thing for the javac (Java Compiler) version as well. The command would be sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk-version/bin/javac 1.

My command would look like this: sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk-20/bin/javac 1.

Remember to change the jdk-version to match your installed JDK version.

We'll also do the same for jar. JAR is essential for running Java based applications directly in the system.

The command would be sudo update-alternatives --install /usr/bin/jar jar /usr/lib/jvm/jdk-version/bin/jar 1.

My command would look like this: sudo update-alternatives --install /usr/bin/jar jar /usr/lib/jvm/jdk-20/bin/jar 1.

Then change the jdk-version to match your installed JDK version.

This is all for most of the cases. You are good to go!

But if you face any kind of problems, then check the complete video provided below. In that video, I talked about a lot of possible issues and how to solve them. If you have multiple Java versions installed on your system, then you need to make one of them the default. This is also covered in the video.

Also, if you want to make more modifications, then the video is going to help you with that as well. But for most of the users, this article is everything that you need to install Java on your Ubuntu operating system.

Video Walkthrough

Check the complete video for troubleshooting any more issues or if you want to make more modifications.

Conclusion

I hope you have enjoyed this article and are able to install Java on your Ubuntu operating system.

If you have any questions then please let me know by reaching out on Twitter or LinkedIn.

You can also follow me on:
🎁GitHub: FahimFBA
🎁YouTube: @FahimAmin

If you are interested then you can also check my website: https://fahimbinamin.com/

That's what we will learn in this article. We will explore two ways to set a static IP in Ubuntu.

Static IP addresses find their use in the following situations:

• Configuring port forwarding.
• Configuring your system as a server such as an FTP server, web server, or a media server.

Pre-requisites:

To follow this tutorial you will need the following:

• Ubuntu installation, preferably with a GUI.
• sudo rights as we will be modifying system configuration files.

How to Set a Static IP Using the Command Line

In this section, we will explore all the steps in detail needed to configure a static IP.

Step 1: Launch the terminal

You can launch the terminal using the shortcut Ctrl+ Shift+t.

Step 2: Note information about the current network

We will need our current network details such as the current assigned IP, subnet mask, and the network adapter name so that we can apply the necessary changes in the configurations.

Use the command below to find details of the available adapters and the respective IP information.

ip a

The output will look something like this:

For my network, the current adapter is eth0. It could be different for your system

• Note the current network adapter name

As my current adapter is eth0, the below details are relevant.

6: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:15:5d:df:c3:ad brd ff:ff:ff:ff:ff:ff
    inet 172.23.199.129/20 brd 172.23.207.255 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::215:5dff:fedf:c3ad/64 scope link
       valid_lft forever preferred_lft forever

It is worth noting that the current IP 172.23.199.129 is dynamically assigned. It has 20 bits reserved for the netmask. The broadcast address is 172.23.207.255.

• Note the subnet

We can find the subnet mask details using the command below:

ifconfig -a

Select the output against your adapter and read it carefully.

IP is 172.23.199.129 and subnet mask is 255.255.240.0

Based on the class and subnet mask, the usable host IP range for my network is: 172.23.192.1 - 172.23.207.254.

Subnetting is a vast topic. For more info on subnetting and your usable IP ranges, check out this article.

Step 3: Make configuration changes

Netplan is the default network management tool for the latest Ubuntu versions. Configuration files for Netplan are written using YAML and end with the extension .yaml.

Note: Be careful about spaces in the configuration file as they are part of the syntax. Without proper indentation, the file won't be read properly.

• Go to the netplan directory located at /etc/netplan.

ls into the /etc/netplan directory.

If you do not see any files, you can create one. The name could be anything, but by convention, it should start with a number like 01- and end with .yaml. The number sets the priority if you have more than one configuration file.

I'll create a file named 01-network-manager-all.yaml.

Let's add these lines to the file. We'll build the file step by step.

network:
 version: 2

The top-level node in a Netplan configuration file is a network: mapping that contains version: 2 (means that it is using network definition version 2).

Next, we'll add a renderer, that controls the overall network. The renderer is systemd-networkd by default, but we'll set it to NetworkManager.

Now, our file looks like this:

network:
 version: 2
 renderer: NetworkManager

Next, we'll add ethernets and refer to the network adapter name we looked for earlier in step#2. Other device types supported are modems:, wifis:, or bridges:.

network:
 version: 2
 renderer: NetworkManager
 ethernets:
   eth0:

As we are setting a static IP and we do not want to dynamically assign an IP to this network adapter, we'll set dhcp4 to no.

network:
 version: 2
 renderer: NetworkManager
 ethernets:
   eth0:
     dhcp4: no

Now we'll specify the specific static IP we noted in step #2 depending on our subnet and the usable IP range. It was 172.23.207.254.

Next, we'll specify the gateway, which is the router or network device that assigns the IP addresses. Mine is on 192.168.1.1.

network:
 version: 2
 renderer: NetworkManager
 ethernets:
   eth0:
     dhcp4: no
     addresses: [172.23.207.254/20]
     gateway4: 192.168.1.1

Next, we'll define nameservers. This is where you define a DNS server or a second DNS server. Here the first value is 8.8.8.8 which is Google's primary DNS server and the second value is 8.8.8.4 which is Google's secondary DNS server. These values can vary depending on your requirements.

network:
 version: 2
 renderer: NetworkManager
 ethernets:
   eth0:
     dhcp4: no
     addresses: [172.23.207.254/20]
     gateway4: 192.168.1.1
     nameservers:
         addresses: [8.8.8.8,8.8.8.4]

Step 4: Apply and test the changes

We can test the changes first before permanently applying them using this command:

sudo netplan try

If there are no errors, it will ask if you want to apply these settings.

Now, finally, test the changes with the command ip a and you'll see that the static IP has been applied.

Static IP applied

How to Set a Static IP Using the GUI

It is very easy to set a static IP through the Ubuntu GUI/ Desktop. Here are the steps:

• Search for settings.
• Click on either Network or Wi-Fi tab, depending on the interface you would like to modify.
• To open the interface settings, click on the gear icon next to the interface name.
• Select “Manual” in the IPV4 tab and enter your static IP address, Netmask and Gateway.
• Click on the Apply button.

Manually setting a static IP using Ubuntu Desktop.

• Verify by using the command ip a

Static IP updated via GUI

Conclusion

In this article, we covered two methods to set the static IP in Ubuntu. I hope you found the article useful.

What’s your favorite thing you learned from this tutorial? Let me know on Twitter!

You can read my other posts here.

Java is one of the most popular programming languages in use today. And a clean setup lets you seamlessly install Java and switch between different versions when you're building applications.

In this tutorial you will learn how to:

• Install any Java version,
• Switch between Java versions,
• Update to the newest Java version.

The provided guide should work for most operating systems. I tested it for the following Linux versions:

• Ubuntu
• Debian
• MacOS

Java Development Kit

The Java Development Kit (JDK) is a development environment for building applications, applets, and components using the Java programming language. (Source)

The JDK contains different applications, including

javac, the Java compiler, which converts source code into Java bytecode.

java, the loader for Java applications. This tool is an interpreter and can interpret the class files generated by the javac compiler.

Now a single launcher is used for both development and deployment. The old deployment launcher, jre, no longer comes with Sun JDK, and instead it has been replaced by this new java loader. (Source)

Java Build tools (Maven, Gradle, and so on) and your code editors use Java applications behind the scenes to give developers a nice experience running, creating, and maintaining applications.

Let’s see how to install Java in a Linux environment using the terminal. This enables you to use the steps in your own Linux environment and in many remote environments.

How to Use SDKMan to Manage Java Versions

SDKMAN! is a tool for managing parallel versions of multiple Software Development Kits on most Unix based systems. It provides a convenient Command Line Interface (CLI) and API for installing, switching, removing and listing Candidates. (Source)

SDKMan comes with its own installer, which supports many operation systems. Make sure you install curl before, and execute the installer script after.

How to Install SDKMan on Ubuntu 22

# install curl
$ sudo apt install curl

# install sdkman
$ curl -s "https://get.sdkman.io" | bash

How to Install SDKMan on Debian 11

# login as root
$ su

# install curl
$ apt install curl zip

# exit root user session
$ exit

# install sdkman
$ curl -s "https://get.sdkman.io" | bash

How to Install SDKMan on MacOS

In case you don’t have brew and curl yet on Mac, you need to install them to easily install and update sdkman.

# install brew package manager)
$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# install curl
$ brew install curl

# install sdkman
$ curl -s "https://get.sdkman.io" | bash

Now, close and reopen your terminal to use sdkman.

# print sdkman version to verify installation
$ sdk versionSDKMAN 5.15.0

# install latest java
$ sdk install java

# check your java installation and print your java’s version
$ java –version

Openjdk version "17.0.3" 2022-04-19OpenJDK Runtime Environment Temurin-17.0.3+7 (build 17.0.3+7)OpenJDK 64-Bit Server VM Temurin-17.0.3+7 (build 17.0.3+7, mixed mode, sharing)

# Show path to current java version$ which java/home/sesigl/.sdkman/candidates/java/current/bin/java

Now, you are ready to use Java.

How to Install Multiple Java Versions

It is very useful to install multiple Java versions. Maybe certain applications require an older version of Java. Or you want to play with a brand new Java version and easily switch back.

Next, you additionally install Java 18:

$ sdk install java 18.0.1-tem
Done installing!

Do you want java 18.0.1-tem to be set as default? (Y/n): n

By typing n, it means that you do not want to use Java 18 as your default version. You can manually enable versions temporarily in your shell by executing sdk use java <version>.

$ sdk use java 18.0.1-tem
Using java version 18.0.1-tem in this shell.

$ java -version
openjdk version "18.0.1" 2022-04-19OpenJDK Runtime Environment Temurin-18.0.1+10 (build 18.0.1+10)OpenJDK 64-Bit Server VM Temurin-18.0.1+10 (build 18.0.1+10, mixed mode, sharing)

If you close the window or type Java sdk use java 17.0.3-tem you can switch back.

$ sdk use java 17.0.3-tem
Using java version 17.0.3-tem in this shell.

$ java -version
openjdk version "17.0.3" 2022-04-19OpenJDK Runtime Environment Temurin-17.0.3+7 (build 17.0.3+7)OpenJDK 64-Bit Server VM Temurin-17.0.3+7 (build 17.0.3+7, mixed mode, sharing)

How to Automatically Switch the Java Version

Let’s say that you have 2 projects, one with Java 17 and one with Java 18. By creating a .sdkmanrc file in a directory, you can automatically switch versions, which will boost your productivity.

Let’s create a file for a Java 17 project:

$ sdk env init
.sdkmanrc created.

$ tail .sdkmanrc
# Enable auto-env through the sdkman_auto_env config
# Add key=value pairs of SDKs to use below
java=17.0.3-tem

Next, create another directory, switch the Java version to Java 18, and create another .sdkmanrc by executing sdk env init.

$ cd ..

$ mkdir my-java-18-project

$ cd my-java-18-project/

$ sdk use java 18.0.1-tem
Using java version 18.0.1-tem in this shell.

$ sdk env init
.sdkmanrc created.

$ tail .sdkmanrc
# Enable auto-env through the sdkman_auto_env config
# Add key=value pairs of SDKs to use below
java=18.0.1-tem

To automatically switch Java versions, you need to edit the file $HOME/.sdkman/etc/config and set sdkman_auto_env=true. There is already a line, so you only need to change false to true.

To enable the configuration change, restart your terminal. Once done, sdkman prints when it changes the Java version automatically for you.

Let’s verify the Java version as well.

$ cd my-java-17-project/
Using java version 17.0.3-tem in this shell.

$ java -version
openjdk version "17.0.3" 2022-04-19
OpenJDK Runtime Environment Temurin-17.0.3+7 (build 17.0.3+7)
OpenJDK 64-Bit Server VM Temurin-17.0.3+7 (build 17.0.3+7, mixed mode, sharing)

$ cd ..
Restored java version to 17.0.3-tem (default)

$ cd my-java-18-project/
Using java version 18.0.1-tem in this shell.

$ java -version
openjdk version "18.0.1" 2022-04-19
OpenJDK Runtime Environment Temurin-18.0.1+10 (build 18.0.1+10)
OpenJDK 64-Bit Server VM Temurin-18.0.1+10 (build 18.0.1+10, mixed mode, sharing)

If you want to know more about sdkman, check the sdkman usage documentation.

How to Update a Java Version

Once a new Java version is available, it should be listed via sdk list java. But, you can also use sdk upgrade java to ask sdkman to check for updates.

Let’s install an older version of Java:

$ sdk uninstall java 17.0.3-tem

$ sdk install java 17.0.2-tem

$ sdk install java 11.0.12-tem

$ sdk upgrade java
Available defaults:
java (local: 18.0.1-tem, 11.0.12-tem, 17.0.2-tem; default: 17.0.3-tem)

Use prescribed default version(s)? (Y/n): Y

Installing: java 17.0.3-tem
Done installing!
Setting java 17.0.3-tem as default.

By confirming with y, it downloads the suggested default version 17.0.3-tem and sets it as a default on your system. This makes future updates easy by executing sdk upgrade java.

Summary

In this article, you learned how manage Java SDKs easily using sdkman. It’s a very useful tool, which supports many Linux distributions including Ubuntu, Debian and MacOS.

SDKMan enables you to install and remove Java versions, switch between them, and upgrade your Java versions with a single command. This keeps your system clean and makes managing Java SDKs easy.

I hope you enjoyed the article.

If you liked it and felt the need to give me a round of applause 👏 or just want to get in touch 👋, follow me on Twitter. I work at eBay Kleinanzeigen, one of the world’s biggest classified companies. By the way, we are hiring!

References

• https://en.wikipedia.org/wiki/Java_Development_Kit
• https://adoptium.net/
• https://phoenixnap.com/kb/create-a-sudo-user-on-debian
• https://stackoverflow.com/questions/63336131/install-sdkman-in-an-alpine-based-docker-image
• https://brew.sh/
• https://reflectoring.io/manage-jdks-with-sdkman/
• https://blog.jdriven.com/2020/10/automatic-switching-of-java-versions-with-sdkman/

That doesn't mean that we no longer need a full blown Linux installation. In fact, machines with both Windows and Linux running side by side are quite common.

But do you know what's more common than machines running both operating systems? Machine owners who have tried to dual boot their machines and ended up losing a lot of data in the process.

So if you're one of the victims or one of those who are trying to avoid possible disasters in their upcoming dual booting adventure, this article is for you. Here you'll learn about:

• How to install any Linux distribution alongside Windows
• How to get rid of Linux without messing up Windows if necessary
• Common problems, misconceptions, and their solutions, and
• Some generally geeky stuff to impress you peers

Without any further ado, let's grab a mug of coffee or tea or at least water and jump right into the process.

Some Assumptions I’m Making

Before I jump into the core of the tutorial, I want to clarify a few things. To make this entire article approachable, I'm making following assumptions about your system:

• Your computer is using UEFI and not BIOS
• You already have Windows installed on your machine
• You have a USB drive large enough (4GB) to boot Linux from
• You have enough space (25GB) to install Linux on your HDD or SSD

That's pretty much it. If you have all of the above ready, you're good to go.

How to Create a Bootable Linux USB Drive

There are multiple tools that can help you to create a bootable Linux USB drive. Among all these tools, my favorites are:

• balenaEtcher
• Fedora Media Writer

Both of these tools are open-source, free to use, and available on pretty much all major platforms. For this article, I'll go with Fedora Media Writer simply because there are not a lot of tutorials talking about it and because I use it personally.

Like the name suggests, Fedora Media Writer is a tool created by Red Hat for making bootable Linux USBs. Once you've downloaded the program, install it on your system and fire it up.

This is how it looks. As you can see, you've got the option to download the latest Fedora ISOs as well as an option to pick a custom image file from your drives.

Unless you're planning on installing Fedora (spoiler! it's my favorite) on your machine, you'll have to go ahead and download your desired ISO file.

In this article, I'll use Ubuntu because it's more popular among newcomers. But the things you'll learn here can be applied to any other Linux distribution.

Go ahead and download the ISO for Ubuntu from their download page. Ubuntu 20.04 LTS (the latest long term release at the time of writing) is around 2.67GB in size. Once you've finished downloading the file, go back to Fedora Media Writer, click on "Custom Image", and select the ISO file you've just downloaded.

The "Write to Disk" button is grayed out because there are no USB drives attached to the computer. Connect your USB drive and the button should turn bright red.

Recheck that the correct USB drive is selected in the dropdown and hit the "Write to Disk" button. Depending on your machine's transfer rate, this process may take a few minutes. Once it's done, disconnect the USB drive and set it aside. You'll need it soon.

How to Prepare Your Computer for Installing Linux

Again, it's not uncommon to find people who have failed to boot from a Linux USB drive. This can happen if you haven't configured your computer properly.

To do so, go to your Control Panel. Not the new Settings application, but the OG Control Panel.

Make sure Control Panel is either on "Small icons" or "Large icons" mode and not on the "Category mode". Now go to "Power Options" and from the left side-bar, click on "Choose what the power buttons do".

Click on the Change settings that are currently unavailable link and uncheck the "Turn on fast startup (recommended)" option and hit "Save changes".

According to Walter Glenn's article,

Fast Startup combines elements of a cold shutdown and the hibernate feature. When you shut down your computer with Fast Startup enabled, Windows closes all applications and logs off all users, just as in a normal cold shutdown.

At this point, Windows is in a state very similar to when it’s freshly booted up: No users have logged in and started programs, but the Windows kernel is loaded and the system session is running.

Windows then alerts device drivers that support it to prepare for hibernation, saves the current system state to the hibernation file, and turns off the computer.

When you start the computer again, Windows does not have to reload the kernel, drivers, and system state individually. Instead, it just refreshes your RAM with the loaded image from the hibernation file and delivers you to the login screen. This technique can shave considerable time off your start up.

I know this sounds like a nice to have feature, but the problem is, if you keep fast startup enabled in a dual boot system, Linux will be unable to use any of the drives shared between the two operating systems because they're hibernated and held by Windows.

Next, boot into your motherboard's UEFI configuration screen. Depending on your motherboard or laptop brand, the key can change but in most cases pressing the "Del" key should get you in.

Once you're there, you'll have to change one setting in particular:

• Turn off secure boot – this is one of the features of UEFI that helps prevent attacks and malware during boot. Disabling it is not strictly necessary but depending on the distribution you've chosen you may or may not face issues during installation. Disable it to be safe.

Save the updated settings and boot back to Windows. Now it's time to prepare some disk space for Linux to fit into.

How to Create Additional Partitions for Installing Linux

Now it's time to make some room for the new OS. Based on the state of your HDD or SSD, it can either be very straightforward or quite tricky.

Let me explain what we're going to do. There is a utility built into Windows called "Disk Management" that's useful when you want to mess around with your partitions.

You can use this to squeeze out some space out of your existing partitions. To do so, open Disk Management by searching for it in the start menu.

Keep in mind that it may pop up as "Create and format hard disk partitions" instead of Disk Management. Fire it up and have a good look at its user interface:

This screenshot is from one of my machines that doesn't have Linux installed. I'll use this device as the guinea pig for this article. It has a 512GB NVME SSD and 8GB of RAM.

The user interface is divided into two parts. The top one is a list of all your partitions and the bottom part has all the physical disks connected to your computer listed vertically.

The below screenshot is from my desktop workstation that has a 250GB NVME SSD and a 1TB HDD. I have both Windows and Linux installed on the second disk. So if you have multiple disks on your machine as well, I would suggest you install the OS on the disk that contains the EFI partition.

If you look at the beginning of Disk 1, that 550MB FAT32 partition is the EFI. On your machine, it may be much smaller.

Let's get back to our guinea pig device. As you can see from the screenshot, the Windows (C:) partition is almost 250GB. I'll cut off 108GB from this partition.

• 100GB for root
• 8GB for swap

In Linux, the root directory contains all other directories and files on the system. When your RAM gets full, Linux moves the inactive pages from memory to the swap space. Having a swap space is not mandatory but it's good to have.

There is no hard and fast rule for determining the swap space. The recommended size for swap when you have a 4GB-8GB RAM is 2 times that size, and for 8GB-16GB is 1.5 times that size. Considering I don't do any memory intensive tasks on this laptop, I will break the rule here.

To cut off some space from your desired partition, right click on it from the bottom part and click on "Shrink". Once you do that, Disk Management will start calculating the amount available for shrinking.

You may think that the entire free space of a partition should be shrinkable, but that's not true. Sometimes there are unmovable files scattered around your partition that may prevent you from using the full free space. In those cases, use a tool like Defraggler to optimize your drive.

After Disk Management has finished querying the partition, you'll see the following window:

As you can see, I have 160311MB of space available to shrink. Dividing the value by 1024 will give you the size in gigabytes which in my case is around 156GB.

But I want to shrink my partition by 108GB. Multiplying this value by 1024 gives the value in megabytes of 110592MB.

Once you have your desired size calculated, hit the "Shrink" button. The shrinking process doesn't take that long. Once the process is done the bottom part of the user interface will update.

As you can see, I now have 108GB of unallocated space. To be honest, this is enough for proceeding to the next step. But to make your life easier, I would suggest that you create two RAW partitions before going forward.

To do so, right click on the unallocated space and click on the "New Simple Volume" option. A new wizard window will show up. Press the "Next" button and on the next step, the wizard will ask about the new partition's size:

I want to create the 100GB root partition. Multiplying that value by 1024 gives the value in megabytes which is 102400MB. Once you have the size calculated, hit "Next".

In the next step, the wizard will ask you about the drive letter. Choose "Do not assign a drive letter or drive path" and hit "Next".

In this step, select the "Do not format this volume" option and hit "Next". Finally hit finish on the last step. Follow the same process for creating your swap partition.

I now have a 100GB RAW partition for the Linux root and a 8GB RAW partition for swap. Close the disk management tool and grab another mug of coffee or tea or at least water because we're going deeper into the rabbit hole.

How to Install Linux Alongside Windows

Okay everyone, it's getting real now. We're going to do it. But first, you'll have to figure out which key to use to get into your boot menu.

On the device I'm using, pressing the F2 button takes me to the UEFI configuration screen. From there, pressing F8 takes me to the boot menu. So make sure you've done the research for your device.

Some tutorials may instruct you to change the boot order from your UEFI configuration screen, but I don't recommend doing that. The SSD or HDD that contains your bootloader should always be on the top.

Now connect the bootable USB device that you set aside on the first section and reboot your computer into the boot menu. From the boot menu, select the bootable USB drive and hit enter.

The GNU GRUB menu will appear. Pick the first one that says "Ubuntu". Wait until the file integrity check finishes or you can just skip it by hitting "Ctrl + C" on your keyboard.

You'll hear a beautiful chime and with that, the majestic Ubuntu installer will show up:

Before you hit the "Continue" button, I would suggest that you get connected to the internet. If you're using an ethernet cable then you should be connected already. But if you're using wireless, then check the top right corner of your screen for the Wifi icon:

Once you're connected, hit the "Continue" button on the installer:

Pick the correct keyboard layout for yourself and hit "Continue".

The "Normal installation" will give you a bunch of useful software and games from the get go, whereas the "Minimal installation" will give you the essentials only.

Keep the "Download updates while installing Ubuntu" option checked. This will download updated package files from the internet during installation.

The third option needs some explanation. Assume that you're using an NVIDIA GPU. When Ubuntu detects that GPU, Ubuntu will load the open-source drivers for NVIDIA GPUs known as "nouveau".

If you check the "Install third-party software for graphics and Wi-Fi hardware and additional media formats" option, NVIDIA will attempt to install proprietary drivers provided by NVIDIA itself. It'll also install codecs for proprietary media formats such as MPEG.

This device I'm using has an AMD GPU and uses the open-source "amdgpu" driver. I'll leave this unchecked considering I can install the codecs as necessary by myself. Do what you prefer and hit the "Continue" button.

Okay this step needs attention. The Ubuntu installer is smart enough to detect whether you have other OSes installed on your machine or not. If yes, the installer will offer you the option to install Ubuntu alongside them. Don't pick that option. I repeat, don't pick that option.

Choose "Something else" and hit the "Continue" button.

This part can be a bit tricky. This is why I instructed you to create the partition from Windows instead of leaving the space unallocated. If you had left it unallocated, figuring out which part of the disk you should use would have become much more difficult.

At the top you can see a multi-colored line along with legends for which color represents which partition. Find out the two partitions you created from Windows.

In my machine, "nvme0n1p4" and "nvme0n1p5" are the ones. Now from the list, find the one you created for the root (nvme0n1p4 in my case) and double click on it:

Choose "Ext4 journaling file system" from the "Use as" dropdown and "/" as the "Mount point" dropdown. According to the The Linux Information Project:

A mount point is a directory (typically an empty one) in the currently accessible filesystem on which an additional filesystem is mounted (i.e., logically attached).

Hit the "OK" button. Next double click on the partition you created for the swap space:

Choose "swap area" from the "Use as" dropdown menu and hit the "OK" button. There is one more partition to configure. That is the EFI partition. Scroll through the list and find the FAT32 partition.

On my machine, the "nvme0n1p1" is the EFI partition. Double click on it:

Make sure "EFI System Partition" is selected from the "Use as" dropdown menu. This is the partition that'll contain your bootloader. Make sure you're not formatting this partition. Hit the "OK" button.

Also, the default mount point for the EFI partition is "/boot/efi". Some distributions like Fedora will require you to write this mount point manually. So make sure you're putting the correct mount point.

Recheck the partition configuration once again and if everything looks fine, hit the "Install Now" button.

The installer will ask you about your time zone. I live in Dhaka, Bangladesh so that's what I've chosen. Hit the "Continue" button.

Fill out all the information as you see fit and hit the "Continue" button.

The installation process shouldn't take long. Back when I was a kid, I loved looking at this slideshow.

Once the installation is done you can either continue testing or restart. If you choose to restart, Ubuntu will instruct you to disconnect the USB drive and hit Enter.

The machine will reboot and the GRUB menu will show up again. Take a look at the list, and you'll see both Ubuntu and Windows Boot Manager on the menu. Boot into Ubuntu because you have one last thing to do.

How to Sync the Time Between Windows and Linux

This is one of the common problems that people with a dual boot system face. When you boot into Windows and then boot into Linux, you'll find Linux's clock all messed up. The same thing will happen if you first boot into Linux and then boot into Windows.

Let me explain why this happens. Your computer (or rather every computer in the world) has two clocks. One is the system clock that lives within the OS, and the other is the hardware clock that lives in your motherboard and keeps track of time even when your computer is not running.

The problem is that Windows assumes that your hardware clock is running in your local time and Linux assumes that your hardware clock is running in UTC time and applies an offset according to your location.

The easiest way to fix this issue is to make your Linux distribution use local time like Windows does. To do so, execute the following command in the Linux terminal:

timedatectl set-local-rtc 1 --adjust-system-clock

Now restart your computer into Windows, sync the system clock and go back to Linux. The time should not be messed up now.

How to Remove Linux From a Dual Boot System

Say for some reason you didn't like your time with Linux and want to get rid of it. This would be sad, but life is hard, ain't it?

Removing Linux from a dual boot system is a two step process:

1. Getting rid of the GRUB bootloader
2. Getting rid of the Linux partitions

To get rid of the GRUB bootloader you'll have to remove the corresponding files from the EFI partition. The problem is that the partition is hidden by default.

To make if accessible you'll have to use the diskpart program. It's a disk management utility like the Disk Management tool but it's a command line interface.

Boot into Windows. From the start menu, open Command Prompt as an administrator. To do so, just search for "cmd" in your start menu and when the Command Prompt shows up, press the "Ctrl + Shift + Enter" key combination.

Now write diskpart in the command prompt window and hit enter to start the program.

Next, write list disk and hit enter to get a list of all the connected disks:

This device has only one physical disk but you may have multiple. Write sel disk <disk number> to select the desired disk.

Then write list vol and press enter to list out all the partitions in this disk.

Judging by the size and format, I can say that Volume 4 is the EFI partition. Keep in mind this can be much smaller on your system but it will be always a FAT32 partition. Write sel vol <volume number> to select the desired volume.

Finally write assign letter x and hit enter to assign the letter x to this partition.

Exit diskpart by writing exit and hitting enter:

Now the partition has become accessible. From the same command prompt window, go inside the EFI partition by writing x: and hitting enter.

To get a list of all the folders in there, write dir and hit enter.

Now write cd EFI to go inside that EFI folder and write dir once again to list out the contents.

You'll have to get rid of that ubuntu folder. To do so, write rmdir /s ubuntu and hit enter. Command prompt will ask you whether you're sure or not. Write Y and hit enter to confirm. Then use dir one last time to make sure it's gone.

That's it. Next, open Disk Management once again like you did before and from the bottom part, right click on the Linux oriented partitions and choose "Delete Volume" from the list.

After deleting the partitions, you can either create a new one using the unallocated space or extend the partition on the left of it to dissolve the unallocated space.

Finally reboot your computer and check whether the Ubuntu has gone away from your machine or not.

What About Other Linux Distributions?

The techniques learned in this article is relevant for any Linux distributions out there.

So, whenever you're dual booting a system, make sure that

• Secure Boot is disabled
• Fast Startup is disabled

And during the installation

• Do not choose any guided/automatic installation type
• Make sure to not format the EFI/ESP partition
• Make sure to mount your partitions properly

As long as you're sticking to these few rules, you should be good to go.

Just keep in mind that there are some rare cases when a distribution may not use GRUB as a bootloader.

Take the very popular "Pop!_OS" for example. It uses "systemd-boot" as its default bootloader. As a result you'll have to keep pressing the Space button (or maybe any button on the keyboard) during startup, otherwise the boot menu won't show up and you'll boot into Pop!_OS directly.

Another thing that I've seen: some motherboards such as my MSI B450 Tomahawk Max, chooses the Windows Boot Manager by default even though I have a working Linux installation. If you see something like this, go into your UEFI configuration screen and look for relevant options.

Conclusion

I would like to thank you from the bottom of my heart for the time you've spent reading this article.

I also have a personal blog where I write about random tech stuff, so if you're interested in something like that, checkout https://farhan.dev. If you have any questions or are confused about anything – or just want to get in touch – I'm available on Twitter and LinkedIn.

Flutter is a Dart-based toolkit that helps you build the front end of your apps. It really shines in cross-platform mobile app development and aims to be a viable option for web and desktop as well.

In its mobile app flavor, Flutter provides many UI abstractions to build interfaces. You can implement logic in Dart, or directly with Kotlin or Swift if you need more specific interactions with your OS of choice.

While cross-platform app development is nothing new, earlier strategies such as PhoneGap and Ionic used the available WebView implementation instead of interfacing directly with the system. This is not only very limiting but also has a lot of performance costs.

The gold standard for native cross-platform app development is yet to be established. But Flutter both offers a a lot on its own and elegantly steps out of the way when you need to interact directly with the OS using whatever official language you need to use.

This makes Flutter a game changer even before it has fulfilled its potential of sharing the same codebase with the web and desktop versions of an app.

In this tutorial we'll get to setup an Ubuntu 16.04+ machine for Android app development with Flutter. You can also edit Swift code directly from Android Studio, but unfortunately you won't have official support to test the app in iOS devices or emulators due to Apple's policies.

For this we'll need to install and configure Java as an Android Studio dependency, setup Android Studio to use hardware-acceleration and run Flutter apps and, of course, install and configure Flutter itself. So, let's get started.

How to Install and Configure Flutter

First things first: let's install Flutter through the snap store. If you are using Ubuntu 16.04 onwards, you likely already have the snap command installed.

If you are not, you can follow the instructions available for your distro at the "Install Snap Store on your Linux distribution" section on this page.

With the snap command available, install Flutter like this:

sudo snap install flutter --classic

After Flutter has finished installing, run a basic checkup which will also do some automatic configuring:

flutter doctor -v

Flutter has been installed, nice!

How to Install and Configure Java

First of all, we need to get the (community-backed) Open Java Development Kit before being able to use Android Studio.

To get the latest stable version of Java 8, open your terminal and run:

sudo apt-get update && sudo apt-get install openjdk-8-jdk

Other versions can sometimes show some unpredictable problems while working alongside Flutter as of May 2021, so I recommend installing OpenJDK 8. Don't worry, OpenJDK 8 is set to receive support at least until 2024.

After a successful installation, it is time to set the $JAVA_HOME environment variable. It's used by default by many applications which interact with your local Java installation, Android Studio among them.

Get a list of the currently installed JDKs in your system with this command:

sudo update-alternatives --config java

Choose from the list of locally installed versions (remember that Java 8 is the easiest to use with Flutter) and set the one which you would like to be the system's default.

Set $JAVA_HOME to its path, without including the /bin portion onwards of the path (in my case, for instance, the correct path was /usr/lib/jvm/java-8-openjdk-amd64):

#JAVA_HOME=<your_java_installation_path>, same as below if you followed instructions
JAVA_HOME="/usr/lib/jvm/java-8-openjdk-amd64" # my local path after installing openjdk-8
echo "JAVA_HOME=\"$JAVA_HOME\"" >> ~/.bashrc # sets JAVA_HOME env var for current user
echo 'export PATH=$PATH:$JAVA_HOME/bin' >> .zshrc # adds java's binaries to your path
source ~/.bashrc && echo $JAVA_HOME # verifies that the variable was perenially set

How to Install and Configure Android Studio to Run with Flutter

You can download Android Studio here.

After your download finishes, extract the Android Studio package into the /usr/local/ directory:

sudo tar -C /usr/local -zxvf ~/Downloads/<android_studio_package>.tar.gz

After it's successfully extracted, run Android Studio's installation script:

bash /usr/local/android-studio/bin/studio.sh

This should pop up the install wizard. Follow the wizard's instructions for the standard installation and you should eventually arrive at the starter screen.

Select Configurations at the lower right corner and click on "Plugins":

Install the "Flutter" official plugin, published by flutter.dev:

You will be prompted to install the Dart plugin (Flutter's base programming language) before you proceed. Click 'Ok' and restart the Android Studio IDE.

The option to start a Flutter project should be visible now. Click on it, then select 'Flutter Application' and click on 'Next'.

You should be greeted by the project configuration screen. Configure your project's name, location, and description as you wish, and point the field "Flutter SDK" to /home/<your_user_name>/snap/flutter/common/flutter:

In case the above path is not available, open a terminal and run:

flutter doctor -v

You should then be greeted with the starter project screen:

Almost done. Now you need to accept the Android licenses and double check your Flutter installation's ownership in order to avoid future surprise build errors due to resources denied for Android Studio.

Open up your terminal and run:

flutter doctor --android-licenses # accept Google's licenses, necessary to build the app
sudo chown -R $USER:$USER /home/$USER/snap/flutter # confirm you are the owner of local flutter

Now Android Studio is finally setup to run Flutter projects. Nice!

You should also enable the Desktop Entry for Android Studio. In your project screen, click on "Tools" then "Create Desktop Entry":

The Android Studio shortcut should be available from the "Activities" menu now.

How to Enable Hardware Virtualization for the Android Emulator

In order to run the emulator, we must first set up your CPU's hardware virtualization capabilities.

Run kvm-ok in your terminal and your output should indicate whether you can use KVM acceleration or not. If you have an AMD or Intel CPU, most likely it can.

The Kernel Virtual Machine, in a nutshell, is a bridge between the kernel with virtual devices which allows a virtual device to emulate its own hardware directly from the host computer's hardware. You can take a look here for more detailed information.

Provided you are indeed able to use KVM acceleration, it is time to setup KVM and authorize the current user for it:

sudo apt update # update repositories
sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils # base packages
sudo addgroup kvm && sudo addgroup libvirtd # create user authorization groups
sudo adduser $USER kvm && sudo adduser $USER libvirtd # add current user to auth groups
sudo virsh -c qemu:///system list # checks if virtualization is ok
# if everything went fine, your output will be something like:
#
#  Id    Name                           State
#----------------------------------------------------

And restart your user session. In the computer, not only the terminal. Log off the system and then login or reboot the PC, I'll be waiting.

How to Use the Android Emulator to Test Apps

Now, open an Android Studio project and click on the 'AVD Manager' (Android Virtual Device) option located in the window's upper right corner:

Click on the "Create Virtual Device" button and a window with a list of devices should pop up with the 'Phone' category preselected. I recommend that you pick a device with Play Store enabled just in case you might want to use it later inside your emulated device. Mine was the Nexus 5.

Click on the 'Next' button and a list of system images (Android OS Versions) should appear:

First, download your target image (by simply clicking on 'Download' right beside the Release Name), select a locally downloaded image, and click on 'Next'. It should only be highlighted after the image was successfully downloaded.

A window will then show up, offering you to customize your virtual device's properties such as screen orientation on startup, RAM usage, and so on. Tweak the device to your liking if you want, otherwise you can safely click on 'Finish'.

If everything goes well, you should now see your device listed at the Android Virtual Device Manager window:

Go back to your Android Studio project view. At the same line where the 'AVD Manager' button is located, there is a dropdown list of available devices just to the left of 'main.dart'. Select the emulator you have just set up and click the green 'play' button just to the right of 'main.dart'.

In case the emulator is not listed there yet, open the AVD Manager window again and click the green 'play' button under the 'actions' label listed for your virtual device. This will load and open the emulator before running your Flutter code.

Notice that 'debug' ribbon in the upper right corner? In case you wanna get rid of it, add debugShowCheckedModeBanner: false as a field of MaterialApp.

How to Use a Physical Android Device to Test Apps

You'll need to have a local installation of the Android Debug Bridge in order to enable your computer to trade information (such as APK builds) with any connected Android devices, virtual or otherwise.

The ADB consists of a client (the interface from which you run commands, which will be the ADB binary installed in your computer for all purposes of this tutorial), a daemon (which executes in the Android device the commands initially sent from the client) and a server (which runs locally in the PC, which has a default listening location at tcp://localhost:5037, and intermediates the communication between the client and the daemon).

Very conveniently, Android Studio currently ships with an ADB, so if you followed the instructions above to install Android Studio, you already have one at your computer.

It is possible to install ADB from the Ubuntu repositories alongside the one in Android Studio, but this invites headaches if your computer eventually confuses the locally installed versions. So instead let's setup our Linux user to access Android Studio's ADB and then run ADB:

echo 'export PATH=$PATH:$HOME"/Android/Sdk/platform-tools"' >> .bashrc # adds adb to path
adb start-server # launches adb server
adb devices # lists connected devices

After running adb devices, you most likely got an error. This error has registered the $LOGNAME variable which contains the current user name. You will use it to insert your user into the plugdev group, in case you are not there already.

You also most likely do not have a set of udev rules for Android devices. UDEV rule files specify Ubuntu interactions with plugged in devices, and Ubuntu will refuse to perform certain interactions with your Android device unless it is previously authorized in an UDEV rules file.

So, let's correct those errors:

# add user to plugdev group
sudo usermod -aG plugdev $LOGNAME
# downloads a very thorough UDEV rules file into the appropriate directory
sudo wget -O /etc/udev/rules.d/51-android.rules https://raw.githubusercontent.com/NicolasBernaerts/ubuntu-scripts/master/android/51-android.rules
# gives reading permission to the UDEV android file
sudo chmod a+r /etc/udev/rules.d/51-android.rules

Reboot your current Linux user session to apply these changes, then open a terminal and run adb devices again.

In case you still have a UDEV-related error, your device's manufacturer ID probably is not listed in /etc/udev/rules.d/51-android.rules. In this case, search the internet for your device's manufacturer UDEV id and manually add it to the rule list in the same format as the others.

Notice how the only field with a unique value amongst the rows is ATTR{idVendor}. If you do not receive any error, you'll notice that your device is listed as 'unauthorized'. Let's unlock the device for USB debugging.

How to Unlock Developer Mode and USB Debugging

In your Android device, open up 'Settings', then 'About Phone'. Tap your 'Build number' 5-6 times until a toast telling that 'You are now a developer!' pops up.

Back to 'Settings', open System', you should see that 'Developer Options' were unlocked.

Tap this new entry and check 'USB debugging' just under the 'Debug' section.

Plug your Android device in your PC via USB, then run adb devices on your terminal. The output should list your device and also point that it is unlocked for debugging.

Now, go back to Android Studio, click on the device dropdown list (the one in which you selected your Virtual Device before) and your physical device should now be listed. Select it.

Finally, click on the 'run' button and you should see the app in your device, ready to be interacted with.

Congratulations! You are now a Flutter developer. Good luck in your development journey!

Cover image from flutter.dev.

Back in 2017, Docker introduced two different versions of its platform: Docker-CE and Docker-EE. But do you know their differences?

Docker CE (Community Edition) is the classical OSS (Open Source Software) Docker Engine. Includes the full Docker platform and is great for developers and DIY ops teams starting to build container apps.

If you are an avid developer like I am, you've probably been using Docker for a while. And I would say that most likely this is the version you've worked with, simply because it's free!

Docker EE, on the other hand, is a premium version of CE. It comes with all CE capabilities plus many enterprise level features.

Anything that comes with premium is not free right? So it goes from $750/month basic plan to $2000/month advanced plan. Anyway the prices are on par with what you would expect from enterprise products.

Please get in touch with their sales team to check the most up-to-date prices.

Docker CE vs EE - the Details

Let's do a quick comparison between Docker EE and Docker CE interest over time:

Now Docker EE vs Docker CE vs Docker:

From my experience, users who are searching for just Docker are looking for the CE edition. This shows us that Docker EE is used much less. But I'm certain that there are robust use cases where it makes sense to use it.

Since I'm an open source enthusiast all my experience comes from using the Docker CE edition, so writing this article was a wonderful experience getting to play with Docker EE.

After that quick introduction, let's get our hands dirty.

Prepare the Ubuntu 18.04 machine

As the first step, we will get the soil ready by running some common commands.

All the commands will be executed on a fresh Ubuntu 18.04 machine, and this time I've chosen Google Cloud Platform as the demonstrating environment.

Create the Virtual Machine

Let's start by creating a fresh VM using Ubuntu 18.04 image:

gcloud compute instances create ubuntu-fcc-demo \
--zone=us-central1-c \
--machine-type=n1-standard-1 \
--image=ubuntu-minimal-1804-bionic-v20200703a \
--image-project=ubuntu-os-cloud \
--boot-disk-size=10GB \
--boot-disk-type=pd-standard

Now connect to it using ssh:

gcloud compute ssh ubuntu-fcc-demo --zone=us-central1-c

Set up commons dependencies:

sudo apt-get update

sudo apt-get install \
   apt-transport-https \
   ca-certificates \
   curl \
   gnupg-agent \
   software-properties-common

Install Docker CE on Ubuntu 18.04

Install from https://get.docker.com

The install script lets you quickly install the latest Docker-CE releases on the supported linux distros. I don't recommend depending on this script for deployment to production systems. From docker-install:

curl -sSL https://get.docker.com/ | sh

The beauty of this command is that it will check your linux distro and run the right instructions to get Docker CE running for you.

You can test that everything is OK by running:

sudo docker run hello-world

# output
Hello from Docker!
This message shows that your installation appears to be working correctly.

Install from Docker repository

This one has more step, but is the recommended approach from Docker's official docs (we even check their GPG key fingerprint).

First, add Docker’s official GPG key:

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

Then verify the key's fingerprint:

sudo apt-key fingerprint 0EBFCD88

Look for the fingerprint 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88. This makes sure the key has not been tempered with.

Next, set up a docker stable repository:

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

The $(lsb_release -cs) command returns the Ubuntu distribution. In our case we used bionic.

Now install Docker Engine:

 sudo apt-get update
 sudo apt-get install docker-ce docker-ce-cli containerd.io

And test that everything is OK by running:

sudo docker run hello-world

# output
Hello from Docker!
This message shows that your installation appears to be working correctly.

Instructions based on docs.docker.com.

Install Docker EE on Ubuntu 18.04

Install using Mirantis Launchpad CLI

To work with Docker EE you need a trial/purchased version. Docker disabled the option to get a trial subscription on their website, and now you need to contact their sales team to get a trial account.

Looking around I found out that, since Mirantis acquired Docker Enterprise, the way to get a Docker EE trial account has changed. You need to go to the Mirantis website and, after applying, you can download it right away.

At the time of this writing the installer is currently beta software. If there's a different way to install Docker EE, please get in touch. I would love to improve this article!

The Mirantis Launchpad CLI tool ("launchpad") is the new, better way to evaluate and experience Docker Enterprise (check out launchpad GitHub).

Download Launchpad CLI

Start by Downloading Launchpad. For Ubuntu 18.04 I used the launchpad-darwin-x64 version.

If you didn't download it from the Virtual Machine, here's a command to upload it to it:

gcloud compute scp launchpad-linux-x64 ubuntu-fcc-demo:~/launchpad \
  --zone=us-central1-c

Next, verify the installation:

# Give it writting permission
chmod +x launchpad

# Verify the installation
./launchpad version

# output
version: 0.12.0
commit: 4492884

Then register your user:

launchpad register

The information provided via registration is used to assign evaluation licenses and for providing assistance for the usage of the product.

Next, set up your cluster.yaml config.

This step was the one that took the most time for me. You need to set up 3 machines:

• Admin machine: The one where you are executing the launchpad command.
• Worker machine: Will be running your workloads.
• Manager machine: Contains the admin dashboard, where you have access to many configs and metrics.

They did a great job with the Go launchpad binary. The tricky parts are within the infrastructure setup. Fortunately they already have some terraform scripts to help with it.

Since at the time of this writing there was no option for GCP, I had to setup the infrastructure manually. The Admin machine connects to the Worker and Manager nodes to setup many steps, so make sure you have the ssh keys correctly set up.

The ssh keys step took me some time to figure out, and I even opened an issue in their repo, but then I quickly solved it. So if you have a similar issue, make sure you check it out.

There's a really detailed documentation about each attribute you can use in the config file.

Now it's time to bootstrap your cluster.

Once you have the cluster.yaml config set up, you can run the apply command:

launchpad --debug apply

You should see something like this:

Running phase: Install Docker EE Engine on the hosts

This is where I can say that they did a really good job abstracting all the setup steps.

There are 37 steps that the Go launchpad binary executes.

At the end you should see a message like this:

INFO[0021] ==> Running phase: UCP cluster info
INFO[0021] Cluster is now configured. You can access your cluster admin UI at: https://34.71.157.231 \
INFO[0021] You can also download the admin client bundle with the following command: launchpad download-bundle --username <username> --password <password>

Now, to test that everything is OK, go into the cluster admin UI:

Admin login UI

After logging in, you are presented the cluster admin UI:

Admin dashboard

I played a little with some of its features, and overall they are great. They provide easy to usage Access Controls and Certified Docker images.

These instructions are based on this getting-started guide.

Wrapping up**

In this article we saw how to set up Docker on Ubuntu 18.04 for both CE and EE versions.

And since Mirantis has acquired Docker Enterprise, we found out that Launchpad is the latest way for customers looking to try out Docker Enterprise licenses.

Overall the developer/deployment experience is really good, since almost all steps to get an environment ready for Docker EE are automated. And Docker seems to be looking to increasingly automate this process, so that is really nice!

• Illustrations from Icons8

If you found this helpful, or wish to challenge or extend anything raised here, feel free to contact me on Twitter or Linkedin. Let's connect!

A couple of months ago, when I learned Ruby-on-Rails for the first time, I had to work on a collaborative project with a coding partner. We kept running into issues, as he had a different version of Rails and Buby setup for the project. I couldn't wrap my head around how to install the versions the project needed.

Here's the guide I wish I had. It also shows you how to switch the version of Ruby or Rails you're using, depending on the projects you're working on.

First, let's get the latest version of Ruby installed. To do this, we need to install a package called RVM - Ruby version manager. This package lets us install ANY version of Ruby on our Ubuntu machine and allows us to switch between versions.

All the code here will be run using the Ubuntu CLI/terminal.

Installing RVM

1. First, we need to install a pre-requisite. Open up your Ubuntu terminal and type the command:

sudo apt-get install software-properties-common

Next, we need to add the PPA (Personal Package archive). A PPA is how we get files distributed by developers that are yet to make it to the official Ubuntu package/app store.

It's also a way for developers to distribute the latest versions of their software while waiting for Ubuntu to test and publish that software in the official store.

sudo apt-add-repository -y ppa:rael-gc/rvm

The command above adds the PPA to the list of locations we can download packages from on our Ubuntu machine.

Next, let's refresh our list of packages by running:

sudo apt-get update

Finally, let's install RVM itself.

sudo apt-get install rvm

Now restart your terminal for your changes to take effect. Then, type rvm version and hit enter to check that rvm is installed. You should get a response like this:

rvm 1.29.10 (manual) by Michal Papis, Piotr Kuczynski, Wayne E. Seguin [[https://rvm.io](https://rvm.io)]

Installing Ruby

Now we can install the latest Ruby version which is 2.7.1. Run the command rvm install 2.7.1. Alternatively, you can run rvm install ruby which will install the latest stable version (this will install v2.7.0).

To see what Ruby versions you have installed, run rvm ls. To switch between Ruby versions, run rvm use <version_number> (for example, rvm use 2.7.1).

Installing Ruby-on-Rails

The latest version of Rails is at 6.03. Rails is simply a Ruby gem, and with Ruby installed we can install Rails! Run gem install rails to install the latest version of Rails.

Finally, to check that all went well, run rails -v. You should get Rails 6.0.3.2 back, as this is the latest version at the time of publishing this article.

You can now start your first Rails project by typing rails new myapp.

Hey, you're now on Rails!

If you try installing the latest version of node using the apt-package manager, you'll end up with v10.19.0. This is the latest version in the ubuntu app store, but it's not the latest released version of NodeJS.

This is because when new versions of a software are released, it can take months for the Ubuntu team to test and release in the official Ubuntu store. As a result, to get the latest versions of any software, we may have to use private packages published by developers.

In this tutorial, what we want to do is get either v12.18.1 (LTS - with Long term support) or v14.4 of Node. To get the latest versions, we can use either nodesource or nvm (node version manager). I'll show you how to use both.

All commands here will be run using the Ubuntu CLI/terminal.

Using NVM - my preferred method

I like nvm because it allows me use different node versions for different projects.
Sometimes, you may be collaborating on a project with someone using a different version of node and you need to switch node versions to what the project requires. For this, nvm is the best tool.

Install NVM

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

To check that nvm is installed, type nvm --version. If you get a version number back like 0.35.3, then you know nvm was successfully installed.

Restart your terminal for your changes to take effect.

Install NodeJS

Next, let's install Nodejs version 14.4.

Simply run nvm install 14.4.0 .

You can use a similar command to install any version of node you want, for example nvm install 12.18.1.

This command automatically installs nodejs as well as the latest npm version which is at v6.14.5.

If you ever need to switch node versions, you can simply run nvm use <version-number> , for example nvm use v12.18.1.

To list the different node versions you have installed with nvm, run nvm ls.

Install Nodesource

Run the command below to tell Ubuntu that we want to install the Nodejs
package from nodesource.

curl -sL https://deb.nodesource.com/setup_14.x | sudo -E bash -

NB that v14.4.0 is the latest version of Node but doesn't currently have LTS - long term support provided for it. To install the latest version of Node with LTS, change 14 in the command above to 12.

You may be prompted to enter the password for your root user. Enter that and hit enter/return.

Install NodeJS

Once we're done setting up Nodesource, we can now install Nodejs v14.4.
Run sudo apt-get install -y nodejs.

Once we're done, we can check that we have the latest version of Node installed.
Simply type nodejs -v into your terminal and it should return v14.4.0.

You should have npm automatically installed at this point. To check what npm version you have, run npm version. If you do not get an object that includes the latest version of npm at 6.14.5, { npm: '6.14.5' }, then you can update npm manually by running the following command:

npm install -g npm@latest.

If you run into any issues with npm being unable to update because it's not installed, you can install npm first by using sudo apt-get install -y npm, then run the command above to update it.

For certain npm packages to run, we also need to run the command below
sudo apt install build-essential.

And that's it!

You've got the latest versions of NodeJS and NPM on your Ubuntu machine.

Go build great products :)

A few days ago a Raspberry Pi I use for CI on my personal projects stopped working. The error was easily fixable, but since running anything on that PI was slow from day one, I decided not to proceed in that direction.

Also, because of the same issue I always wanted to switch to another OS – but I never had the proper motivation since everything worked on that Raspberry PI, right? Well the motivation came along with this article :)

Note: The original setup on the Raspberry PI was quite simple: Raspibian OS, VNC Server, and Jenkins.

For you that are new to Raspberries here is a little background at what they are, and what they can be used for.

Raspberry Pi's are basically small computers used most often used to learn programming skills, build hardware projects, do home automation, and some have even found usage in industrial applications.

There are a few different types of PI's on the market today. To learn more about them please visit the their Wikipedia page: https://en.wikipedia.org/wiki/Raspberry_Pi#Generations

Tools you'll needed to complete this tutorial:

• Raspberry PI
• Micro SD card
• Micro SD card adapter for your laptop
• Windows
• Mouse for Raspberry PI
• HDMI cable to connect your Raspberry PI to at TV or any other kind of screen
• Keyboard for Raspberry PI is good to have but not necessary as Ubuntu MATE offers on screen keyboard

Once we complete all the steps, this article will show you how to:

• Set up Ubuntu MATE on an SD card using Windows
• Install Ubuntu MATE to Raspberry PI
• Things to do after installing Ubuntu MATE

There are several OS options for Raspberry PI available, and Ubuntu Mate is just one option. For more info on other options you can check out this article:

Flashing Ubuntu MATE to Micro SD card

The SD card and USB sticks are called a Flash drives because they have a flash type memory in them. So flashing means creating a bootable drive with a specific operating system (OS) on it.

Navigate to the download page of Ubuntu MATE and download the recommended architecture image for Raspberry PI:

Download the Raspberry PI 32 bit version (recommended)

Setting Up the SD Card

After downloading the Ubuntu MATE image we need to write it to the SD card. To do that we will use the Balena Etcher tool. Etcher is a tool we will download from here:

Balena Ether download page

Install Etcher and launch it. Then select the Ubuntu MATE image file you previously downloaded, along with your SD card, and start the flashing process.

Note: Flashing Ubuntu MATE to the SD card takes some time, so feel free to get yourself a cup of coffee.

Balena Etcher decompressing Ubuntu MATE image

Balena Etcher validating Ubuntu MATE image

Once you are done with flashing, take out the SD card from the adapter and put it in the Raspberry PI. Also, this is the step where you will need to connect the PI with the mouse and a screen.

Installing Ubuntu MATE on Raspberry PI

Once you are done connecting all peripherals of the Raspberry PI, connect it to the power source and let it startup.

The Ubuntu MATE installation process is exactly the same as for ordinary Ubuntu. During this process you will be asked to to select your keyboard layout, timezone, username and password. Here is the step by step instalation guide for Ubuntu 18.04: Ubuntu installation.

After the installation is done you will be greeted by the desktop screen.

Ubuntu Mate desktop greeting screen

Things to do after installing Ubuntu MATE

Update the local database

This command updates/maps the local database of your local packages with updates, later allowing your system to fetch new versions of the packages.

sudo apt update

Upgrading the installed packages

This command fetches new versions of packages existing on the machine you previously mapped with sudo apt update command.

sudo apt upgrade

Note: Updating Ubuntu MATE takes a lot of time so feel free to get yourself another cup of coffee, and a pastry to go along with it. If you don't have any pastry around feel free to go to the nearest bakery, because by the time you get back you system will probably be 50% upgraded.

Installing the Ubuntu Software application

Software Boutique is the default software center on Ubuntu MATE. However, it has a very limited selection of applications, and one of the more interesting apps needed for my project is missing.

Luckily, since this is an Ubuntu distribution, there is a way to install the standard Ubuntu Software center which has more app choices.

Apparently there is a way of installing Ubuntu Software center via Software Bundle. But when selecting the option to doing that I was stuck and nothing seemed to happen for me so I just used the terminal command:

sudo apt install ubuntu-software

Bra gjort! You have just finished setting up the Ubuntu Mate OS on your Raspberry PI device!

Check out more articles like this on my freeCodeCamp profile, Medium profile, and other fun stuff I build on my GitHub page.

I recently got myself a “new” laptop – a Lenovo x270 (yay)! And once again I needed to set up a Python virtual environment. So of course I Googled for a solution, just to find my previously written article on the same topic!

So in this article, I'll update the instructions based on my newly acquired knowledge.

And let me tell you, it’s easier than before because we are going to do only two things:

• Install virtualenvwrapper
• Edit the .bashrc file

Prerequisites

In this article I will show you how to set up virtualenvwrapper with pip3 (pip for Python 3). We are not going to use Python 2 because it's no longer supported.

To complete this tutorial, you will need a computer with Ubuntu 20.04 installed and an internet connection. Also, some knowledge of the terminal and Vim editor would be useful.

Setting up a Virtual Environment

Now open your terminal in the home directory by right clicking and choosing the option “Open in Terminal”. You can also press the CTRL, ALT, and T keys on your keyboard at the same time to open the Terminal application automatically.

You first need to create a special directory that will hold all of your virtual environments. So go ahead and create a new hidden directory called virtualenv:

mkdir .virtualenv

pip3

Now you should install pip for Python3:

sudo apt install python3-pip

Confirm the pip3 installation:

pip3 -V

virtualenvwrapper

virtualenvwrapper is a set of extensions for virtualenv. It provides commands like mkvirtualenv, lssitepackages, and especially workon for switching between different virtualenv environments.

Install virtualenvwrapper via pip3:

pip3 install virtualenvwrapper

bashrc file

We are going to modify your .bashrc file by adding a row that will adjust every new virtual environment to use Python 3. We will point virtual environments to the directory we created above (.virtualenv) and we will also point to the locations of the virtualenv and virtualenvwrapper.

Now open the .bashrc file using the Vim editor:

vim .bashrc

If you still haven’t used Vim before or you don’t have it installed on your computer, you should install it now. It is one of the most widely used Linux editors and for good reason.

sudo apt install vim

After you've installed Vim open the .bashrc file by typing in the vim .bashrc command in your terminal. Navigate to the bottom of the .bashrc file, press the letter i to enter insert mode in Vim, and add these rows:

#Virtualenvwrapper settings:
export WORKON_HOME=$HOME/.virtualenvs
VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
. /usr/local/bin/virtualenvwrapper.sh

After you are done, press the esc key, then type :wq and press enter. This command will save the file and exit Vim.

Now you need to reload the bashrc script. There are two ways to do it – close and reopen your terminal, or execute this command in the terminal:

source ~/.bashrc

To create a virtual environment in Python3 and activate it immediately use this command in your terminal:

mkvirtualenv name_of_your_env

To deactivate the environment use the deactivate command.

To list all available virtual environments use the command workon or lsvirtualenv (lsvirtualenv will show the same result as workon but in a fancier way) in your terminal:

workon

lsvirtualenv

To activate one specific environment use workon + name of your environment:

workon name_of_your_env

There are several useful command you might need to use someday:

Rmvirtualenv will remove a specific virtual environment located in your .virtualenv directory.

rmvirtualenv name_of_your_env

Cpvirtualenv will copy the existing virtual environment to a new virtual environment and activate it.

cpvirtualenv old_virtual_env new_virtual_env

Well done! You have now created your first isolated Python 3 environment.

Thank you for reading!

Check out more articles like this on my freeCodeCamp profile, Medium profile, and other fun stuff I build on my GitHub page.

Let me tell you a story. Recently, I realized that I needed to review how to set up virtualenvwrapper on top of virtualenv in Ubuntu 18.04. I have completed this process several of times on different computers, and every time it seems to be just a little bit different than before.

I just got a new laptop and on the way home I read several tutorials on “How to set up virtualenvwrapper on Ubuntu 18.04”. And let me tell you – it seemed really easy because all of those tutorials were pretty straight forward and basically explained how to do these three 3 things:

• Install virtualenv
• Install virtualenvwrapper
• Edit .bashrc/.bash_profile or both

But even though I read all those tutorials none of them really worked for me.

I had several errors while trying to figure out what went wrong while following the tutorials.

First I got some of “mkvirtualenv: command not found”, then a little of “-bash: /usr/bin/virtualenvwrapper.sh: No such file or directory”, and then a touch of “ERROR: virtualenvwrapper could not find virtualenv in your path”.

After some research I realized that all virtualenvwrapper Ubuntu 18.04 tutorials are copies an old text written before April 2016 (the release date of Ubuntu 16.04).

I know this because from Ubuntu 16.04 and onward the location of vritualenvwrapper’s pip installation changed from /usr/local/bin/virtualenvwrapper.sh to ~/.local/bin/virtualenvwrapper.sh. Note that the local directory is hidden.

So I'll start by writing a tutorial that will show you how to avoid all those issues mentioned above.

Prerequisites

In this article I will show you how to set up virtualenvwrapper with pip3 (pip for Python 3). I chosen this version of pip instead of a Python 2 because Pythons 2's end of life was January 1. 2020.

Python 2 will retire in… https://pythonclock.org/

To complete this tutorial you will need a computer with Ubuntu 18.04 installed and an internet connection :). Also some knowledge about terminals and the Vim editor would be useful. I will assume you already updated and upgraded your system.

Setting up a Virtual Environment

Now open your terminal in the home directory by right clicking and choosing the option “Open in Terminal”. You can also press the CTRL, ALT, and T keys on your keyboard at the same time to open the Terminal application automatically.

You first need to create a special directory that will hold all of your virtual environments. So proceed with creating a new hidden directory called virtualenv.

mkdir .virtualenv

Now you should install pip for Python3.

sudo apt install python3-pip

Confirm the pip3 installation.

pip3 --version

Now install virtualenv via pip3.

pip3 install virtualenv

To find where your virtualenv was installed, type:

which virtualenv

Install virtualenvwrapper via pip3:

pip3 install virtualenvwrapper

We are going to modify your .bashrc file by adding a row that will adjust every new virtual environment to use Python 3. We will point virtual environments to the directory we created above (.virtualenv) and we will also point to the locations of the virtualenv and virtualenvwrapper.

Now open the .bashrc file using Vim editor.

vim .bashrc

If you still haven’t used the Vim editor or you don’t have it installed on your computer you should install it now. It is a widely used Linux editor, and for good reason.

sudo apt install vim

After you've installed Vim open the file .bashrc file by typing the vim .bashrc command in your terminal. Navigate to the bottom of the .bashrc file, press the letter i to enter the insert mode of Vim, and add these rows:

#Virtualenvwrapper settings:
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_VIRTUALENV=/home/goran/.local/bin/virtualenv
source ~/.local/bin/virtualenvwrapper.sh

After you are done, press the esc key. Then type :wq and press enter. This command will save and exit the Vim editor. Close and reopen your terminal when you’re done.

To create a virtual environment in Python3 and activate it immediately, use this command in your terminal:

mkvirtualenv name_of_your_env

You should confirm that this environment is set up for Python3:

Python -V

To deactivate the environment use the deactivate command.

deactivate

To list all available virtual environments use the command workon or lsvirtualenv (same result as workon but shown in a fancy way) in your terminal:

workon

lsvirtualenv

To activate one specific environment use workon + name of your environment:

workon name_of_your_env

There are several useful command you might need to use someday:

Rmvirtualenv will remove a specific virtual environment located in your .virtualenv directory.

rmvirtualenv name_of_your_env

Cpvirtualenv will copy the existing virtual environment to a new virtual environment and activate it.

cpvirtualenv old_virtual_env new_virtual_env

Well done! You have now created your first isolated Python 3 environment.

Thank you for reading! Check out more articles like this on my freeCodeCamp profile and other fun stuff I build on my GitHub page.