Name: Remote Access Using SSH on Oracle Linux
Uploaded: 2025-11-04T17:23:14.000Z
Duration: 8 min 35 s
Description: Thousands of YouTube videos with English-Chinese subtitles! Now you can learn to understand native speakers, expand your vocabulary, and improve your pronunciation...

Adverbs of manner

Often the system we need to connect to is physically somewhere else, so we have to connect remotely.

There are several different ways to do this, but

Participle clauses

in this video I'll show you one of the most common methods by connecting remotely using ssh, also known as Secure Shell.

In this demo, I'll be working on two systems, the server that I want to connect to and the client I'll be connecting from.

Let's get started by opening a terminal session on the server system.

We'll need to make sure that the system has OpenSSH server installed and configured.

Oracle Linux has this installed out of the box, and

we can verify that by using dnf list installed and then piping it to grep ssh and we see openssh Server listed here.

However, if you needed to install it, you'd use sudo dnf install openssh server after installation, you would then need to enable and start the sshd daemon which listens for client connections using sudo systemctl enable now sshd with the OpenSSH server installed, let's look at configuring it by editing the sshdconfig file.

So I'll open it up with sudo vi etc ssh sshdconfig There are a lot of settings you can adjust here, but

Near the top, you can set the port that SSH listens on.

If I wanted to change it, I'd uncomment the line and adjust the port number, but

the default works for my setup, so I'll leave it as is.

If we page down, there's a line that permits root access.

Generally you'll want this to be set to no.

To make the system more secure, if you needed root access remotely, you would log in with a less privileged user and then elevate your privileges after you connect, which is what I'm going to do.

So I'll set this to no scrolling down we see a line for allowing key authentication, which would allow users to use key pairs to log in instead of passwords.

I'll show you how to do this later, so make sure this is set to yes.

If we continue down the file, there's a line for password authentication.

This allows clients to log in with the username and password defined on the server system.

If we set it to no, users would have to log in using a key instead.

As I mentioned, we'll look at keys later, so for now I'll leave password authentication set to yes and change it once we get keys configured.

Since we made changes, we'll need to restart the daemon with sudo systemctl rest restart sshd now that we have SSH server up and running, we'll need to configure the firewall to allow SSH connections.

To do that, we'll need to open the port that SSH is using.

In this case it's using the default port 22.

So we can simply add the SSH service to the firewall with sudo firewall cmd permanent add service ssh then reload the firewall with sudo firewall cmd reload and we can verify the firewall settings with sudo firewall cmd list all and we see SSH listed as a service.

If you are using a different port, you'd have to specifically open that port with the add port option and depending on your system settings, you would also have to tell Selinux about the port change.

Okay, that's it for configuring the server.

So let's take a look at connecting to it from the client system.

We'll need to make sure that the System has the OpenSSH clients package installed and configured.

Most distros have this installed by default and again we can verify using dnf list installed and then pipe it to grep ssh and we see it's installed on the system.

But if you needed to install it, you could use sudo-dnf install OpenSSH clients the config file for the client side is in etc ssh sshconfig and I'll take a look at it with vi.

This file allows you to set system wide options.

just know that the ssh config file is for the client side and the sshdconfig file that we looked at previously is for the server settings.

Now let's connect from the client to the server.

The server already has a user matching my username and password, so I can use that.

To connect I'll enter ssh my username and then the IP address or host name of the server.

If I left it like this, it would assume the default port of 22, but

to specify a port I could use the p option followed by the port number.

Then it'll ask if I want to accept the server's key.

When installing OpenSSH server, I'll enter yes to accept the key and then it'll ask me for my password.

And now we're logged into the server system's terminal, the same as if I were logged in and sitting in front of it.

For instance, maybe I'll run LS LA and we see those files.

This connection will stay open as long as network connectivity is maintained.

So once I'm done working, I can type exit to disconnect and it'll return me to the prompt on my client system.

In that example, I used a username and password.

The other way to authenticate remote connections is using key pairs, which is more secure, because unlike passwords, a key can't be guessed.

It also frees the user from having to remember complicated passwords.

We'll generate a key pair on our client system using SSH keygen.

This creates a private key and a corresponding public key.

We'll copy the public key over to the server and keep the private key securely on the client.

Then, when we try to connect the system, we'll present our private key.

The server will verify that it corresponds to the public key that's already on the server.

And if it does, the server will allow us to connect.

If I don't specify anything, it'll save it to the default SSH folder within my home directory and call the key idrsa.

if you had several different systems you were connecting to, you'd probably want to specify something more specific.

I'm not going to add a passphrase, so I'll hit Enter and it generates the keys.

And if I run LS L ssh, we see the IDRSA file, which is the private key, and

the idrsa pub file, which is the public key.

Now that we have the key pair, we need to copy the public key over to the server.

To do that, I can use SSH Copy id, then the I option, followed by the path to the identity file or key.

So in my case, it's my home directory SSH idrsa pub, then my username, and

then it adds the key to the SSH authorizedkeys file within my home directory on the server.

Now let's connect to the server with SSH my username at the IP address.

this time notice that it doesn't ask for my password.

That's because it's using key authentication.

Now that we've added a key, let's disable password authentication by opening up the sshdconfig file and changing the password authentication line to no.

Since we made changes to the file, we'll need to restart the daemon with sudo systemctl restartsshd and let's exit out of my session then return to the client.

Let's test out that password authentication change by trying to login with a different user that hasn't set up a key pair yet.

So I'll try to login as sam, who's a defined user on the server with ssh sam the IP address and we see that it denies access again.

That's because this user doesn't have key authentication for the server and we've just turned off password authentication.

But if we try to connect with my user, sure enough it allows me to do it.

I think that covers the basics of connecting remotely using ssh.