opensource/podman
1
0
Fork 0
mirror of https://github.com/containers/podman.git synced 2025-05-17 23:26:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

[CI:DOCS] Update remote tutorials

Browse Source 
update remote tutorial
update mac/windows tutorial
move varlink tutorial

Signed-off-by: Ashley Cui <acui@redhat.com>
This commit is contained in:
Ashley Cui
2020-09-08 16:44:49 -04:00
parent be7778df6c
commit 98ae84cc9e
8 changed files with 304 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -177,8 +177,8 @@ familiar container cli commands. For more details, see the
[Container Tools Guide](https://github.com/containers/buildah/tree/master/docs/containertools).
## Podman Legacy API (Varlink)
Podman offers a Varlink-based API for remote management of containers.
However, this API has been deprecated by the REST API.
Podman offers a [Varlink-based API](https://github.com/containers/podman/blob/master/docs/tutorials/varlink_remote_client.md)
for remote management of containers. However, this API has been deprecated by the REST API.
Varlink support is in maintenance mode, and will be removed in a future release.
For more details, you can see [this blog](https://podman.io/blogs/2020/01/17/podman-new-api.html).

2
docs/source/Tutorials.rst
View File

@ -6,7 +6,7 @@ Here are a number of useful tutorials to get you up and running with Podman. If
* `Basic Setup and Use of Podman <https://github.com/containers/podman/blob/master/docs/tutorials/podman_tutorial.md>`_: Learn how to setup Podman and perform some basic commands with the utility.
* `Basic Setup and Use of Podman in a Rootless environment <https://github.com/containers/podman/blob/master/docs/tutorials/rootless_tutorial.md>`_: The steps required to setup rootless Podman are enumerated.
* `Podman Mac Client tutorial <https://github.com/containers/podman/blob/master/docs/tutorials/mac_client.md>`_: Special setup for running the Podman remote client on a Mac and connecting to Podman running on a Linux VM are documented.
* `Podman Mac/Windows tutorial <https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md>`_: Special setup for running the Podman remote client on a Mac or Windows PC and connecting to Podman running on a Linux VM are documented.
* `How to sign and distribute container images using Podman <https://github.com/containers/podman/blob/master/docs/tutorials/image_signing.md>`_: Learn how to setup and use image signing with Podman.
* `Podman remote-client tutorial <https://github.com/containers/podman/blob/master/docs/tutorials/remote_client.md>`_: A brief how-to on using the Podman remote-client.
* `How to use libpod for custom/derivative projects <https://github.com/containers/podman/blob/master/docs/tutorials/podman-derivative-api.md>`_: How the libpod API can be used within your own project.

4
docs/tutorials/README.md
View File

@ -12,9 +12,9 @@ Learn how to setup Podman and perform some basic commands with the utility.
The steps required to setup rootless Podman are enumerated.
**[Setup on OS X](mac_client.md)**
**[Setup Mac/Windows](mac_win_client.md)
Special setup for running the Podman remote client on a Mac and connecting to Podman running on a Linux VM are documented.
Special setup for running the Podman remote client on a Mac or Windows PC and connecting to Podman running on a Linux VM are documented.
**[Remote Client](remote_client.md)**

101
docs/tutorials/mac_client.md
View File

@ -1,99 +1,2 @@
# Podman Mac Client tutorial
## What is the Podman Mac Client
First and foremost, the Mac Client is under heavy development. We are working on getting the
Mac client to be packaged and run for a native-like experience. This is the setup tutorial
for the Mac client at its current stage of development and packaging.
The purpose of the Mac client for Podman is to allow users to run Podman on a Mac. Since Podman is a Linux
container engine, The Mac client is actually a version of the [Podman-remote client](remote_client.md),
edited to that the client side works on a Mac machine, and connects to a Podman "backend" on a Linux
machine, virtual or physical. The goal is to have a native-like experience when working with the Mac
client, so the command line interface of the remote client is exactly the same as the regular Podman
commands with the exception of some flags and commands that do not apply to the Mac client.
## What you need
To use the Mac client, you will need a binary built for MacOS and a Podman "backend" on a Linux machine;
hereafter referred to as the Podman node. In this context, a Podman node is a Linux system with Podman
installed on it and the varlink service activated. You will also need to be able to ssh into this
system as a user with privileges to the varlink socket (more on this later).
For best results, use the most recent version of MacOS
## Getting the Mac client
The Mac client is available through [Homebrew](https://brew.sh/).
```
$ brew cask install podman
```
## Setting up the client and Podman node connection
To use the Mac client, you must perform some setup on both the Mac and Podman nodes. In this case,
the Mac node refers to the Mac on which Podman is being run; and the Podman node refers to where
Podman and its storage reside.
### Connection settings
Your Linux box must have ssh enabled, and you must copy your Mac's public key from `~/.sconf sh/id.pub` to
`/root/.ssh/authorized_keys` on your Linux box using `ssh-copy-id` This allows for the use of SSH keys
for remote access.
You may need to edit your `/etc/ssh/sshd_config` in your Linux machine as follows:
```
PermitRootLogin yes
```
Use of SSH keys are strongly encouraged to ensure a secure login. However, if you wish to avoid ‘logging in’ every
time you run a Podman command, you may edit your `/etc/ssh/sshd_config` on your Linux machine as follows:
```
PasswordAuthentication no
PermitRootLogin without-password
```
### Podman node setup
The Podman node must be running a Linux distribution that supports Podman and must have Podman (not the Mac
client) installed. You must also have root access to the node. Check if your system uses systemd:
```
$cat /proc/1/comm
systemd
```
If it does, then simply start the Podman varlink socket:
```
$ sudo systemctl start io.podman.socket
$ sudo systemctl enable io.podman.socket
```
If your system cannot use systemd, then you can manually establish the varlink socket with the Podman
command:
```
$ sudo podman --log-level debug varlink --timeout 0 unix://run/podman/io.podman
```
### Required permissions
For now, the Mac client requires that you be able to run a privileged Podman and have privileged ssh
access to the remote system. This limitation is being worked on.
#### Running the remote client
There are three different ways to pass connection information into the client: flags, conf file, and
environment variables. All three require information on username and a remote host ip address. Most often,
your username should be root and you can obtain your remote-host-ip using `ip addr`
To connect using flags, you can use
```
$ podman --remote-host remote-host-ip --username root images
REPOSITORY TAG IMAGE ID CREATED SIZE
quay.io/podman/stable latest 9c1e323be87f 10 days ago 414 MB
localhost/test latest 4b8c27c343e1 4 weeks ago 253 MB
k8s.gcr.io/pause 3.1 da86e6ba6ca1 20 months ago 747 kB
```
If the conf file is set up, you may simply use Podman as you would on the linux machine. Take a look at
[podman-remote.conf.5.md](https://github.com/containers/podman/blob/master/docs/podman-remote.conf.5.md) on how to use the conf file:
```
$ podman images
REPOSITORY TAG IMAGE ID CREATED SIZE
quay.io/podman/stable latest 9c1e323be87f 10 days ago 414 MB
localhost/test latest 4b8c27c343e1 4 weeks ago 253 MB
k8s.gcr.io/pause 3.1 da86e6ba6ca1 20 months ago 747 kB
```
# [Podman Mac Client tutorial](https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md)
This tutorial has moved! You can find out how to set up Podman on MacOS (as well as Windows) [here](https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md)

111
docs/tutorials/mac_win_client.md Normal file
View File

@ -0,0 +1,111 @@
# Podman Remote clients for MacOS and Windows
## Introduction
The core Podman runtime environment can only run on Linux operating systems. But other operating systems can use the “remote client” to manage their containers to a Linux backend. This remote client is nearly identical to the standard Podman program. Certain functions that do not make sense for remote clients have been removed. For example, the “--latest” switch for container commands has been removed.
### Brief architecture
The remote client uses a client-server model. You need Podman installed on a Linux machine or VM that also has the SSH daemon running. On the local operating system, when you execute a Podman command, Podman connects to the server via SSH. It then connects to the Podman service by using systemd socket activation. The Podman commands are executed on the server. From the client's point of view, it seems like Podman runs locally.
## Obtaining and installing Podman
### Windows
Installing the Windows Podman client begins by downloading the Podman windows installer. The windows installer is built with each Podman release and is downloadable from its [release description page](https://github.com/containers/podman/releases/latest). You can also build the installer from source using the `podman.msi` Makefile endpoint.
Once you have downloaded the installer, simply double click the installer and Podman will be installed. The path is also set to put `podman` in the default user path.
Podman must be run at a command prompt using the Windows ‘cmd” or powershell applications.
### MacOS
The Mac Client is available through [Homebrew](https://brew.sh/). You can download homebrew via the instructions on their site. Install podman using:
```
$ brew install podman
```
## Creating the first connection
### Enable the Podman service on the server machine.
Before performing any Podman client commands, you must enable the podman.sock SystemD service on the Linux server. In these examples, we are running Podman as a normal, unprivileged user, also known as a rootless user. By default, the rootless socket listens at `/run/user/${UID}/podman/podman.sock`. You can enable this socket, permanently using the following command:
```
$ systemctl --user enable podman.socket
```
You will need to enable linger for this user in order for the socket to work when the user is not logged in.
```
$ sudo loginctl enable-linger $USER
```
You can verify that the socket is listening with a simple Podman command.
```
$ podman --remote info
host:
arch: amd64
buildahVersion: 1.16.0-dev
cgroupVersion: v2
conmon:
package: conmon-2.0.19-1.fc32.x86_64
```
#### Enable sshd
In order for the client to communicate with the server you need to enable and start the SSH daemon on your Linux machine, if it is not currently enabled.
```
$ sudo systemctl enable -s sshd
```
#### Setting up SSH
Remote podman uses SSH to communicate between the client and server. The remote client works considerably smoother using SSH keys. To set up your ssh connection, you need to generate an ssh key pair from your client machine.
```
$ ssh-keygen
```
Your public key by default should be in your home directory under .ssh\id_rsa.pub. You then need to copy the contents of id_rsa.pub and append it into ~/.ssh/authorized_keys on the Linux server. On a Mac, you can automate this using ssh-copy-id.
If you do not wish to use SSH keys, you will be prompted with each Podman command for your login password.
## Using the client
The first step in using the Podman remote client is to configure a connection..
You can add a connection by using the `podman system connection add` command.
```
C:\Users\baude> podman system connection add baude --identity c:\Users\baude\.ssh\id_rsa ssh://192.168.122.1/run/user/1000/podman/podman.sock
```
This will add a remote connection to Podman and if it is the first connection added, it will mark the connection as the default. You can observe your connections with `podman system connection list`
```
C:\Users\baude> podman system connection list
Name Identity URI
baude* id_rsa ssh://baude@192.168.122.1/run/user/1000/podman/podman.sock
```
Now we can test the connection with `podman info`.
```
C:\Users\baude> podman info
host:
arch: amd64
buildahVersion: 1.16.0-dev
cgroupVersion: v2
conmon:
package: conmon-2.0.19-1.fc32.x86_64
```
Podman has also introduced a “--connection” flag where you can use other connections you have defined. If no connection is provided, the default connection will be used.
```
C:\Users\baude> podman system connection --help
```
## Wrap up
You can use the podman remote clients to manage your containers running on a Linux server. The communication between client and server relies heavily on SSH connections and the use of SSH keys are encouraged. Once you have Podman installed on your remote client, you should set up a connection using `podman system connection add` which will then be used by subsequent Podman commands.
## History
Originally published on [Red Hat Enable Sysadmin](https://www.redhat.com/sysadmin/podman-clients-macos-windows)

2
docs/tutorials/podman_tutorial.md
View File

@ -5,7 +5,7 @@ Podman is a utility provided as part of the libpod library. It can be used to c
containers. The following tutorial will teach you how to set up Podman and perform some basic
commands with Podman.
If you are running on a Mac, you should instead follow the [Mac tutorial](https://github.com/containers/podman/blob/master/docs/tutorials/mac_client.md)
If you are running on a Mac or Windows PC, you should instead follow the [Mac and Windows tutorial](https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md)
to set up the remote Podman client.
**NOTE**: the code samples are intended to be run as a non-root user, and use `sudo` where

168
docs/tutorials/remote_client.md
View File

@ -1,88 +1,112 @@
# Podman remote-client tutorial
## What is the remote-client
## Introduction
The purpose of the Podman remote-client is to allow users to interact with a Podman "backend" while on a separate client. The command line interface of the remote client is exactly the same as the regular Podman commands with the exception of some flags being removed as they do not apply to the remote-client.
First and foremost, the remote-client is under heavy development. We are adding new
commands and functions frequently. We also are working on a rootless implementation that
does not require privileged users.
The remote client takes advantage of a client-server model. You need Podman installed on a Linux machine or VM that also has the SSH daemon running. On the local operating system, when you execute a Podman command, Podman connects to the server via SSH. It then connects to the Podman service by using systemd socket activation, and hitting our [Rest API](https://docs.podman.io/en/latest/_static/api.html). The Podman commands are executed on the server. From the client's point of view, it seems like Podman runs locally.
The purpose of the Podman remote-client is to allow users to interact with a Podman "backend"
while on a separate client. The command line interface of the remote client is exactly the
same as the regular Podman commands with the exception of some flags being removed as they
do not apply to the remote-client.
This tutorial is for running Podman remotely on Linux. If you are using a Mac or a Windows PC, please follow the [Mac and Windows tutorial](https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md)
## What you need
To use the remote-client, you will need a binary for your client and a Podman "backend"; hereafter
referred to as the Podman node. In this context, a Podman node is a Linux system with Podman
installed on it and the varlink service activated. You will also need to be able to ssh into this
system as a user with privileges to the varlink socket (more on this later).
## Obtaining and installing Podman
## Building the remote client
At this time, the Podman remote-client is not being packaged for any distribution. It must be built from
source. To set up your build environment, see [Installation notes](https://github.com/containers/podman/blob/master/install.md) and follow the
section [Building from scratch](https://github.com/containers/podman/blob/master/install.md#building-from-scratch). Once you can successfully
build the regular Podman binary, you can now build the remote-client.
### Client machine
You will need either Podman or the podman-remote client. The difference between the two is that the compiled podman-remote client can only act as a remote client connecting to a backend, while Podman can run local, standard Podman commands, as well as act as a remote client (using `podman --remote`)
If you already have Podman installed, you do not need to install podman-remote.
You can find out how to [install Podman here](https://podman.io/getting-started/installation)
If you would like to install only the podman-remote client, it is downloadable from its [release description page](https://github.com/containers/podman/releases/latest). You can also build it from source using the `make podman-remote`
### Server Machine
You will need to [install Podman](https://podman.io/getting-started/installation) on your server machine.
## Creating the first connection
### Enable the Podman service on the server machine.
Before performing any Podman client commands, you must enable the podman.sock SystemD service on the Linux server. In these examples, we are running Podman as a normal, unprivileged user, also known as a rootless user. By default, the rootless socket listens at `/run/user/${UID}/podman/podman.sock`. You can enable this socket permanently using the following command:
```
$ make podman-remote
$ systemctl --user enable podman.socket
```
Like building the regular Podman, the resulting binary will be in the *bin* directory. This is the binary
you will run on the remote node later in the instructions.
## Setting up the remote and Podman nodes
To use the remote-client, you must perform some setup on both the remote and Podman nodes. In this case,
the remote node refers to where the remote-client is being run; and the Podman node refers to where
Podman and its storage reside.
### Podman node setup
Varlink bridge support is provided by the varlink cli command and installed using:
```
$ sudo dnf install varlink-cli
```
The Podman node must have Podman (not the remote-client) installed as normal. If your system uses systemd,
then simply start the Podman varlink socket.
```
$ sudo systemctl start io.podman.socket
```
If your system cannot use systemd, then you can manually establish the varlink socket with the Podman
command:
```
$ sudo podman --log-level debug varlink --timeout 0 unix://run/podman/io.podman
```
### Required permissions
For now, the remote-client requires that you be able to run a privileged Podman and have privileged ssh
access to the remote system. This limitation is being worked on.
### Remote node setup
#### Initiate an ssh session to the Podman node
To use the remote client, an ssh connection to the Podman server must be established.
Using the varlink bridge, an ssh tunnel must be initiated to connect to the server. Podman must then be informed of the location of the sshd server on the targeted server
You will need to enable linger for this user in order for the socket to work when the user is not logged in:
```
$ export PODMAN_VARLINK_BRIDGE=$'ssh -T -p22 root@remotehost -- "varlink -A \'podman varlink \$VARLINK_ADDRESS\' bridge"'
$ bin/podman-remote images
REPOSITORY TAG IMAGE ID CREATED SIZE
docker.io/library/ubuntu latest 47b19964fb50 2 weeks ago 90.7 MB
docker.io/library/alpine latest caf27325b298 3 weeks ago 5.8 MB
quay.io/cevich/gcloud_centos latest 641dad61989a 5 weeks ago 489 MB
k8s.gcr.io/pause 3.1 da86e6ba6ca1 14 months ago 747 kB
$ sudo loginctl enable-linger $USER
```
This is only required if you are not running Podman as root.
You can verify that the socket is listening with a simple Podman command.
```
$ podman --remote info
host:
arch: amd64
buildahVersion: 1.16.0-dev
cgroupVersion: v2
conmon:
package: conmon-2.0.19-1.fc32.x86_64
```
The PODMAN_VARLINK_BRIDGE variable may be added to your log in settings. It does not change per connection.
#### Enable sshd
If coming from a Windows machine, the PODMAN_VARLINK_BRIDGE is formatted as:
In order for the Podman client to communicate with the server you need to enable and start the SSH daemon on your Linux machine, if it is not currently enabled.
```
set PODMAN_VARLINK_BRIDGE=C:\Windows\System32\OpenSSH\ssh.exe -T -p22 root@remotehost -- varlink -A "podman varlink $VARLINK_ADDRESS" bridge
$ sudo systemctl enable -s sshd
```
The arguments before the `--` are presented to ssh while the arguments after are for the varlink cli. The varlink arguments should be copied verbatim.
- `-p` is the port on the remote host for the ssh tunnel. `22` is the default.
- `root` is the currently supported user, while `remotehost` is the name or IP address of the host providing the Podman service.
- `-i` may be added to select an identity file.
#### Setting up SSH
Remote Podman uses SSH to communicate between the client and server. The remote client works considerably smoother using SSH keys. To set up your ssh connection, you need to generate an ssh key pair from your client machine.
```
$ ssh-keygen
```
Your public key by default should be in your home directory under ~/.ssh/id_rsa.pub. You then need to copy the contents of id_rsa.pub and append it into ~/.ssh/authorized_keys on the Linux server. You can automate this using ssh-copy-id.
If you do not wish to use SSH keys, you will be prompted with each Podman command for your login password.
## Using the client
Note: `podman-remote` is equivalent to `podman --remote` here, depending on what you have chosen to install.
The first step in using the Podman remote client is to configure a connection.
You can add a connection by using the `podman-remote system connection add` command.
```
$ podman-remote system connection add myuser --identity ~/.ssh/id_rsa ssh://192.168.122.1/run/user/1000/podman/podman.sock
```
This will add a remote connection to Podman and if it is the first connection added, it will mark the connection as the default. You can observe your connections with `podman-remote system connection list`:
```
$ podman-remote system connection list
Name Identity URI
myuser* id_rsa ssh://myuser@192.168.122.1/run/user/1000/podman/podman.sock
```
Now we can test the connection with `podman info`:
```
$ podman-remote info
host:
arch: amd64
buildahVersion: 1.16.0-dev
cgroupVersion: v2
conmon:
package: conmon-2.0.19-1.fc32.x86_64
```
Podman-remote has also introduced a “--connection” flag where you can use other connections you have defined. If no connection is provided, the default connection will be used.
```
$ podman-remote system connection --help
```
## Wrap up
You can use the Podman remote clients to manage your containers running on a Linux server. The communication between client and server relies heavily on SSH connections and the use of SSH keys are encouraged. Once you have Podman installed on your remote client, you should set up a connection using `podman-remote system connection add` which will then be used by subsequent Podman commands.
## History
Adapted from the [Mac and Windows tutorial](https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md)

89
docs/tutorials/varlink_remote_client.md Normal file
View File

@ -0,0 +1,89 @@
# Podman varlink remote-client tutorial [DEPRECATED]
## What is the varlink client
This API has been deprecated by the [REST API](https://docs.podman.io/en/latest/_static/api.html).
For usage on Windows and Mac, please reference the [Podman Mac/Windows tutorial](https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md)
Varlink support is in maintenance mode, and will be removed in a future release.
For more details, you can see [this blog](https://podman.io/blogs/2020/01/17/podman-new-api.html).
The purpose of the Podman remote-client is to allow users to interact with a Podman "backend"
while on a separate client. The command line interface of the remote client is exactly the
same as the regular Podman commands with the exception of some flags being removed as they
do not apply to the remote-client.
## What you need
To use the remote-client, you will need a binary for your client and a Podman "backend"; hereafter
referred to as the Podman node. In this context, a Podman node is a Linux system with Podman
installed on it and the varlink service activated. You will also need to be able to ssh into this
system as a user with privileges to the varlink socket (more on this later).
## Building the remote client
At this time, the Podman remote-client is not being packaged for any distribution. It must be built from
source. To set up your build environment, see [Installation notes](https://github.com/containers/podman/blob/master/install.md) and follow the
section [Building from scratch](https://github.com/containers/podman/blob/master/install.md#building-from-scratch). Once you can successfully
build the regular Podman binary, you can now build the remote-client.
```
$ make podman-remote
```
Like building the regular Podman, the resulting binary will be in the *bin* directory. This is the binary
you will run on the remote node later in the instructions.
## Setting up the remote and Podman nodes
To use the remote-client, you must perform some setup on both the remote and Podman nodes. In this case,
the remote node refers to where the remote-client is being run; and the Podman node refers to where
Podman and its storage reside.
### Podman node setup
Varlink bridge support is provided by the varlink cli command and installed using:
```
$ sudo dnf install varlink-cli
```
The Podman node must have Podman (not the remote-client) installed as normal. If your system uses systemd,
then simply start the Podman varlink socket.
```
$ sudo systemctl start io.podman.socket
```
If your system cannot use systemd, then you can manually establish the varlink socket with the Podman
command:
```
$ sudo podman --log-level debug varlink --timeout 0 unix://run/podman/io.podman
```
### Required permissions
For now, the remote-client requires that you be able to run a privileged Podman and have privileged ssh
access to the remote system. This limitation is being worked on.
### Remote node setup
#### Initiate an ssh session to the Podman node
To use the remote client, an ssh connection to the Podman server must be established.
Using the varlink bridge, an ssh tunnel must be initiated to connect to the server. Podman must then be informed of the location of the sshd server on the targeted server
```
$ export PODMAN_VARLINK_BRIDGE=$'ssh -T -p22 root@remotehost -- "varlink -A \'podman varlink \$VARLINK_ADDRESS\' bridge"'
$ bin/podman-remote images
REPOSITORY TAG IMAGE ID CREATED SIZE
docker.io/library/ubuntu latest 47b19964fb50 2 weeks ago 90.7 MB
docker.io/library/alpine latest caf27325b298 3 weeks ago 5.8 MB
quay.io/cevich/gcloud_centos latest 641dad61989a 5 weeks ago 489 MB
k8s.gcr.io/pause 3.1 da86e6ba6ca1 14 months ago 747 kB
```
The PODMAN_VARLINK_BRIDGE variable may be added to your log in settings. It does not change per connection.
If coming from a Windows machine, the PODMAN_VARLINK_BRIDGE is formatted as:
```
set PODMAN_VARLINK_BRIDGE=C:\Windows\System32\OpenSSH\ssh.exe -T -p22 root@remotehost -- varlink -A "podman varlink $VARLINK_ADDRESS" bridge
```
The arguments before the `--` are presented to ssh while the arguments after are for the varlink cli. The varlink arguments should be copied verbatim.
- `-p` is the port on the remote host for the ssh tunnel. `22` is the default.
- `root` is the currently supported user, while `remotehost` is the name or IP address of the host providing the Podman service.
- `-i` may be added to select an identity file.