Tutorial Works

Using environment variables in shell scripts: Tutorial

Thu, 21 Sep 2023 06:00:00 +0000

Environment variables are one of those Linux things that, once they click, you’ll be using them everywhere.

In this tutorial we’ll dabble a bit with environment variables, and see how they can be used in shell scripts. Everything we do in this tutorial will be done in the terminal, so you’ll get some good practice with the Linux command line too.

But first, environment variables: what are they?

What are environment variables?

Environment variables (or “env vars” if you want to save some breath) are a way of storing configuration information in Linux. They’re a good way to store configuration, or temporary data that you want to use in your programs.

Linux usually has a bunch of environment variables that are already defined. They’re like built-in properties. They tell you information about your system, such as the current user, the current working directory, and the current shell. They’re called things like USERNAME, PWD and SHELL.

You can also add your own custom environment variables to store information about your own programs.

What you’ll need for the tutorial

A Linux terminal, or a virtual machine running Linux. Any distribution of Linux should be fine.
You should have experience editing files using a text editor such as nano or vim.

Steps

Looking at environment variables

First let’s explore the environment variables that are already in your system, probably without you even realising it.

Print your system’s environment variables. Run the following command to print your system’s environment variables:
```
printenv
```
Now you should see a list of environment variables, like HOME, PATH, and SHELL. For example, the output on my system looks like this:
```
SHELL=/bin/bash
SESSION_MANAGER=local/unix:@/tmp/.ICE-unix/5046,unix/unix:/tmp/.ICE-unix/5046
COLORTERM=truecolor
HISTCONTROL=ignoredups
XDG_MENU_PREFIX=gnome-
```
You can also use the printenv command to print the value of a specific environment variable. For example, try typing printenv HOME and seeing what you get!
Search for a string in an environment variable. Next, run the following command to search for a string in an environment variable name or value:
```
printenv | grep SHELL
```
This command uses the grep command to search for the string SHELL in the output of printenv.

Grep is an absolutely essential command for searching for things. You will probably use it every day.

We can also search for strings in the values of our environment variables. So let’s search for the string bash:
```
printenv | grep bash
```
If you’re using bash as your Linux shell, you should see a line like this:
```
SHELL=/bin/bash
```

Using environment variables in a command

Now that we’ve seen how to print and search for environment variables, how can we use them?

One of the most common times you might use environment variables is when you’re running a command.

For example, you might want to run a command on a specific file, but you don’t want to type the full path to the file.

Or, you might want to give a sensitive password to a command, without having to type it in, or show it on-screen.

Let’s use an environment variable in a command.

Pass an environment variable to the echo command. The echo command is one of the simplest Linux commands there is! It just prints whatever you pass to it.

Run the following command to print the value of the HOME environment variable. We’re using HOME because it’s a variable that’s set on all Linux systems:
```
echo $HOME
```
Note that we use the special $HOME syntax to access the value of the HOME variable.

You should see output like this:
```
/home/tdonohue
```
(Note that your username will be different!)
Use an environment variable in another command. Now let’s use the HOME environment variable in another command. Run the following command:
```
cd $HOME
```
This command uses the cd command to change the current working directory to the value of the HOME environment variable.

You can always check the current working directory using the pwd command.

Now if you run the pwd command, you should see that you’ve been taken to your home directory!

How did that work?

So what just happened? When you type in a command with an environment variable, a substitution happens.

When you type the command echo $HOME, the shell replaces the variable reference $HOME with the value of the HOME environment variable.

This means that Bash (or whichever shell you use) is responsible for the substitution. It’s not the echo command that does it.

So the first command that was actually run, was this: echo /home/username.

Using environment variables in a shell script

Now let’s get a bit more creative, and use environment variables in a shell script.

Create the script

Create a shell script. Create a file called hello.sh. Remember you can create a file using the touch command, or using your text editor like vim, nano or pico. Then add the following code to it:
```
 #!/bin/bash
 echo "Hello, world!"
```
This is a simple shell script that prints “Hello, world!” to the terminal.

The line #!/bin/bash is called a shebang. It tells the operating system that this file is a shell script, and that it should be run using the Bash shell.
Make the script executable. In Linux, scripts aren’t executable by default, so we need to run the following command to make it executable:
```
chmod +x hello.sh
```
We use the chmod command to change the permissions of a file. The +x option means “add execute permissions”.

You can always check the permissions of a file using the ls -l command. For example, ls -l hello.sh.
Run the script. Run the following command to run the script:
```
./hello.sh
```

Add environment variables to the script

Now that we have our test script, let’s add some environment variables.

Reference an environment variable in the script. Adding variables in shell scripts makes them more dynamic.

Let’s change the greeting to say hello to the current user. Fortunately in Linux there is usually an environment variable called USERNAME that stores the current user’s username.

So edit the file so it looks like this:
```
#!/bin/bash
echo "Hello, $USERNAME!"
```
The $USERNAME syntax is used to access the value of the USERNAME variable.
Run the script. Once you’ve made the changes above, run the modified script.
```
./hello.sh
```
You should see this output:
```
Hello, tdonohue!
```
(Again, or whatever your username is!)

Define our own environment variables

Finally, to finish off, let’s define our own environment variables.

Define an environment variable. Run the following command to define an environment variable called SECRET_CODE:
```
export SECRET_CODE="1234"
```
The export command is used to define an environment variable. The syntax is export VARIABLE_NAME="value".

You can also define an environment variable without the export command, but it will only be available in the current shell session. Using export makes it available to all child processes, including the programs you run.
Edit the script to print the environment variable. Now let’s edit the script to use the SECRET_CODE environment variable. Edit the file so it looks like this:
```
#!/bin/bash
echo "Hello, $USERNAME!"
echo "Your secret code is $SECRET_CODE"
```
Now when we run the script, it will print the value of the SECRET_CODE environment variable.
Run the script and let’s see it in action.

You know what to do:
```
./hello.sh
```
And you should see:
```
Hello, tdonohue!
Your secret code is 1234
```

And that’s the end of the tutorial!

Wrapping up

You did it. You’ve completed the tutorial!

In this tutorial, you learned how to:

Print your system’s environment variables
Search for a string in an environment variable
Pass an environment variable to the echo command
Use environment variables in a shell script

See you in the next tutorial!

Unit vs integration testing: What's the difference?

Sun, 09 Jul 2023 17:00:00 +0000

Developers have a job to create reliable, working software. But how do you know that your code works? Whether you’re developing a small app or a large system, you need to test your code.

What to know

Unit testing focuses on testing individual units of code in isolation, using specific test data, while integration testing examines how different systems or parts of the code interact with each other.
Unit tests are faster, easier to maintain, and validate the correctness of individual parts of the program, while integration tests are slower, more complex, and identify compatibility and integration issues.
Both unit and integration testing are important, and it’s good practice to write both.

There are several types of tests. To be confident in writing tests, you need to understand the difference between them. Unit and integration testing are two common types of testing. The main difference between the two is the scope of the test: unit tests are about testing a single unit of code, while integration tests are about testing how different parts of your code work together.

Unit testing explained

A Unit test is a way of verifying the correctness of a software program by testing a single part of it, in isolation. In practice, the term “unit” in “unit test” usually means testing a single function or method.

Unit tests are usually small enough that they run quickly, and can be run often. This allows developers to quickly test their code, and to catch any errors before they become a problem.

Unit tests should also be isolated, which means that each test should run independently from other tests. The outcome from one unit test should not affect another.

An example

You write a test for a function in your application that calculates the total price of an order. The function takes a list of products and returns the total price.

You call the function with a list of products, and verify that the result is correct.

This is a unit test. It tests a small piece of code, and it’s isolated from other tests.

Integration testing explained

Integration tests are a way of testing how different parts of your code work together. Integration tests are usually slower than unit tests, because they have a wider scope, and are often run less frequently.

These types of tests are designed to test the interaction between components of a system.

An example

You write a test that logs on to your application, and verifies that the user was logged in successfully.

This test might involve several components:

making a request to your logon method
the logon method might call an API to authenticate the user
the logon method might save the user’s details to a database

This is an integration test. It tests how different systems or parts of your code work together.

What’s the difference between unit and integration tests?

This table summarises some of the key differences between unit testing and integration testing:

	Unit testing	Integration testing
Purpose	Validates individual parts of a program	Verifies how parts work together
Scope	Focuses on individual units	Tests interaction between units
Isolation	Tests parts separately	Tests parts together
Granularity	Tests small, focused parts	Tests end-to-end scenarios
Environment	Uses mocks or stubs in place of external dependencies	Uses real or simulated integration environment
Data used in the test	Specific test data, often to make a certain event or error happen	Realistic, production-like data
Execution speed	Faster execution times	Slower, due to larger scope
Level of complexity	Less complex, due to isolation	More complex, due to interaction
Bug detection	Identifies logic errors	Identifies compatibility and integration issues
Maintenance	Easier to maintain	Challenging, as dependencies can change often

Which is more important?

It might be tempting to think that you can focus on one type of testing, and ignore the other. But both unit and integration testing are important, and you should have a good mix of both.

Unit testing focuses on testing logic within a software program, which can be subject to programmer error.

But most software applications also depend on another system – for example, a program might depend on a database or an API. Integration testing focuses on testing how the different parts of a software system work together.

If you’re unsure which to write first, people suggest writing unit tests first, and then adding integration tests as you go. This is perhaps because unit tests are smaller and easier to write, and they can help you to refactor your code.

The test pyramid

The test pyramid, originally by Mike Cohn, is a good visual illustration for the relative size and importance of tests. The test pyramid shows that the bulk of tests are often unit tests, with a smaller number of integration tests:

The test pyramid, showing the scope and speed of tests

Vladimir Khorikov, in his book Unit Testing Principles, Practices, and Patterns, says:

Check as many of the business scenario’s edge cases as possible with unit tests; use integration tests to cover one happy path, as well as any edge cases that can’t be covered by unit tests.

Closing the loop

In software development, testing is essential to ensure the reliability and functionality of code. Unit testing focuses on testing individual units of code in isolation, using specific test data to validate their correctness. On the other hand, integration testing examines how different parts of the code interact with each other, using realistic production-like data to identify compatibility and integration issues.

Both types of testing are crucial, and a balanced combination of unit and integration tests will help you build great, reliable software.

7 power features of the Linux shell you really need to know

Sat, 29 Oct 2022 08:00:00 +0000

The Linux shell is a powerful tool with many features that aren’t immediately obvious to the beginner. In this article, we’ll see some of the hidden power features of the Linux shell which will make your Linux shell experience a whole lot easier. From simple shortcuts to more advanced features, try one of these tricks today.

So, I use the Linux shell a lot. I use it for my day job, and I also use it for my personal projects. I use it to do a lot of the legwork for this blog.

I’ve been working with Linux for several years and picked up some useful tips. There are some Linux features which I didn’t know about for years, but now I use them all the time. And there’s still a ton of stuff that I don’t know!

In this post, I want to share some power features which I think are so useful, you’ll want to start using them every day. I’ll also share the proper names of these features, so if you want to know more, you know what to look for in the manual.

And, as a bonus, you’ll sound like you know what you’re talking about at work :-)

These commands work on the Bash or “GNU Bourne-Again SHell” which is the default shell on most Linux distributions. If you’re using a different shell, you might need to use a slightly different command.

Without further ado, let’s get into the seven power features of the Linux shell.

1. Save output from a command to a file

A lot of features in the Linux shell are activated simply by using a special character. So to be a pro, you just need to remember some characters. ;-)

Our first special character in Linux is the humble “greater-than” sign: >. With this character, you can save the output of a command to a file.

For example, here’s how to use the > operator to redirect the output of the echo command, to a file called “hello.txt”:

$ echo "Hello, world!" > hello.txt

This will create a file called hello.txt and write the text Hello, world! to it.

This is really useful when you want to share a command’s output with someone. No more do you need to suffer the embarrassment of pulling out your phone and taking a picture of your heavily-stained screen. 🤦‍♂️ Simply use the > operator and send them the file! Voila!

Here’s how to use the > it with another command; let’s use the > operator to save the output of the ls command to a file:

$ ls > files.txt

Now you have a file called files.txt that contains a list of the files in the current directory.

Double up to append to a file `>>`

You can also use the >> operator to append to a file. This means that if the file already exists, the output will be added to the end of the file. If the file doesn’t exist, it will be created.

$ echo "Hello, world!" >> hello.txt

This will append the text Hello, world! to the end of the file hello.txt.

Run a command and see its output while saving it with ‘tee’

But what if you want to save the output from a command and also see it on the screen? No problem. Just use the tee command.

Let’s say you want to see the output of the ls command, but you also want to save the output to a file. You can do this by using the tee 🫖 command:

$ ls | tee files.txt

It’s called “tee” because in plumbing, a “tee” connects two pipes together!

🔵 PROPER NAME IN LINUX: Redirection. To learn more, type man sh, press / and search for “redirection”.

2. Run commands in the background

Ever wanted to run a command, but keep using the command line at the same time, and without having to open a new terminal? You can do that with another special character, the ampersand: &.

With the & character, you can run a command in the background in a subshell. When you put a command into the background, you can get on with other stuff while the command is doing its thing.

A subshell is a copy of your current shell that runs your background command. You can think of it as a mini-shell that runs your background command and then terminates.

Here’s an example:

$ sleep 1000 &

This example will run the sleep command in the background for 1,000 seconds, and then exit.

Not sure if your command is still running? You can use the jobs command to see what’s running in the background:

$ jobs
[1]+  Running                 sleep 1000 &

Bring a job to the foreground and then to the background again

What if you want to bring a background job into the foreground – so you can see what it’s doing – and then put it back into the background? No problem, this is pretty common! Here’s how it’s done:

Run the program: Run your program, adding & to run it in the background.
Bring it to the foreground: Type fg, to bring the job back into the foreground. When the job is in the foreground, you’ll see its output in your terminal.
Suspend the program: Now you can can press Ctrl+Z to suspend the command. (During this time, the command isn’t really running, it’s paused. ⏸️)
Background the program: Finally, type bg to put the job back into the background.

Here’s what it looks like:

# start sleep in the background

$ sleep 1000 &
[1] 12345

# bring it to the foreground

$ fg
sleep 1000

# sleep is now running in the foreground, press Ctrl+Z to suspend it

^Z
[1]+  Stopped                 sleep 1000
$ 

# sleep is now suspended, type bg to put it back into the background
$ bg
[1]+ sleep 1000 &

🔵 PROPER NAME IN LINUX: Asynchronous commands or background jobs. To learn more, type man sh, press / and search for “job control”.

Handy for: Running more than one command at a time. Especially useful if you’re connected to a remote server via SSH and you only have one connection.

3. Use wildcard patterns to refer to groups of files

You don’t always have to type filenames. There is a handy shortcut!

The shell will automatically expand filenames or lists of files when you use a feature called pattern matching.

Pattern matching lets you find a file or group of files by some pattern in their filename. You can use pattern matching in most of your Linux commands, including ls, rm, cp, mv, grep and find. It’s really helpful because it means you don’t need to type exact filenames all the time!

This feature is really useful when you want to do something to a group of files; like delete them, or move them to a different directory. And don’t we all want to save typing? (Yes, we do.)

To use this feature, just remember the wildcard characters. Here are the most common wildcards:

* matches zero or more characters. (I use this a lot!)
? matches exactly one character
[abc] matches any one of the characters a, b or c
[a-z] matches any character between a and z (useful for matching all letters of the alphabet!)

For example, you can use the * wildcard to match any number of characters:

$ ls *.txt

This will print the names of all files that end with .txt to the screen.

Here’s another example. Let’s print the contents of all files which have four characters in their name and end in .conf:

$ cat /etc/????.conf

If you ever want to preview what an expansion will look like after it’s been expanded, use the echo command! For example:
echo cat /etc/????.conf.

🔵 PROPER NAME IN LINUX: Pathname expansion, pattern matching, “globbing”. To learn more, type man sh, press / and search for “pathname expansion”.

What it’s helpful for: Doing something to many files at once; like deleting them, or moving them to a different directory.

4. Pipe output from one command into another

Working in the Linux shell is often about running small commands which do one thing, and then taking the output of that command and passing it as the input to another command.

The pipe operator | is another special character! It lets you take the output from a command and use it as the input to another command. It’s probably the most useful operator on the Linux command line and I use it every single day.

For example, we can use the ls command to list the files in a directory, and then pipe the output to the grep command to search. Here’s an example:

$ ls /etc | grep cron

This example will list the contents of the /etc directory and then search the output for any files that contain the word cron in the filename.

Here are some other examples of using the pipe to combine commands:

# Print your command history and search the list for the text 'ls'
$ history | grep ls

# Print all running processes and search the list for the text 'java'
$ ps aux | grep java

# Print the contents of a file and convert double spaces to tabs
$ cat /var/myfile | tr '  ' '\t'

🔵 PROPER NAME IN LINUX: Pipelines. To learn more, type man sh, press / and search for “pipelines”.

5. Autocomplete everything

Autocomplete is one of the most useful features of the Linux command line. It’s so useful that I can’t imagine using the command line without it.

Autocomplete is a feature that lets you type the first few letters of a command or filename, and then press Tab to complete the rest of the word. It’s really useful when you’re typing long filenames or commands.

To start using it, just type a command or a filename.

$ systemd-

Then press Tab to get a list of possible completions:

$ systemd-
systemd-analyze
systemd-ask-password
systemd-cat
systemd-cgls
...

It’s like the autocomplete feature on your iPhone… except it actually suggests useful stuff.

Some commands have their own autocomplete, too

You can also use autocomplete with some commands!

Yes, many commands have their own autocomplete, too. For example, if you type ls -- and then press the tab key, the command line will show all of the possible options you can use.

And more complex commands, like kubectl (for Kubernetes), have their own autocomplete too. (Check the documentation for the tool you’re using to see if you need to install its completion feature.)

🔵 PROPER NAME IN LINUX: Completion, programmable completion. To learn more, type man bash, press / and search for “completion” or “READLINE”.

6. Change text in the command line

How often have you typed a command and realised you’ve got the first part wrong – and needed to go backspace all the way to change it? Or have you ever used a Linux shell and wished you could copy and paste bits of your command?

Well I think this trick is the most hidden of them all. The Linux shell has special key combinations that you can use to cut, copy and paste text in the command line - without needing a mouse:

Move around the command line

You probably know that you can use the arrow keys (Left and Right) to move the cursor around the command line.

But did you know that you can also use these keys too:

Ctrl+A and Ctrl+E keys move to the beginning or end of the line.
Alt+B moves the cursor back one word
Alt+F moves the cursor forward one word

Cut and edit parts of your command

These key combinations will save you a ton of typing. Use these key combos to edit your typing at the command line:

Ctrl-K will delete everything from the cursor to the end of the line (kind of like deleting forwards)
Ctrl-U will delete everything from the cursor to the start of the line (kind of like deleting backwards)
Ctrl-W will delete the word before the cursor.
Ctrl-Y will paste the last thing you deleted. This is called “yanking” 😳

🔵 PROPER NAME IN LINUX: Killing, yanking (and other weird names). These are features of the “READLINE” part of the shell. To learn more, type man bash, press / and search for “READLINE”.

7. Go back in history

When you need to repeat yourself, or run the same command again, you can use the up and down arrow keys to scroll through your command history.

But it gets better. You can also see your command history in the Linux command line. Use the history command to list the commands that you have run recently:

$ history

Written a long, complicated command and want to run it again? Find the command you want to re-run, and use the ! operator + its number, to run the command again:

$ !123

This will re-run the command that was run in history position 123.

And, most useful of all, you can search for commands in your history too. pressing Ctrl-R will let you search through your history using a text interface. Then just press Enter to run the command again.

Wrapping up

Now you’ve seen a whole bunch of features you probably didn’t even know existed in the Linux command line. Now you’ll be chomping at the bit to get started!

But before you do, there’s one more thing you need to remember…

You can find out more about any command you’re using by using the man command. For example, to find out more about the ls command, type:

man ls

I hope you use these hidden features of the Linux shell to make your Linux life easier, and to get things done faster.

Happy Linuxing!

Maven POM template - an example

Wed, 05 Oct 2022 08:00:00 +0000

When you’re kickstarting a new Java project, you might find yourself getting stuck at the first hurdle. How do you set up your brand new project with Maven?

If you’re using Maven to build your project (and many teams use it, so you’re in good company!), you’ll find that you need to create something called a pom file. What’s a pom file? It’s an XML file – usually called pom.xml – where you tell Maven all about your project, and declare all of your dependencies.

You’re probably thinking, what does a pom file look like? And is there a basic beginner pom file that you can use?

Fortunately, most IDEs can create your pom file for you. Just create a new Java project and follow the wizard steps. But, if you’re doing this on your own, don’t worry! You don’t need to write one from scratch. We’ve prepared an example pom file for you.

Maven pom.xml template

Here’s an example pom.xml that you can use to kickstart your next project:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>your-project-name</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>

    <name>your-project-name</name>

    <properties>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- Your dependencies go here, like this! -->
        <!--
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        -->
    </dependencies>

    <build>
        <plugins>
            <!-- Your plugins go here! -->

        </plugins>
    </build>
</project>

You can add this into your project’s folder as pom.xml. Don’t forget to:

Add the dependencies that you need in the dependencies section
Add any plugins you need in the plugins section
Start adding your source code into src/main/java

Alternative ways to bootstrap a Maven project

Are there any other ways to generate this pom file? Yes, many! Here are some of the ways:

Using your IDE. Most Java IDEs like IntelliJ or Eclipse include wizards or templates which can generate your pom file for you.
Spring has an online wizard called the Spring Initializr, which bootstraps a new Spring or Spring Boot project, and includes a ready-made pom file. Of course, this is mostly useful if you’re using the Spring framework.
Quarkus also has an online wizard at code.quarkus.io to bootstrap a new project. Again, only applies if you’re using Quarkus.
From the command line, Maven’s own mvn archetype:generate command will create a new project for you from an archetype (template).

But for now, I hope you found this example pom.xml useful!

Secure your Linux services with this guide to systemd's little-known security options

Fri, 23 Sep 2022 08:00:00 +0000

Systemd doesn’t just start and stop services… it can do a whole bunch of other stuff too. The problem is, most of us don’t know about it! But fortunately there’s a cheatsheet and command to help you. So if you’re creating a systemd service, consider using this handy guide to add some much-needed security to your services.

Why systemd is a “power tool”

So what exactly is systemd? Systemd is basically a controller, at the heart of your modern Linux system, which starts and manages services in your userspace. (Userspace is the technical term for the area of a Linux-based operating system where you run programs; in other words, userspace is the bit that’s not the Linux kernel.)

Systemd lets you configure your services in infinite ways. You can run services on a schedule, configure an action to take when a service fails, configure a service to automatically start its dependent services, and more. You could probably spend your whole career studying systemd. (And it’d be a fine career choice, to be honest.) But most of us want to get the most out of these tools without studying them for years.

Source: Hacker News

Instantly see how secure your services are

Systemd usually runs as the first process on boot (PID 1), which means that it has an awful lot of power over your Linux environment. “With great power, comes great responsibility,” they say. So for something with that amount of power, it’s helpful to have some checks and balances.

Systemd comes with a command line tool called systemd-analyze security which shows you instantly whether your services are using its security options. It gives each service an “exposure” score. I ran systemd-analyze security on my Linux workstation, and I got these results:

These results are not exactly encouraging for my Linux skills! But I’m running a Linux personal desktop; you might be aiming for different results if you’re running a database server in production. 😉

Try this cheatsheet to create more secure services

So once you’ve analyzed your services, you might want to add some security settings to them. Perhaps you want to sandbox your services, or prevent them from acquiring additional permissions. To do this you need to know the settings you need to add to your unit files.

These settings are all documented in the official documentation but is there an example? Yes! GitHub user Kevin Gallagher (ageis) did the hard work and created this awesome cheatsheet which shows some default systemd unit security settings and includes the relevant sections of the systemd docs, so you can find out more about them. Sharing here because I think it’s great:

Get the cheatsheet on GitHub Gist

Now you’ll be on your way to sandboxing your services, limiting their access to the file system, hiding access to the bits of the system that they don’t need, and so on.

Six helpful dnf/yum commands to manage software on Red Hat

Wed, 21 Sep 2022 08:00:00 +0000

In Red Hat Enterprise Linux and its related distributions (like Fedora and Rocky Linux), YUM and DNF are used to install, manage and remove software. These distros use packages in the RPM format (unlike Ubuntu/Debian which use apt)

So in RHEL or Fedora, this means you’ll often be using the yum or dnf commands to install and manage software on your system.

yum is the same as dnf!

In recent versions of Linux, yum is the same as dnf! In fact, the yum command is just a symbolic link to dnf.

I can check this on my Fedora 36 system. This example output shows that /usr/bin/yum is just a link to the dnf-3 command:

$ ls -la /usr/bin/yum 
lrwxrwxrwx. 1 root root 5 Sep  9 14:49 /usr/bin/yum -> dnf-3

Now let’s look at six dnf (or yum!) commands which you can use to install and manage software on Fedora or Red Hat Enterprise Linux.

Search for a package

Most of the time, when you want to install some software on Linux, the best place to look is the default repositories. Software in your distro’s repositories is usually tailored for your Linux distribution; it installs files in the right places, creates a system service and so on.

On Fedora, you’ll usually have the fedora and updates repositories enabled by default, which both contain lots of packages.

RHEL is an “enterprise” Linux distribution, has far fewer packages in its default repositories, and those are often a little more behind the “cutting-edge”, but they are generally stable and safe to install.

You can search for software in the default repositories using dnf search, for example:

dnf search nginx

This will search for packages containing the string nginx.

Install a package from a repository

When you’ve browsed the search results and decided which package you want to install, you can use the dnf install command. This will look in repositories for a package with the exact name, and install it.

For example, to install nginx:

dnf install nginx

Don’t forget you’ll need superuser privileges to install software, so add “sudo” to the front of the command.

Install a local rpm file

Some software isn’t distributed in repositories, but is distributed as a .rpm file instead. You can sometimes encounter this if you’re installing some commercial, closed-source software. Or, some open source projects might provide a .rpm file on their download or GitHub Releases page.

Whichever way you acquire a .rpm file, you can install it with rpm using the same install command:

dnf install your-rpm-file.rpm

You can also install an RPM file directly from a URL!:

dnf install http://github.com/example/example-app/releases/myapp.rpm

List all installed packages

Another common task is to find out all of the packages which are installed on your system, and their versions. This allows you you see all of the software applications which you have installed.

Why might you want to know this?

Sometimes you might want to check if a system has been configured correctly… or perhaps you’re wondering why a particular command is missing?

Here’s the command you need to show all installed packages:

dnf list --installed

The output from this command will show you the package name, the version, and which repository it was installed from (e.g. @fedora, @updates, etc.)

Packages which have been installed from a file are usually shown as coming from the @System repository.

Search for a specific installed package

Searching for a specific installed package? Well, for extra points, you can also pipe this command into grep, which will let you search for all installed packages which match a string.

For example, if I want to see all the podman packages on my system:

[tdonohue@fedora ~]$ dnf list --installed | grep podman
podman.x86_64                                        4:4.2.0-2.fc36                      @updates                             
podman-compose.noarch                                1.0.3-6.fc36                        @updates                             
podman-gvproxy.x86_64                                4:4.2.0-2.fc36                      @updates                             
podman-plugins.x86_64                                4:4.2.0-2.fc36                      @updates             

Zingggg! ✨

Which files are included in a package?

Before you install a package, you can find out what’s contained inside it. The massively useful thing about packages is that they install files to a specific location. So you can see, upfront, exactly what will be installed, and where.

So, to find out which files and paths are included in a package:

dnf repoquery -l nginx

The output from this command shows you all of the files in a package, and their paths.

Where does everything go? You’ll often see that application binaries will be installed into /usr/bin, the manpages will be added into /usr/share/man and the program’s config files will go into /etc/.

Which packages provide a command?

If you know you need a command, but you’re not sure which package provides that command, then you can use dnf provides to query the repositories.

For example, when I wanted to install kubectl (for working with Kubernetes), I wasn’t sure which package I needed to install. So I searched like this:

dnf provides /usr/bin/kubectl

… and the result told me that the package which contains kubectl is kubernetes-client (which is in the Fedora repositories, but might not be in the RHEL repositories).

If you’re not exactly sure of the path to the command, you can search with a wildcard:

dnf provides "*/bin/top"

Wrapping up

There are tons more commands you can use to manage packages on your Linux system, but these ones are very handy to know! To find out more, type man dnf.

Useful links:

5 ways to learn Linux to advance your career

Mon, 01 Aug 2022 08:00:00 +0000

Want to learn Linux to grow your career? Here are some tips if you’re planning to learn Linux.

Tips for learning Linux

Read a book

Books are comprehensive. Linux is pretty big. Sometimes it can feel like in order to do something, you need to learn about 100 concepts beforehand. Books go into thorough detail and will cover more than any video course.

Investing in a Linux book is a great idea, as you’ll probably return to it for years to come.

We recommend:

Linux Bible. It’s in its 10th Edition now, so if that’s not a good sign that you should pick it up, I don’t know what is.
How Linux Works. This is more of a “why” book. It explains the reasons that Linux works the way that it does.

Does it matter which distribution?

These Linux books are geared towards using Linux for business, not for gaming or home use. So they mostly focus on the big enterprise distributions, Red Hat and Ubuntu.

Take a course and/or an exam

If you want to learn Linux and the command line step-by-step, then take a course and an exam. The good thing about taking a course is that it will cover the core topics you need to know.

Try to find a course for system administrators. This will give you a good grounding in Linux commands, managing a server, installing packages, and so on.

Here are some ideas for Linux training:

Training for the Red Hat Certified System Administrator (RHCSA) certification will give you the knowledge you need to be confident with Red Hat Enterprise Linux.
Online learning platforms like A Cloud Guru and O’Reilly have self-paced Linux training courses.
The Linux Foundation offers Linux system administration training and certification. The Linux Foundation Certified System Administrator (LFCS) is a well-recognised certification.

Play with your own Linux server

You can get started with Linux by creating a Linux virtual machine on your own PC, using a program like VirtualBox. A virtual machine is a safe environment. In a VM, you can play around and learn, without being too concerned, because you won’t break anything.

Run Linux in Docker. You could also run Linux in a container.
Dual-boot. Once you’ve learned some of the basics, you could then choose to dual-boot to Linux. Dual-booting is where you install Linux as a secondary operating system on your PC, and you can choose to boot into it.

RECOMMENDED: See our step-by-step tutorial on running a web server in a Linux virtual machine with Vagrant.

Get command line experience

If you’re learning Linux for DevOps, you should force yourself to use the command line. So, ideally, install a Linux distribution without a desktop environment.

If you don’t install a desktop environment, you’ll only have the shell/terminal as your friend. But you will make the quickest progress this way.

When you’re learning the command line, also make time to learn a text editor like nano or vim. Vim is the text editor that comes with most distributions of Linux, with a quirky set of keyboard commands that take time to learn but will help you get things done quicker.

RECOMMENDED: See our guide to the top Linux commands.

Top ‘need-to-know’ Linux commands

There are dozens of Linux commands, some of which you’ll use more often than others. Here are some of the top commands that I use almost every day. You will probably use these often if you are going to be using Linux:

Command	What it does
`cd`, `pwd`, `ls`	Navigating the file system. These commands move between directories (folders), and list their contents.
`mkdir`, `rm`	Create and delete stuff. These commands can make a directory or delete files.
`vi`	Editing files. Vi, or vim, is the ubiquitous text editor that you’ll find on most Linux systems. It’s extremely powerful but takes time to learn.
`grep`, `find`	Searching files. These commands are used to find files on disk and search for text patterns.
`yum`, `dnf`, `apt`	Installing packages. These commands install or upgrade software on the operating system.
`ps`, `top`	Process monitoring. How many programs are running on the server, and how much resources are they using? Useful for troubleshooting.
`tar`, `zip`, `unzip`	Working with archive files. These commands compress and extract archive files, like zip, tar or tgz (compressed-tar) files.
`sed`, `awk`	Text manipulation. These commands are often chained together to extract data from files or input, and then used to create input to another command. These are used in DevOps to help write automation scripts.

Get help anytime

On your Linux journey, your emergency exit is man.

man is the command to show the “manual” and is your best buddy on Linux.

man holds the documentation for almost everything on your Linux system. It tells you how to run commands, how to configure things, and is a goldmine of info.

The only problem is, you need to know how to find things in man, and how to read man pages. Spend time learning how to use man first, and it will pay dividends for you in the future.

If you’re already on a Linux server, try typing man ls, and it will show you the manual for the ls command (which lists files and directories).

To search the manual on Linux, use man -k <search term>. This will find the manual pages which match your search query.

Outside of the manual, you can also get help with using Linux on forums and Q&A sites, like:

Linux4Noobs subreddit Beginner
Unix & Linux Stack Exchange Intermediate

XSD vs WSDL: What's the difference?

Mon, 04 Jul 2022 08:00:00 +0000

When you’re working with XML web services, you’ll often come across the terms WSDL and XSD. But do you know what they do, and what makes them different from each other? Read on to find out more.

What is XSD?

XSD, or XML Schema Definition, is a language for describing what an XML document should look like. XSD helps a computer system to validate an XML document.

You can use XSD to define the structure and rules for an XML document. XSD allows you to declare things like:¹

The list of elements which are allowed in an XML document, and a description of each element
The order of those elements
What contents the elements can contain (e.g. string or date)
Whether elements can contain more (child) elements

XSD can be used to validate any XML document – whether it’s received by email, file transfer, or a web service call. So it’s often used in backend processes to make sure that data is OK before processing it. If an XML document passes validation, it’s sometimes called schema-valid.

Validating an XML document with XML Schema

Source: Tutorial Works

An XML Schema Definition is itself just an XML document², so it looks like a regular XML file. When a document is written in XML Schema Definition language, it’s often saved with the extension .xsd.

XSD is a standard, agreed by the W3C. There are other ways to write rules for XML documents (like Document Type Definitions (DTDs), Relax-NG and Schematron) but XSD is probably the most popular way to validate an XML document.

What does it look like?

You begin an XSD document with the root element, schema. You define each tag in the XML document using the tag element. Each of these elements can contain simple content (which means something like a string or a date), or more complex data (like nested elements).

For example: You’re writing an XSD for an XML document to describe a Customer. In the XSD, you might declare that a Customer must have 1 Address, and that each Address must contain a State, but the Zip code is optional:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

  <xsd:element name="Customer" type="CustomerType"/>

  <xsd:complexType name="CustomerType">
    <xsd:sequence>
      <xsd:element name="Name" type="xsd:string"/>
      <xsd:element name="Address" type="AddressType"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:complexType name="AddressType">
    <xsd:sequence>
      <xsd:element name="Street" type="xsd:string"/>
      <xsd:element name="City" type="xsd:string"/>
      <xsd:element name="State" type="xsd:string"/>
      <xsd:element name="ZipCode" type="xsd:string" minOccurs="0"/>
      <xsd:element name="Country" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>

</xsd:schema>

We have an XML document that we’d like to validate against this XSD:

<Customer>
  <Name>Bob Carolgees</Name>
  <Address>
    <Street>1 Homer Street</Street>
    <City>Flanville</City>
    <State>BZ</State>
    <Country>DE</Country>
  </Address>
</Customer>

We could now validate this with the xmllint tool on Linux:

xmllint --schema customer.xsd bob.xml

If you try it yourself, you should see that the message “customer.xml validates”. Success!

What can you do with XSD?

So how is XSD used in the real world?

Write an XSD. You can create an XSD document and write rules in it, using a text editor, or specialised software like XMLSpy.
Validate with a command-line tool. You can use a tool like xmllint to validate XML documents using your XML Schema definition.
Validate in your code. Most programming languages have libraries to validate XML documents using XSD, so you can add validation to your own applications. For example, in Python you might use the xmlschema package.
Validation in another app. When a software application receives some data in XML format (e.g. from a business partner), it might use XSD to validate the incoming XML document.
Web services. If a program exposes an XML web service, it might use an XSD to check that its inbound and outbound messages are valid.

What is WSDL?

WSDL, or Web Services Description Language, is an XML-based language for describing web services.³

WSDL defines a standard set of XML elements, which describe all the features of a web service. You write a WSDL document, using these elements to describe your web service.

You can use WSDL to describe a web service, so that potential consumers of the service know how to use it. A WSDL document declares things like:

The operations you can call on the service
How the input and output messages should look
Which protocol or data format you should use to access the service
The location of the service (e.g. its HTTP endpoint)

WSDL looks like a regular XML file, and it’s usually saved with the .wsdl extension.

WSDL is also a standard from the W3C. You don’t have to use WSDL, but since it documents a web service completely, it’s become a common way to share information about web services (especially SOAP web services). Because of its widespread adoption, there are many tools which can understand WSDL files and use them to connect to web services.

What does it look like?

There are two major versions of WSDL:

A WSDL 1.1 document starts with the root element, definitions.
A WSDL 2.0 document starts with the root element, description.

WSDL contains elements to define the web service operations, data types, protocol and data formats, and location of the service. Inside the WSDL document, you can use XML Schema (XSD) to define the messages which should be received and sent by the web service.

What can you do with WSDL?

WSDL has been around for a long time, although it’s still used for lots of internal systems. So what can you do with it?

Write a WSDL. You can write a WSDL document using any text editor. It’s written in XML.
Describe your web service. Inside the WSDL file you can describe all of the operations your web service has, and the structure of the input and output messages.
Generate a WSDL from code. In some programming languages, you can generate a WSDL document automatically from your code. This is much easier than writing a WSDL document manually.

For example… In Java, you can write code for a web service using the JAX-WS APIs, and add a library like CXF which implements the JAX-WS standard. When you deploy your code, a WSDL will be automatically generated.
Create a web service client. If a web service provides a WSDL, you can import the WSDL into your programming language, and use it to create a client. There are libraries to help you do this in most programming languages. It can save a lot of time and means you don’t have to write a bunch of XML yourself!
Share it. You can publish a WSDL into a repository, so that people can find it and discover your web service.

WSDL describes the interface of a web service. One of the key things you need to know when connecting to a web service is how you should construct your request message. So, the WSDL defines what the input and output messages for the service should look like.

WSDL didn’t introduce a new language for describing these messages. Instead, it chose to adopt XML Schema Definition as its type system. ⁴ So WSDL uses the features of XSD to describe input and output messages – by defining the elements, their types, their sequence, and so on.

Most WSDL documents either include an XSD document, or they reference an XSD document located somewhere else.

So WSDL and XSD are closely related. You will often see XSD being used to describe the input and output messages of a web service.

Chains

Sometimes, you might also see a chain of documents, where a WSDL references an external XSD document, which itself references another XSD document.

You might see this when dealing with very complex web services, or many web services which share similar messages. So the messages might be defined in one place, and then referenced from many places.

Wrapping up

XML Schema Definition, or XSD, is almost the de facto way to write rules for your XML documents. An XSD document describes which elements should be present in an XML document. It can be used to validate XML.

WSDL, or Web Services Definition Language, is a way to describe web services. It’s also written in XML. Many WSDL documents use XML Schema to describe the types of messages that a web service either consumes or produces.

There are so many ways to create a web service. But now you’re familiar with XSD and WSDL, you’ll be on your way to creating and consuming XML-based web services!

XML Technology: Schema. W3C. Retrieved 2022-07-14. ↩
XML, DTD and XML Schema. Duke University. 2014. ↩
Web Services Description Language (WSDL) Version 2.0 Part 1: Core Language. W3C. 26 June 2007. ↩
What is WSDL?. IBM. Retrieved 2022-07-05. ↩

How to download all Maven dependencies into a folder

Sun, 26 Jun 2022 09:00:00 +0000

In this article we’ll look at how to use Maven to download all of your Java project’s dependencies, like libraries and frameworks, and save them into a specific folder.

Summary

You can use the Maven Dependency Plugin to download dependencies.
Run mvn dependency:copy-dependencies, to download all your dependencies and save them in the target/dependency folder.
You can change the target location by setting the property outputDirectory.

Normally, you don’t need to download your dependencies explicitly! Maven automatically downloads your project’s dependencies, whenever you run a build. (So you can ignore this post.)

So why might you need to download dependencies? Well, you might need to do this if…

You want to run your project (and its dependencies) on another machine which doesn’t have internet access
You want to debug a library, so you want a local copy
You simply like collecting jars

If this sounds like you, read on.

Steps to download all dependencies

When you want to do something in Maven, you usually need a plugin. Most features in Maven – like compiling code, running tests and downloading dependencies – are implemented inside a plugin.

To download dependencies, you can use the Maven Dependency Plugin.

Download dependencies (without building your project)

From the Maven Dependency Plugin, we can use the goal copy-dependencies. It downloads dependencies from a repository (usually the “main” online repository, Maven Central) to our local project folder.

You can execute this goal separately, without building your project.

Here’s how to do it:

In your project’s pom.xml, make sure that you’ve added all the dependencies you want to use.
Drop to a terminal in your project folder (where your pom.xml is located).
Run this command to execute the goal copy-dependencies, which starts downloading dependencies:
```
mvn dependency:copy-dependencies
```
Maven Dependency Plugin will download dependencies (for example, JAR files) into the folder target/dependency.

Afterwards, you will see that the files have been downloaded:

$ ls -al target/dependency
total 63676
drwxr-xr-x. 2 tdonohue tdonohue    16384 Jun 26 10:46 .
drwxr-xr-x. 7 tdonohue tdonohue     4096 Jun 26 10:46 ..
-rw-r--r--. 1 tdonohue tdonohue   364206 Jun 26 10:46 aesh-2.6.jar
-rw-r--r--. 1 tdonohue tdonohue     6806 Jun 26 10:46 apiguardian-api-1.1.2.jar
-rw-r--r--. 1 tdonohue tdonohue   199943 Jun 26 10:46 arc-2.9.2.Final.jar
-rw-r--r--. 1 tdonohue tdonohue   122176 Jun 26 10:46 asm-9.3.jar
....

And that’s pretty much it.

Download dependencies to a specific location

Want to download to a different location? No problem.

The Maven Dependency Plugin copy-dependency goal saves files to target/dependency by default. But you can change the behaviour, by setting the property outputDirectory.

Here’s an example:

mvn dependency:copy-dependencies -DoutputDirectory=/mydeps

(See how we use -D to set a property.)

Now Maven will download the artifacts to the /mydeps directory.

How does it work?

Like most features in Maven, this is made possible by a plugin, the Maven Dependency Plugin. The plugin helps you to manage your project’s dependencies:

About the plugin:

Name	Maven Dependency Plugin
Purpose	The dependency plugin provides the capability to manipulate artifacts. It can copy and/or unpack artifacts from local or remote repositories to a specified location.
Homepage	maven-dependency-plugin
Prefix	`dependency:`
Example goals	`copy-dependencies` – downloads dependencies `analyze` – calculates used/unused dependencies `tree` – shows the dependency tree for your project

The plugin analyses the dependencies in your project, and copies dependencies from Maven Central (or the repository you have configured).

There are lots of other plugins for Maven, too - see the list.

Wrapping up

We’ve seen how you can use the Maven Dependency Plugin to download all of your project’s dependencies (JAR files) into a single folder.

We activate this plugin using the dependency: prefix, and then choose the goal to execute. In our case, we use the copy-dependencies goal.

If you want to check out what else the plugin can do, see the documentation.

Happy building!

Java frameworks: Spring vs Quarkus

Mon, 30 May 2022 07:00:00 +0000

After you’ve mastered your ints and hashmaps, you probably want to know how Java software is developed in the real world. Well, you probably won’t write as much code as you think. Most programming problems have already been solved in frameworks. But which are the most well-known Java frameworks? Let’s find out.

For most Java developers, frameworks are a part of everyday life.

Perhaps you’re just learning Java and you want to get the lay of the land, or you’re an operations engineer who wants to understand more about those Java workloads you’re running.

Well, here are the frameworks you will probably see in modern Java development.

Why frameworks?

A good framework helps you build solid foundations for your application and means that you don’t need to “reinvent the wheel” for every bit of functionality you need.

(We might think that we can forge a piece of metal into something that turns round and round, but it’s easier and cheaper to just buy a wheel.)

Of course, you can still write an app from scratch without a framework. But in most companies – especially larger ones – you’ll see frameworks in use.

Why?

Because a framework provides a common way to write an application. It helps developers work together, and it reduces the amount of boilerplate code that you need to write.

Let’s see two of the most well-known Java frameworks in use today: Spring and Quarkus.

🍃 Spring

Spring is an umbrella brand for a whole bunch of frameworks and libraries for Java. Specifically many new Java projects these days start on Spring Boot:

Website	https://spring.io/projects/spring-boot
Stargazers	61,000+
GitHub	https://github.com/spring-projects/spring-boot
License	Apache 2.0
Examples	GoThinkster RealWorld, Spring Petclinic

Spring started out as a dependency injection framework, but now it’s much more than that. The various projects in Spring help Java developers to do things like connect to a database, or write reactive (asynchronous) applications.

Let’s dive in to Spring.

What is Spring? What’s inside the box?

Spring has many projects, but the most well-known ones are:

Spring Framework. This is the main project, and is the basis for everything else in the Spring universe. Spring Framework is a dependency injection container, and a bunch of utilities.
Spring Boot. Spring Boot is the modern way to create a Spring application. You don’t need to use Boot to create a Spring app. But most people do, because it’s easier! It makes it easy to “bootstrap” a Spring project (it configures your Spring Framework container and auto-configures lots of third-party libraries too.)

The are lots of other projects under the ‘Spring’ name. Some of them help you work with data (Spring Data), write batch processing programs (Spring Batch), or create REST services (Spring REST).

What do you need to know?

What should you know about Spring?

Spring enables the Inversion-of-Control design pattern. Inside your application, Spring creates a virtual ‘container’ called the Application Context. Inside the container, it creates objects from your classes, and then wires them up together (simple, right?)
It’s stable and well-documented. Spring is supported by VMware, who employ developers that work on Spring and keep it patched and up-to-date.
Big community. There are almost 200,000 questions about Spring on Stack Overflow, an annual Spring conference, and lots of blog posts to learn from.
Good for cloud-native microservices. Spring Boot helped spread the trend of running Java applications without an application server. Spring Boot builds your application to a single .jar file. This makes it easier to implement microservices.
The inertia effect. Spring is used by lots of developers, so… it gets used by even more developers. If you know Spring, you won’t have a problem finding a job in Java today.

How to develop apps with Spring Boot

Most people start with Spring Boot. It’s the easiest way to start developing a Spring application:

Generate your app. Go to start.spring.io, use the application generator. Add the Spring Web dependency. This generates a Spring Boot application with an embedded web server (so you can create APIs).
Write your code. Load the project into your IDE. Add annotations to your code when you need Spring to do something.
Compile your app to a JAR file. Use the Maven plugin to compile your application into a single JAR file.
Deploy and run it. Run the packaged JAR file on a virtual machine with Java installed, run in the cloud (e.g. deploy it onto AWS Elastic Beanstalk) or package it into a container image and run on Kubernetes.

⚛ Quarkus

Quarkus is a framework for developing small, fast Java apps.

Website	https://quarkus.io
Stargazers	10,000+
GitHub	https://github.com/quarkusio/quarkus
License	Apache 2.0
Examples	quarkus-quickstarts

Quarkus consists of a runtime “core” which you use to develop your application.

Then you add extensions which give you features and functionality you want to add to your app.

What is Quarkus? What’s inside the box?

So what is Quarkus, really? When you create apps with it, what components do you use?

Quarkus Core. This is the runtime core which helps you build the scaffolding for your app. It manages the lifecycle of your application and handles capabilities like configuration management, etc.
Reactive Engine. Under the hood, Quarkus uses a tool called Vert.x to manage tasks from the various internal components. Vert.x is a Java toolkit for creating reactive applications. It helps applications to perform some tasks quicker, by allowing the application to work on another task, while it’s waiting for the result of another task. (It’s a bit more complicated than this, but you can read more.)
Quarkus Extensions. To add a framework or library to your Quarkus app, you need to add an extension. There are a growing number of extensions. For example, there is a JPA extension which lets you add Hibernate, so that you can save data to a database. Or, you can use the Arc extension to add support for CDI (Contexts & Dependency Injection).

What do you need to know?

Quarkus optimises your app at build time. Quarkus uses a special build process, which removes some unused code and classes. It also tries to do some of your app’s initialisation work upfront during the build, so that the compiled app has to do less work on startup.
Uses less memory, starts up faster. Some tests have shown that Quarkus uses less memory at runtime and starts up quicker. This means that it’s a good choice for developing microservices.
Compiles to a native binary on Linux. A Quarkus application can be compiled to a native binary on Linux. This means that your application can run on a Linux system without needing to run inside the Java Virtual Machine (JVM), so it can be much smaller and faster.
Uses Java standards that you might already know. Quarkus lets you code using some well-known Java standards, like CDI, JPA, JAX-RS and MicroProfile.
Live coding. While you’re developing, Quarkus can automatically compile your code changes and reload your application, without you having to stop and start it yourself. It’s very fast, and feels just like you are developing a PHP or Node.js app.
Tooling to create containers. The Quarkus build tooling lets you easily create a container (Docker) image for your application.

How to develop apps with Quarkus

To get started with Quarkus, you can create a skeleton project and add the extensions that you need.

Here’s how to do it:

Generate your app. Go to code.quarkus.io to generate a new Quarkus application. Add the capabilities you want to your app, by choosing Extensions. Download the source code as a ZIP file.
Write your code. Import the source code into your IDE. Write your code.
Build your application to a JAR or native binary. Use the Quarkus Maven Plugin to package your app, and optionally into a native binary and/or into a container.
Deploy and run it. Run it on a cloud provider, Kubernetes cluster, FaaS/serverless platform (like AWS Lambda or Azure Functions) or just a plain old virtual machine.

Wrapping up

Two of the biggest Java frameworks in use today are Spring (well, specifically Spring Boot) and Quarkus.

If you want to understand Java, then try to create a simple application in either of these two frameworks. It will give you a better idea of how Java programs are written in the real world.

Of course, there are many more frameworks in Java; too numerous to cover here. (But that’s maybe an article for another day!)

Happy Java programming.

Tutorial Works

Using environment variables in shell scripts: Tutorial

What are environment variables?

What you’ll need for the tutorial

Steps

Looking at environment variables

Using environment variables in a command

How did that work?

Using environment variables in a shell script

Create the script

Add environment variables to the script

Define our own environment variables

Wrapping up

Unit vs integration testing: What's the difference?

What to know

Unit testing explained

An example

Integration testing explained

An example

What’s the difference between unit and integration tests?

Which is more important?

The test pyramid

Closing the loop

7 power features of the Linux shell you really need to know

1. Save output from a command to a file

Double up to append to a file >>

Run a command and see its output while saving it with ‘tee’

2. Run commands in the background

Bring a job to the foreground and then to the background again

3. Use wildcard patterns to refer to groups of files

4. Pipe output from one command into another

5. Autocomplete everything

Some commands have their own autocomplete, too

6. Change text in the command line

Move around the command line

Cut and edit parts of your command

7. Go back in history

Wrapping up

Maven POM template - an example

Maven pom.xml template

Alternative ways to bootstrap a Maven project

Secure your Linux services with this guide to systemd's little-known security options

Why systemd is a “power tool”

Instantly see how secure your services are

Try this cheatsheet to create more secure services

Read more about systemd

Six helpful dnf/yum commands to manage software on Red Hat

yum is the same as dnf!

Search for a package

Install a package from a repository

Install a local rpm file

List all installed packages

Search for a specific installed package

Which files are included in a package?

Which packages provide a command?

Wrapping up

5 ways to learn Linux to advance your career

Tips for learning Linux

Read a book

Does it matter which distribution?

Take a course and/or an exam

Play with your own Linux server

Get command line experience

Top ‘need-to-know’ Linux commands

Get help anytime

XSD vs WSDL: What's the difference?

What is XSD?

What does it look like?

What can you do with XSD?

What is WSDL?

What does it look like?

What can you do with WSDL?

How is XSD related to WSDL?

Chains

Wrapping up

How to download all Maven dependencies into a folder

Summary

Steps to download all dependencies

Download dependencies (without building your project)

Download dependencies to a specific location

Double up to append to a file `>>`