DEV Community: Krishnakanth Alagiri

Why and How to Use Unattended-Upgrades on a Ubuntu server?

Krishnakanth Alagiri — Thu, 02 Mar 2023 01:51:02 +0000

SysAdmins already have enough on their plate without having to manually update their systems every day!

Why Use Unattended-Upgrades?

Keeping software up-to-date is crucial for security reasons, as updates often include patches for vulnerabilities. However, it can be time-consuming and inconvenient to manually update packages regularly. This is where Unattended-Upgrades comes in.

Unattended-Upgrades is a package for Ubuntu that allows automatic installation of security updates. This means that critical updates are installed without user intervention, reducing the risk of security breaches and keeping your system secure.

How to Install and Configure Unattended-Upgrades

Install the Unattended-Upgrades package by running the following command:
```
sudo apt-get install unattended-upgrades
```

Edit the configuration file /etc/apt/apt.conf.d/50unattended-upgrades to enable automatic security updates. Uncomment the following line:

//Unattended-Upgrade::Allowed-Origins {
//        "${distro_id}:${distro_codename}-security";
//  //      "${distro_id}:${distro_codename}-updates";
//};

So it looks like this:

Unattended-Upgrade::Allowed-Origins {
        "${distro_id}:${distro_codename}-security";
        "${distro_id}:${distro_codename}-updates";
};

This tells Unattended-Upgrades to automatically install updates from the security repository and the main repository.

Enable automatic updates by editing the configuration file /etc/apt/apt.conf.d/20auto-upgrades. Uncomment the following lines:
```
APT::Periodic::Update-Package-Lists "1";
APT::Periodic::Unattended-Upgrade "1";
```
This tells the system to update the package lists and install security updates automatically.
Configure email notifications (optional). By default, Unattended-Upgrades sends an email to root whenever an update is installed. To configure email notifications, edit the configuration file /etc/apt/apt.conf.d/50unattended-upgrades and add the following lines:
```
Unattended-Upgrade::Mail "youremail@example.com";
Unattended-Upgrade::MailOnlyOnError "true";
```
Replace youremail@example.com with your email address.
Restart the Unattended-Upgrades service to apply the changes:
```
sudo systemctl restart unattended-upgrades
```

That's it! Your Ubuntu system is now configured to automatically install security updates. You can rest easy knowing that your system is up-to-date and secure.

Can this makeshift vertical case keep the Pi cool?

Krishnakanth Alagiri — Sat, 30 Oct 2021 11:04:34 +0000

Originally published at thekrishna.in

The Raspberry Pi 4 offers an excellent upgrade to the preceding Pi 3B+, but keeping the new model from overheating can be a challenge. Users have tried many techniques to tackle this issue, from running the Pi in the open air to utilizing cooling rigs with fans attached. But as vertical cases are gaining popularity, can my DIY vertical case keep the Broadcom BCM2711B0 quad-core A72 SOC (system on chip)—cool? Spoiler alert: Surprisingly, yes.

First of all, why subject your Raspberry Pi to this level of stress? In the case of Raspberry Pi 4, the A72 CPU is so powerful that it can overheat if it doesn't have enough cooling. This results in the CPU being thermal throttled (governed) to reduce the power consumption and in turn reducing heat generation. The Raspberry Pi 3B+ and predecessors could also overheat, but this was less of an issue for the majority of use cases. A quick stress test will reveal if the Raspberry Pi 4 can run at maximum CPU-loads in its case/environment without overheating or throttling.

The goal of this post is to create a graph, which depicts:

A stabilization period at the beginning
A period of time for full-load CPU
View the CPU temperature
View the CPU clocks (to witness if the CPU is being thermal throttled, or not)

I searched the Internet for existing methods for stress testing the Pi and stumbled upon Stressberry. The package is straightforward, as their documentation quotes "stressberry is a package for testing the core temperature under different loads, and it produces nice plots which can easily be compared". The room temperature at the time was about 26ºC. The Raspberry Pi is operating at a stock clock speed of 1.5 GHz, since this is more relevant to the wider population

Chart notes:

Blue = Temperature in degrees Celsius
Orange = CPU clock speed (maximum 1500 MHz)

Test 1: Heat Sink, No Fan, Open air, Stock Case with open lids.

Creative visualization (but not inaccurate 😛) of the setup and the performance chart for the stock case setup

Towards the end of 10 minutes under full-load, the CPU was clearly in for trouble.

Test 2: Heat Sink, Fan, Open air, DIY Vertical Case.

Actual setup and the performance chart for the vertical setup

Raspberry Pi — Awesome custom MOTD

Krishnakanth Alagiri — Mon, 18 Jan 2021 20:09:57 +0000

Even though the Raspberry Pi comes with an HDMI port, most projects are headless (runs without a display), which suggests you're mostly using SSH to access the system. I'm bored of seeing the most basic login banner with no information. This login banner is your MOTD (Message of the day, Linux term). My goal here was to have something that could quickly inform me about the machine's information I was using and knowledge of the current state. It should also be as brief as it is practical, and importantly be fast to execute.

The programs included with the Debian GNU/Linux systems are free software; The exact distribution terms for each program are described in the individual files in /usr/share/doc/*/copyright 

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent permitted by applicable Iaw.

How to do it?

Remove the default MOTD. It is located in /etc/motd.

# Remove the folder
sudo rm /etc/motd

Open /home/<user>/.bash_profile if you're using Raspberry Pi OS (aka. Raspbian). You can edit this file however to match your needs.
First you need to edit your profile:

# mostly, the user is "Pi"
sudo nano /home/pi/.bash_profile

Then just past in the code below, anywhere within that file:

clear 
echo "$(tput bold)$(tput setaf 2)"
echo "    .~~.   .~~.  "
echo "   '. \ ' ' / .' "
echo "$(tput setaf 1)"
echo "    .~ .~~~..~.   "
echo "   : .~.'~'.~. :  "  
echo "  ~ (   ) (   ) ~ "  
echo " ( : '~'.~.'~' : )"    
echo "  ~ .~ (   ) ~. ~ "  
echo "   (  : '~' :  )  "  
echo "    '~ .~~~. ~'   "
echo "        '~'      "
let upSeconds="$(/usr/bin/cut -d. -f1 /proc/uptime)"
let secs=$((${upSeconds}%60))
let mins=$((${upSeconds}/60%60))
let hours=$((${upSeconds}/3600%24))
let days=$((${upSeconds}/86400))
UPTIME=`printf "%d days, %02dh%02dm%02ds" "$days" "$hours" "$mins" "$secs"`

# get the load averages
read one five fifteen rest < /proc/loadavg

echo "$(tput setaf 2)
`date +"%A, %e %B %Y, %r"`
`uname -srmo`

$(tput sgr0)- Uptime.............: ${UPTIME}
$(tput sgr0)- Memory.............: `free | grep Mem | awk '{print $3/1024}'` MB (Used) / `cat /proc/meminfo | grep MemTotal | awk {'print $2/1024'}` MB (Total)
$(tput sgr0)- Load Averages......: ${one}, ${five}, ${fifteen} (1, 5, 15 min)
$(tput sgr0)- Running Processes..: `ps ax | wc -l | tr -d " "`
$(tput sgr0)- IP Addresses.......: `hostname -I | /usr/bin/cut -d " " -f 1` and `wget -q -O - http://icanhazip.com/ | tail`

$(tput sgr0)"

Restart the sshd service:

# Restart the sshd service via systemctl command
sudo systemctl restart sshd

This is how it looks

Add-ons

You could additionally edit the the above script to take advantages of packages such as neofetch and figlet to make attractive and informative MOTDs.

Using Neofetch

Neofetch is a command-line system information utility written in Bash. It prints the information of your system's software and hardware in the Terminal. By default, the system information will be displayed alongside your operating system's logo in ASCII.

Using Figlet

FIGlet is a program that generates text banners, in a variety of typefaces, with letters made up of combinations of smaller ASCII characters. So you can use the figlet command to turn regular terminal text into a huge fancy test, like this:

Understanding our future with 5G

Krishnakanth Alagiri — Mon, 18 Jan 2021 19:56:46 +0000

Originally published at thekrishna.in on July 5, 2020

As the long-term evolution (LTE) system embracing 4G is reaching maturity, it is reasonable for humanity to ponder “what’s next?”

We all know that 5G is a paradigm shift from 4G with very high carrier frequencies, massive bandwidths, a tremendous amount of base station and device densities, and unprecedented numbers of antennas. But unlike the past four generations, it will be highly integrative by binding any new 5G air interface and spectrum together with LTE and WiFi to give universal high-rate coverage and seamless user experience. This is going to lead a new wave of wireless data explosion driven largely by smart-phones, tablets, and other wireless devices.

What makes 5G demanding?

In just a decade, the number of IP data handled by wireless networks has grown by well over a factor of 100, from under 3 exabytes in 2010 to over 190 exabytes by 2018 and is on pace to surpass 500 exabytes by the end of 2020. In addition to the sheer volume of data, the number of devices and the data rates will always continue to grow exponentially. The number of devices could reach tens or even hundreds of billions by the time 5G is fully matured, due to many new applications beyond personal communications such as Cloud gaming and Video streaming. So let us jot down the top two reasons why we need 5G in the first place?

1. Data Rate

The need to support the mobile data traffic explosion is undoubtedly the main driver behind 5G. The primary parameters of Data Rates on which 5G networks can be judged are Aggregate data rate (total amount of data the network can serve), Edge rate (worst case data rate per user), and Peak rate (best case data rate per user).

2. Latency

The Current 4G roundtrip latencies are on the order of about 15 ms. Although this latency is sufficient for most current services, anticipated 5G cloud-based applications such as Google Stadia - Cloud Gaming platform will require seemingly real-time feedback loops. Therefore, 5G should support a round trip latency of about 1 ms, an order of magnitude faster than 4G.

How does 5G solve the problem?

In addition to the highly visible need for more network capacity, several other factors make 5G interesting, including the potentially disruptive “big three” 5G technologies: ultra-densification, mmWave, and massive multiple-input multiple-output (MIMO). Let's take a quick look at them.

A quick look at Ultra Densification

Put differently, more active nodes per unit area and Hz.

In simple terms, a 5G network will aim to provide high system capacity with high per-user data rates. So this will require a lot of the radio access network or the deployment of additional network nodes to come together.

Source: CSIRO: Simulations of Ultra-dense small cell networks

This is how it works,

By increasing the number of cells, the traffic per square-meter will be increased without an increase in the traffic per network node.
Thereby, by increasing the number of network nodes, the base-station-to-terminal distances will be shorter.
Due to shorter base-station-to-terminal distances, there will be an improvement in achievable data rates.

To make this system of networks possible requires a fair bit of densification.

A quick look at mmWave

Altogether, more Hz

The term mmWave regards to a particular part of the radio frequency spectrum between 24GHz and 100GHz, with a very short wavelength. This section of the spectrum is usually unused, so the mmWave technology intends to increase the amount of bandwidth accessible. Plus, the lower frequencies are heavily congested with signals from TV, Radios, and even the 4G LTE networks, which sit within 800 and 3,000MHz. Another advantage of this short wavelength is that it can t*ransfer data even faster at the expense of transfer distance* (ie., more transfer speed, less range).

Source: Qualcomm

A Quick look into massive MIMO

To support more bits/s/Hz per node

Multiple Input Multiple Output (MIMO) has been used in wireless communications for a long time now where nearly all our devices have multiple antennas to enhance connectivity and performance. MIMO algorithms control how data maps into antennas and where to focus energy in space. Both network and mobile devices must have tight coordination within each other to make MIMO work.

In simple words, MIMO is how Devices and Network work together.

But with how the upcoming 5G NR is designed, it is necessary for a substantially large number of networks and devices to work with tight coordination. So MIMO becomes “massive” and is called Massive MIMO. The “massive” number of antennas improves focusing energy, which causes radical improvements in throughput and efficiency. Along with the increased number of antennas, both the network and mobile devices achieve more complex designs to regulate MIMO operations.

A Glimpse into the Possiblities

The way I see 5G network is to be an accelerator for technologies that already exist with us. There are endless possibilities with the dense and fast-pacing 5G wireless networks. So let's look at some of my favorite picks.

Edge Computing

Edge computing is a method of optimizing cloud computing systems by performing data processing at the edge of the network or near the source of the data. Imagine you ordering a pizza from your beloved restaurant, but your neighbor cooks and delivers it for you. This means faster delivery. Edge computing is very similar to that.

So 5G standards are the only way to meet the latency targets that have been set (1ms network latency) to achieve the realistic usage of Edge Computing. Improvements in the radio interface alone will never achieve these. With a well-mature 5G in the game of computing, the abundance of unused resources in wireless devices or IoTs can significantly drop the cost of compute units than traditional cloud providers.

Autonomous Driving

The use of 5G wireless networks can bring Self-driving cars closer to reality. The key ingredient currently missing from Autonomous vehicles is High-performance wireless network connectivity for low latency.

The will enable Vehicle-to-Everything (V2X) in the future, making cars communicate with everything from traffic signs, environmental objects, to other vehicles on the road. The original V2X standard is based on a IEEE 802.11p Wi-Fi offshoot. So when coupled with a network like 5G, it will drastically reduce latencies and decrease an AVs response time. Thus ensuring passenger safety.

A Visualization of Vehicle-to-Everything (V2X) standard

Internet of Things (IoT)

Internet of Things (IoT) is another extensive field for development using a supercharged 5G wireless network. IoTs are already all around us from wrist-bands to our cars collecting huge amounts of data from millions of devices and sensors. Crucial IoT real-time processes such as data collection, processing, transmission, control, and analytics can be accelerated by an efficient network.

Drone and Security Operation

The number of operative drones is foreseen to grow over 18.1 million in 2025, driving flight authorities, and society to explore solutions to overview all drone users and the traffic. Rapid technology progresses on the propulsions, sensors, and navigation and guidance systems led to reliable drone platforms. Consequently, drones must acquire data in real-time. With the need to overcome current RF limitations for increasing flight endurances, size of data sets and video streaming capabilities, alternative control capabilities, 5G wireless networks are required.

Amazon delivers packages to customers using drones

Acknowledgments

J. G. Andrews et al., "What Will 5G Be?," in IEEE Journal on Selected Areas in Communications, vol. 32, no. 6, pp. 1065-1082, June 2014, doi: 10.1109/JSAC.2014.2328098.
X. Ge, S. Tu, G. Mao, C. Wang and T. Han, "5G Ultra-Dense Cellular Networks," in IEEE Wireless Communications, vol. 23, no. 1, pp. 72-79, February 2016, doi: 10.1109/MWC.2016.7422408.

Scaling with Nginx; Cost-Performance analysis

Krishnakanth Alagiri — Mon, 18 Jan 2021 13:38:15 +0000

Originally published on thekrishna.in

When you realize your system is getting slow and is unable to handle the current number of requests even with optimizations, you need to scale the system sooner than you can optimize further. Building a scalable system also drives to a lower Total Cost of Ownership (TCO). Proper scaling in process-intensive applications embraces interesting new scenarios, notably in data analytics and machine learning. Traditionally, you have two options, Horizontal scaling, and Vertical scaling.

Pokémon Go - A Successful Scaling Story

If you downloaded the Pokémon GO app right at its launch, you might have faced several issues on server unavailability for some minutes. Based on the hype around the announcement of Pokémon GO, one might have already presumed what chaos was going on in the backend infrastructure. Pokémon Go engineers never imagined their user base would grow exponentially, exceeding the expectations within a short time. With 500+ million downloads and 20+ million daily active users, the actual traffic was 50 times more than their initial expected traffic.

This makes Pokémon GO, one of the most exciting examples of container-based development and scaling in the wild. The logic for the game runs on Google Container Engine (GKE) powered by Kubernetes. Niantic picked GKE for its capability to orchestrate their container cluster at large-scale, saving its focus on deploying live changes for their players. So by provisioning tens of thousands of cores for Niantic’s Container Engine cluster, the game brought joy into all the Pokémon Trainers around the globe.

What is Horizontal scaling?

Horizontal scaling implies that you scale a cluster by attaching more machines or nodes into your pool of resources. Scaling horizontally is like thousands of minions will do the work together for you. Increasing the number of servers present in a system is the highly used solution is in the tech industry. This will eventually decrease the load in each node while providing redundancy and flexibility, thus reducing the risks of downtimes. If you need to scale the system, just add another server, and you are done.

What is Vertical scaling

Vertical scaling means that you scale by adding horsepower to an existing machine. Scaling vertically is like one big hulk will do all the work for you. You increase the resources in the server which you are using currently (increase the amount of RAM, CPU, GPU, and other resources). A horizontally scaled app will provide the benefit of elasticity. Vertical scaling is expensive than horizontal scaling and may require your machine to be brought down for a moment when the process takes place.

I've explained in brief about nginx and how to run it using docker in my previous post

Getting Started

As developers, we do not always have access to a production-like environment to test new features and run proofs-of-concept. This is why it can be interesting to deploy containers for such an experiment. For this little experiment, our host machine (part of my home-lab setup) comes with a 4-core Intel i5-4200M (base speed of 2.5 GHz) and dedicated 6GB DDR3 SDRAM.

Now the client uses the ab - Apache HTTP server benchmarking tool. For ensuring connection stability and integrity, both our host machine and our client will be connected via Ethernet on an isolated network. The cost is determined based on their highest on-demand value based on AWS-EC2 and Sherweb pricing with a fixed storage and network bandwidth.

Diving into Action

We'll be requesting the below HTML document from our Nginx server. As you can see here, there are no references to increase unnecessary load times. The HTML Document Length is 1328 bytes, and our server is running nginx/1.19.0.

Initial Benchmark

Our initial benchmark is on a single docker container with 4MB memory, and 0.1 CPU cores. Docker can allocate partial CPU cores by adjusting the CPU CFS scheduler period, and imposing a CPU CFS quota on the container. To kick things up a notch, I used 10000 requests with 1000 concurrencies.

# ab -n <num_requests> -c <concurrency> <addr>:<port><path>
ab -n 10000 -c 1000 http://192.168.1.16/index.html

Observations

It took the server about 31.462 seconds to transfer 14.89 MB (15620000 bytes)
Fastest request was served at 50ms and slowest at 20796ms.
This request time was high due to high concurrency and wasn't the same case when concurrency is 1000 and below.

Vertical Scaling

Like above, our benchmarking parameters are 10,000 requests with a concurrency of 1000 .

Tabulated Result

#	CPU Cores	Memory (MB)	Time Taken (s)	Request Per Second	Transfer rate (KBps)	Min. Serve Time (ms)	Max. Serve Time (ms)	Time per request (ms)	Estimated Monthly Cost (USD)
A	0.1	2	64.614	154.77	234.1	47	64,537	6.461	0.51
B	0.3	6	50.657	196.42	289.17	47	35,162	5.091	2.02
C	0.5	10	39.327	254.28	376.24	49	33,404	4.133	3.36
D	0.7	14	35.985	277.89	412.15	42	31,926	3.599	4.72
E	1	20	29.238	338.19	505.88	51	29,189	2.957	6.81

Horizontal Scaling

Like above, our benchmarking parameters are 10,000 requests with 1000 concurrencies. Each instance would have 0.1vCPU and 2MB of Memory and are deployed using Nginx Ingress Controller in a Minikube cluster.

Tabulated Result

#	Number of Instances	Time Taken (s)	Request Per Second	Transfer rate (KBps)	Min. Time to Serve (ms)	Max. Time to Serve (ms)	Time per request (ms)	Estimated Monthly Cost (USD)
A	1	64.614	154.77	234.1	47	64537	6.461	$0.51
B	3	46.802	212.42	317.54	45	24473	4.701	$1.53
C	5	34.334	284.28	403.43	43	23249	3.817	$2.55
D	7	30.247	311.89	461.11	44	22220	3.324	$3.57
E	10	24.013	437.19	551.25	49	20316	2.731	$5.10

Final Result: Vertical Scaling v/s Horizontal Scaling

Observations

The overall performance degrades if the increase in CPU cores allocated was not proportional to the memory allocated. This is because the data must be read from the disk instead of directly from the data cache, causing a memory bottleneck.
The vice-versa can also happen and is termed as CPU-Bottlenecks which causes a chronically high CPU utilization rate.
On Vertical Scaling, Our test roughly stabilized after 1 CPU core and 32 MB of memory. This signifies that more than the required resources will not result in a performance boost, but will only increase our cost of the deployment.

Conclusion

From the above, we understood the following:

Horizontal Scaling provides a faster delivery than vertical scaling due to their lower average request time.
In terms of responsiveness, Horizontal Scaling provides better performance due to the distribution of server loads among available nodes.
Horizontal scaling prevents you from getting caught in a resource deficit.
Horizontal Scaling is more cost-effective than vertical scaling.

But this doesn't mean all applications would qualify for absolute horizontal scaling. If your applications demand a greater horsepower to perform as expected or quicker, you might want to consider vertical scaling. In other words, you might want each of your thousands of minions as powerful as a hulk, so they are suitable for other intensive tasks. But for accurate lower Total Cost of Ownership (TCO), Auto Scaling is the solution. Here, servers dynamically scale to secure steady, predictable performance at the lowest possible cost.

Flatpak vs Snaps vs AppImage vs Packages - Linux packaging formats compared

Krishnakanth Alagiri — Mon, 18 Jan 2021 12:45:12 +0000

Originally Published in thekrishna.in on Jun 27, 2020

Linux often gets a bad reputation when it comes to installing software, and this is because we have so many different application distribution formats. Most of them also are misunderstood, or have preconceived notions attached to them, so I think it’s time to take a look at the differences among the different packaging formats!

DEB and RPM Packages

The two most popular package formats are the DEB and RPM. Debian and derivative distros like Ubuntu use Debs, while Fedora, Red Hat, and OpenSUSE use RPMs. You can pull the Packages from their distribution’s repositories or installed them. They contain a pre-compiled or a binary version of the application or library you’re trying to install for your system’s architecture.

These packages come with a descriptive file with all the various libraries and other applications your program needs to run.

Since the DEB and RPM packages are pre-compiled for your architecture, they're quicker to install. They pull all your dependencies immediately if they’re available. Since these packages are distro-specific, developers need to package their app for various distros, versions, and architectures.

Flatpaks

The Flatpak format is here to fix these problems. While Flatpaks come as binaries, so no compilation needed, they embark on all the libraries required in the package. They can use shared libraries provided in other Flatpaks.

Flatpaks are quick to install from repositories called remotes. The largest available repository is Flathub, which sources the most available Flatpak applications. They also provides an interface for granting and revoking permissions.

Flatpaks may introduce security issues: while Flatpaks sandboxes itself, they still can provide outdated libraries and can consume larger storage than their DEB and RPM relatives. Flatpaks can run on any distro that has the flatpak package installed and most distro’s software centers have added the flathub remote.

Snaps

Snaps have an interesting difference though: they can also ship server stuff. While Flatpaks focuses on graphical applications, snaps can contain pure command line packages. Another difference is that Snaps can be automatically updated without user intervention and can receive delta updates.

Snaps can also revert to the previous version. Snaps do have some problems though: first, they don’t make use of the system theme. Second, they can’t use external repositories: all snaps come through snapcraft, which is the “official” distribution center for these. Snaps also tend to be bigger, and slower to launch than Flatpaks or regular packages. Snaps can run on any distro that has access to snapd, the backend part of snaps.

AppImages

AppImages are yet another way to distribute applications in a single contained package. They use the “one app one file” method: AppImage ships all the files needed, and all the libraries as well, in a single file. An AppImage app is a single executable file (similar to Windows .exe files). They are not downloaded from a repo, but there is AppImage hub, a website that lists most if not all the available AppImages. AppImage has lowest app size footprint compared to Snaps and Flatpaks, most probably because it serves binaries in compressed format.

You can immediately start using them once they're downloaded, regardless of the path on the system. No need to install runtimes, or shared components like Snaps or Flatpaks, you can put your AppImages anywhere and run it. This means that AppImages are super portable: to keep all your apps, you can copy/paste the AppImages and you’re good to go. This a big advantage, but there are some issues there as well. First, you can’t update an AppImages without downloading the new version yourself, much like apps on windows.

AppImages also don’t respect the system’s theme at all and can get pretty big, since they don’t make use of share runtimes at all. AppImages can run on any distro, they don’t need any specific plumbing to work. Recently, AppImage developers provided a tool to update existing binaries by providing delta updates. However, it still requires downloading the update tool and manually using it with an existing AppImage binary. There is no hands-free update mechanism available for AppImage yet. They also don’t support granular permission controls.

GNOME vs KDE Plasma

Krishnakanth Alagiri — Sun, 17 Jan 2021 20:52:25 +0000

Originally published at thekrishna.in on Sep 29, 2020

Both default setups of KDE and GNOME are simply legible. Plasma looks like what you'd expect if you're coming from Windows, with its bottom panel, menu, and task manager, and the defaults are clean and simple, rather welcoming for a new user.

GNOME, on the other hand, is the precise opposite approach: the default metaphor is the opposite of what you're used to, with no active task management, no desktop icons, no application menu, no dock or taskbar. Activities are a good concept, easy to learn, but it goes against most other desktops I've used, so I took a while to get used to switching windows through the activities or the keyboard.

Configuration

Plasma has an overabundance of options, plasmoids, layouts and panels, and as many configuration options as you want. You can tweak colours, themes, window borders and controls, and even the position of panels and toolbars on most applications, to get to the desktop and layout you want to use. You can't fault KDE on customization and it is the most configurable desktop environment I've ever used on any OS.

GNOME, by default, has almost zero configuration. However, you can tweak quite a few things through extensions and GNOME Tweaks, but these come with a convoluted installation process: look for GNOME Tweaks, install it, then install extensions, and the browser add-on, and the host connector, then manage extensions through GNOME Tweaks, where you find their own set of preferences. I appreciate the logic of offering a very clean and simple default desktop, but enabling extensions in one-click, with all the browser extensions and host connector configured, or providing an "extension store" directly from GNOME Software would be far easier, and would not clutter the interface whatsoever.

Look and Feel

The default look of KDE is pleasing, with bright icons, nice gradients and shadows, and smooth animations switching from a menu to another, dragging windows around, and generally while using the system. The default theme, Breeze, looks good on plasmoids and application widgets, and it offers a dark mode by default if you prefer that. Plasma looks modern and polished, and it feels natural to use, with each element fading in and out.

GNOME, on the other hand, comes with Adwaita. It is a big theme: there is a lot of padding around buttons, menus, and everything looks quite big. Icons are a bit dated in my opinion, with muted colours. Adwaita is usually plain and minimalistic to me, although it is very functional and legible, with nothing catching your eye specifically, letting you focus on your work.

Applications

As per applications, it's a tough one: GNOME seems to have a lot more applications available by default, compared to KDE, but GNOME applications are severely lacking in features.

KDE Plasma has very stable applications, but little choice: since most applications do everything and are extremely configurable, there is little incentive to work on a new project instead of contributing to an existing one. Default applications can sometimes look dated, without place buttons or widgets and convoluted interfaces. They are powerful, though, and do not lack important features. Once you get familiar with a KDE application, you can pretty much do anything you like.

GNOME, on the other hand, has a nice choice of different applications, but they have issues. Photos are too simple, Music crashed a lot, and Contacts didn't support contact groups. One problem is desktop consistency: since GNOME does away with menu bars, once you install something that does not strictly adhere to GNOME guidelines, it quickly looks out of place and behaves differently.

Performance

In terms of performance, KDE Plasma has quick and smooth animations for panels and menus and uses fewer RAM compared to GNOME. Applications open promptly, and stay snappy, even under load. GNOME also behaves nicely by default, but it usually uses more RAM and CPU. If you have a lower spec system, GNOME might not be the right choice for you.

In the end, I genuinely liked both. In terms of Look and feel, KDE matches my tastes more closely since I came from a Windows Ecosystem, but GNOME's interface and interface guidelines appeal to the minimalist in me. In fact, I daily drive the GNOME from Pop!_OS and the minimalism helps me focus on whatever I'm up to. You can find out why I love Pop!_OS here

Why I switched to Pop_OS?

Krishnakanth Alagiri — Sat, 16 Jan 2021 11:53:36 +0000

Originally published at thekrishna.in

As of 2020, Windows is still the dominant desktop OS comprising nearly 90% of it's demographic and I was in it for over 14 years. It was initially fast but as time progressed, the Windows updates stacked up along with previously installed softwares. Adding gasoline to the fire, Windows decided to bake advertisements and even more telementary services right into the operating system.

Then one day, I wanted to print a theatre ticket in a rush and turned on my computer only to see...

Now I finally chose to migrate to Linux and after careful experimentations with various distros and DEs, I came across Pop!_OS by System76 and loved it straight out of the box.

So why do I have so much love for a Ubuntu based distribution? Well, let me explain.

1. Linux is free and that's a great price!

This is true not only for the operating system and the kernel but also for all the software that comes bundled with it. Also in most cases, there will be an open-source alternative for any paid application in Windows like the LibreOffice Suite instead of Microsoft Office.

2. Pop!_OS is beautiful and functional.

Now to the fun part. Pop!_OS is undoubtedly one of the best-looking desktop environments I have ever used. I would suppose it is tied with Elementary OS, Deepin and Budgie DE. While it's Gnome desktop environment, has its fair share of criticisms, it does hold true to its values of getting out of your way to get work done.

GNOME has no active task management, no desktop icons, no application menu, no dock or taskbar. Activities are an easy concept but coming from Windows, I took a while to get used to switching windows through the activities or the keyboard.

However, if the default design and working are not up to your fondness, then you can customize and tweak it however you want using the GNOME Tweak Tool. You can even make it to look and behave like macOS or Windows complete with a start menu.

As far as functionality goes, if you are used to GNOME then you will feel at home in Pop!_OS. You boot straight to your desktop, and the system tray is pretty minimal by default helping you focus on whatever you're onto.

Automatic Window Tiling

As of Pop!_OS 20.04, it has released an automatic window tiling manager. This enables you to tile and arranges all open windows at the click of a button which is remarkably helpful when multitasking.

Pop!_OS makes life easier for Developers.

Pop!_OS can do everything Ubuntu can do. But its dedicated tools, attractive looks, and refined work flow provide a smooth Development. It supports tons of programming languages and useful programming tools natively. Nvidia drivers with CUDA support comes preinstalled which enables developers to speed up compute-intensive applications.

There are features like the New Keyboard shortcuts, Increased Compatibility, New App launcher and even more that you shoud take a look at. Overall, The Pop!_OS is smooth, functional, and melts right into the background just as it was intended to.

3. Pop!_Store has Everything.

Pop!_Shop is a software store for Pop!_OS as to Play Store is for Android. Here, you can search and install any package with just a click of a button. To add more power to the store, Pop 20.04 brings Flatpak support to Pop Shop. This implies that if you want to download any application, you can now also pull packages from the Flathub repository along with Pop!_OS and Ubuntu repo.

Flatpak/Flathub is a widely recognised universal package management tool and store that contains a number of applications. You can learn more about Flatpaks in my previous post. Hence, you now have access to more packaged applications with high privacy.

4. The "Nvidia Driver" Situation.

Nearly all major Linux distributions have come a long way in the past 2 years in making the proprietary Nvidia driver available to their users. Here again, there’s a subtle yet a functional difference in the way Pop!_OS handles Nvidia drivers compared to its alternatives that hybrid graphics laptop users like me would especially appreciate.

When you download the Nvidia version of the Pop!_OS ISO, the Nvidia graphics driver is active during the OS installation process, not merely “available” to install. That means no risk of perplexing black screens which is more common with the open-source “Nouveau” driver for Nvidia hardware.

Hybrid Graphics

Pop!_OS supports hybrid graphics straight out of the box. It includes the system76-power package, which includes the ability to switch between integrated, NVIDIA, and hybrid graphics modes.
This means once you launch your application in Hybrid Graphics mode with a dedicated Graphics card, your laptop runs on the battery-saving Intel GPU and only uses the NVIDIA GPU for applications running.

5. Privacy, Control and Support

Privacy and Security

While no operating system is absolutely risk-free, Windows is a big target for viruses and malware due to its majority market share. With Linux as a whole, you only need to be smart, stick to trusted software repositories, and avoid using risky programs such as Adobe Flash or free_ram.sh. Linux is more secure than Windows primarily because of the way it's designed and handles user permissions. This is one reason why most of the web runs on Linux. Since most packages you install would be open-source, their codebase is public and would have been reviewed by more developers for bugs and security vulnerabilities.

Speaking of security, Pop!_OS is so far the only Linux distribution that enables pre-installed full-disk encryption out of the box. Moreover, you can use the ‘Refresh install’ feature to reset your operating system while preserving the files in your Home folder.
Windows chooses when to install updates, and it displays a message declaring that your computer is going to be rebooted. While with most linux distros, you get to decide when those updates are installed, and in most cases, the updates are installed without rebooting the system.

Control

Compared to Windows or macOS, Linux support is easier to find, and there are dozens of forums, subreddits, chat rooms, and even more websites committed to helping people receive and understand Linux. Unlike Microsoft support, which is mostly from an employee, Linux support usually comes from enthusiasts and developers.

Every single part of your Distribution can be adjusted if you have the time, will and support. KDE Fan? Remove GNOME from Pop!_OS and install KDE Instead. System services slowing your boot? Disable and mask them. In fact, you can even write your own scripts and packages if you have the time and effort.

Personal Recommendations

1. Install rEFInd Boot Manager

Visit rEFInd Documentation for Installation and theming instructions

If you're Dual Booting Windows and Pop!_OS, I highly recommend you to use rEFInd Boot Manager instead/on-top of the systemd-bootloader. I had to manually adjust both GRUB and systemd-boot configurations every time Windows had a major update, while rEFInd scans for kernels on every boot and is more adaptive and is less reliant on configuration files. Plus rEFInd has more eye candy.

2. Bridging gaps between OSes in a system

2.1 Why didn't I delete Windows for good?

Despite Linux growing better every day, there are still a lot of programs, softwares and hardware that are exclusively made for Windows due to majority market share and the open-source alternatives are not essentially good enough. Adobe Photoshop, Microsoft Office and Epic Games Stores are a great example of it.

2.2 Create a common partition

If you're dual-booting Windows and any other Linux Distibution(s), I strongly advice to turn off Fast Startup in Windows as they make all accessible filesystem read-only in Linux until you fully shut down you Windows. Create an extra NTFS partition for all your OSes to coexist and share common files peacefully.

2.3 Install WINE and create a Windows Virtual Machine

Not every Windows Program has it's equal Open-Source Linux Alternative so if you're lucky (or savvy) enough, your program might run using Wine on Linux. You can check your application's compatibility on Wine here. Platforms like Lutris can even install and launch games so you can start playing without the hassle of setting up your games with Wine Linux powered machine. If you can't find your program on the database, give it a shot.

Popular programs like Microsoft Office still doesn't have great compatibility with Wine. So if Wine doesn't work for your program, create a small Windows Virtual Machine and run on it. I created mine using VirtualBox and Windows 10 Development Virtual Machines provided by Microsoft. However, power-demanding programs like Adobe Photoshop still don't perform well on Virtual Machines and here's is where you have no other option than to boot into your Windows Host.

Docker Apps and Images for everyone

Krishnakanth Alagiri — Sat, 16 Jan 2021 11:19:03 +0000

Originally published at thekrishna.in

Wait, What is Docker?

Have you ever worried about software running in your machine but not in other systems? Docker is the solution. Docker sandboxes applications running within as containers so that their execution is completely isolated from others. This has become enormously popular over the last few years, but to capitalize on it, you need to integrate third-party images.

What is a Container Image?

A Docker container image is a standalone bundle of executable packages and software to run an application. An image is a dormant and immutable file with a set of layers that essentially acts as a snapshot of a container. Docker’s public registry is usually your central source for container apps.

What are Containers?

A container is an efficient little environment that encapsulates up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. In simple words, an instance of an image is called a container. Container images become containers only from their runtime on Docker Engine.

Docker Management

1. Portainer

Portainer is a management UI that enables you to manage your different Docker environments (Docker hosts or Swarm clusters). Portainer is easy to deploy and has a surprisingly intuitive user interface for how functional it is. It has one container which will run on any Docker engine (whether it's deployed as a Linux container or a Windows native container). Portainer allows you to control all of your Docker resources (containers, images, volumes, networks, etc.) it is compatible with both the standalone Docker engine and with Docker Swarm mode.

Installing Portainer

# create a Docker volume portainer_data
docker volume create portainer_data 
# create a Portainer Docker container
docker run --restart=always --name "portainer" -d -p 9000:9000 \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data portainer/portainer

Advertisement and Internet Tracker Blocking Application

2. PiHole

Pi-hole is a must-have for everyone whether you're a hardcore gamer, developer, or just couch potato. It is a Linux network-level advertisement and tracker blocker that acts as a DNS sinkhole (supplies systems looking for DNS information with false returns). It is designed for single-board computers with network capability, such as the Raspberry Pi. Even If your router does not support changing the DNS server, you can use Pi-hole's built-in DHCP server. The optional web interface dashboard allows you to view stats, change settings, and configure your Pi-hole.

Unlike traditional advertisement blockers where only a user's browser ads are removed, this functions similarly to a network firewall. This means that advertisements and tracking domains are blocked for all devices behind it. Since it acts as a network-wide DNS resolver, it can even block advertisements in unconventional places, such as smart TVs and mobile advertisements.

Installation

docker run -d \
    --name pihole -p 53:53/tcp -p 53:53/udp \
    -p 80:80 -p 443:443 -e TZ="America/Chicago" \
    -v "$(pwd)/etc-pihole/:/etc/pihole/" \
    -v "$(pwd)/etc-dnsmasq.d/:/etc/dnsmasq.d/" \
    --dns=127.0.0.1 --dns=1.1.1.1 \
    --restart=unless-stopped --hostname pi.hole \
    -e VIRTUAL_HOST="pi.hole" -e PROXY_LOCATION="pi.hole" \
    -e ServerIP="127.0.0.1" pihole/pihole:latest

Why do I love it?

Every day browsing is accelerated by caching DNS queries.
Everyone and everything in your network are protected against advertisements and trackers.
It comes with a beautiful responsive Web Interface dashboard to view and manage your Pi-hole.

Execution Environments

3. TensorFlow with Jupyter Images

The Tensorflow Docker image is based on Ubuntu and comes preinstalled with python3, python-pip, a Jupyter Notebook Server, and other standard python packages. Within the container, you can start a python terminal session or use Jupyter Notebooks and use packages like PyTorch, TensorFlow.

# For other variants, visit the link above 
# Use the latest TensorFlow with Jupyter CPU-only image
docker run --name jupyter-cpu -h "jupyter-server" \
    -p 8888:8888 tensorflow/tensorflow:nightly-py3-jupyter

# Use the latest TensorFlow with Jupyter GPU image
docker run --gpus all --name jupyter-cuda -h "jupyter-server" \
    -p 8888:8888 tensorflow/tensorflow:latest-jupyter

For those who want to use a GPU, Docker is the easiest way to enable GPU support on Linux since only the NVIDIA GPU driver is required on the host machine. For CUDA support, make sure you have installed the NVIDIA driver and Docker 19.03+ for your Linux distribution. For more information on CUDA support on Docker, visit NVIDIA Container Toolkit

As you can see above, I'm using a 10.2 CUDA driver for my GeForce MX150 with a total GDDR5 memory of 2GB. Although it's an entry-level graphics card, it's at least 450% faster than my CPU (i5-8520U), which makes training your machine learning models much quicker.

Why I prefer it over platforms like Google Colab?

You have to install all python libraries which do not come built-in with Google Colab and must repeat this with every session.
Google Drive is usually your primary Storage with 15 GB Free space. While you can use local, it'll eat your bandwidth for bigger datasets.
If you have access to a modest GPU, it's just a matter of time to install a CUDA enabled driver and deploy your personal Jupyter server with GPU support. With proper port forwarding and Dynamic DNS, you can also share your GPU with your friends as I do.
The free tier of Google Colab comes with much lesser runtime and memory than their pro version. Therefore, you could suffer from unexpected termination and even data loss.

What more I like about it?

Based on Ubuntu so you install any additional Linux packages that you need in ease using apt package manager.
Out of the box support for CUDA enabled GPU.

4. CoCalc

In my opinion, CoCalc is definitely one of the underrated Jupyter notebook servers out there. Although it is intended for computational mathematics, it is essentially Jupyter notebooks on steroids. Your notebook adventure is enhanced with real-time synchronization for collaboration and a history recorder. Additionally, there is also a full LaTeX editor, Terminal with support for Multiple Panes, and much more.

Running the container

# If you're using Linux containers
docker run --name=cocalc -d -v ~/cocalc:/projects -p 443:443 sagemathinc/cocalc

# If you're using Windows, make a docker volume and use that for storage
docker volume create cocalc-volume
docker run --name=cocalc -d -v cocalc-volume:/projects -p 443:443 sagemathinc/cocalc

Image Credits to CoCalc

What do I like about it?

Multiple users can simultaneously edit the same file, thus enabling real-time collaboration. It also comes with side-by-side chat for each Jupyter notebook.
Realtime CPU and memory monitoring.
Comes with a LaTeX Editor and many pre-installed kernels (R, Sage, Python 3, etc).

What I dislike about it?

Unlike the TensorFlow with Jupyter Image, this does not come with complete CUDA support out of the box.
The full image size is a whopping 11GB+ and is a full Linux environment with nearly 9,500 packages, so you better free up your storage before pulling this image.
(Opinionated) The interface is quite different from the traditional Jupyter notebook interface, adding a little bit of learning curve.

Base Images

Wait, what's a base image?

A base image (not to be confused with parent image) is the parent-less image that your image is fundamentally based on. It is created using a Dockerfile with the FROM scratch directive. Docker image must include an entire root filesystem and the core OS installation, so choosing the right base image essentially determines factors such as the size of your container image, packages it inherits.

5. Alpine

If you've built Docker images, you know Alpine Linux. Alpine Linux is a Linux distro mostly built around musl libc (a standard library intended for OSes based on the Linux kernel) and BusyBox (provides several Unix utilities). The image is just around 5 MB in size and even has access to a package repository, which is much more complete than any other BusyBox based images while being super light. This is why I love Alpine Linux, and I use it for services and even production applications. As you can look below, the image comes with only 18 Packages and has a lower memory utilization than ubuntu. The image comes with a apk package manager.

Running the container

# For other tags, visit https://hub.docker.com/_/alpine/
# Copy-paste to pull this image
docker pull alpine:latest

6. Ubuntu

Ubuntu is undoubtedly the most popular Linux distro and exceptionally known for its accessibility and compatibility. It is a Debian-based Linux distro that runs on practically everything (from the desktop to the cloud, to all your IoTs). The ubuntu tag points to the "latest LTS" image as that's the version prescribed for general use. As you can see below, the image comes with only 89 Packages and has an apt package manager.

Running the container

# For other supported tags, visit https://hub.docker.com/_/ubuntu/
# Copy-paste to pull this image
docker pull ubuntu:latest

Database Systems

7. MySQL + PHPMyAdmin

MySQL is undoubtedly the most popular open-source database. Execute the below commands to deploy two containers for MySQL and PHPMyAdmin. They'll leave the port 3306 in the host to accept SQL connections and port 8080 in the host for PHPMyAdmin. You can also optionally install SSL certificates to secure your connections when taking it public. MySQL is better suited for applications that use structured data and require multi-row transactions. As of June 2020, there are about 546,533 questions on just StackOverflow compared to it's NoSQL on-par which has only 131,429 questions.

Running the container

# Runs MySQL server with port 3306 exposed and root password '0000' 
docker run --name mysql -e MYSQL_ROOT_PASSWORD="0000" -p 3306:3306 -d mysql

# Runs phpmyadmin with port 80 exposed as 8080 in host and linked to the mysql container 
docker run --name phpmyadmin -d --link mysql:db -p 8080:80 phpmyadmin/phpmyadmin

What do I like about it?

Support for atomic transactions, privileged, and password security system.
MySQL is around the block for a long time which results in a huge community support

What I dislike about it?

It doesn't have an official image (including open-source forks like MariaDB) for machines like Raspberry Pi and ODROID-XU4 running arm32 making developers usually falling back to either community or third party image builds.
It does not natively support load balancing MySQL clusters, although open-source software such as ProxySQL helps you achieve this but with a learning curve.
Although the Vanilla MySQL is open source, it is not community-driven.
Are prone to SQL injections to some degree.

8. MongoDB

MongoDB is an open-source document-oriented database that is on many modern-day web applications. MongoDB stores it's data in JSON like files. I personally like MongoDB as its load balancing feature enables Horizontal scaling while explicitly removing the need of a Database Administrator. It is best suited for applications that require High write loads even if your data is unstructured and complex, or if you can’t pre-define your schema.

Running the container

# create a /mongodata directory on the host system
sudo mkdir -p /mongodata
# Start the Docker container with the default port number 27017 exposed
docker run -it -v /data/db:/mongodata -p 27017:27017 \
    --name mongodb -d mongo
# Start Interactive Docker Terminal
docker exec -it mongodb bash

What do I like about it?

Horizontal scaling is less expensive than vertical scaling which makes it financially a better choice.
The recovery time from a primary failure is significantly low.

What I dislike about it?

Lacks support for atomic transactions.
MongoDB has a significantly higher storage size growth rate than MySQL
MongoDB is comparatively young and hence cannot replace the legacy systems directly.

Database and Monitoring Tools

9. Grafana

Grafana is an open-source standalone tool mainly for visualizing and analyzing metrics while supporting integration with various databases (InfluxDB, AWS, MySQL, PostgreSQL, and more). Grafana supports built-in alerts to the end-users (even email you) from version 4.0. It also provides a platform to use multiple query editors based on the database and its query syntax. It is better suited for applications for identifying data patterns and monitoring real-time metrics.

Running the container

# Start the Docker container with the default port number 3000 exposed
docker run --name=grafana -d -p 3000:3000 grafana/grafana

Dashboard for monitoring resources on my Raspberry Pi

Web Server

10. Nginx

Nginx is more than just a lightweight web server as it comes with a reverse proxy, load balancer, mail proxy, and HTTP cache. I prefer Nginx to Apache as it uses lesser resources and quickly serves static content while being easy to scale. Compared to Apache, I've experienced Nginx to stutter less under load.

Nginx addresses the concurrency problems that nearly all web applications face at scale by using an asynchronous, non-blocking, event-driven connection handling algorithm. The software load balancing feature enables both Horizontal and Vertical Scaling, thus cutting down server load and request-server time. You can use the Nginx Docker containers to either host multiple websites or scale-out by load balancing using Docker swarm.

Running the container

# For other supported tags, visit https://hub.docker.com/_/nginx/
# Start the Docker container with the default port number 8080 exposed
docker run --name "nginx-server" -d -p 8080:80 nginx:latest