What is Podman?

Docker bases all its operation on a process (daemon) that manages the containers. This process is getting bigger and bigger over time and this can be a problem. So Podman uses the fork/exec model that allows it to run using a smaller amount of resources.

The main driver of the project is Red Hat that has seen how in this distribution and the derivatives like CentOS have been replaced Docker with Podman. However, the images and many commands are compatible which reduces the learning curve.

One of the main differences is the path where Podman saves the images.

So in short, Podman is a container integration engine. It allows you to manage them in much the same way as Docker. So it’s a simple transition.

Installing Podman on OpenSUSE 15.1

Podman has strong documentation where they explain, among other things, how to install it from the source code. However, let’s do a search within the official OpenSUSE repositories to see.

So, open a terminal session or connect to your server using SSH.

:~$ sudo zypper search podman
Loading repository data…
 Reading installed packages…
 S | Name              | Summary                                                               | Type   
 --+-------------------+-----------------------------------------------------------------------+--------
   | podman            | Daemon-less container engine for managing containers, pods and images | package
   | podman-cni-config | Basic CNI configuration for podman                                    | packageLoading repository data…
 Reading installed packages…
 S | Name              | Summary                                                               | Type   
 --+-------------------+-----------------------------------------------------------------------+--------
   | podman            | Daemon-less container engine for managing containers, pods and images | package
   | podman-cni-config | Basic CNI configuration for podman                                    | package

As we can see in the image and in the standard output, Podman is in the official OpenSUSE 15.1 repositories, so it is best to install it from there as there are no external pre-compiled binaries.

To do this, just use the following command:

:~$ sudo zypper in podman
Loading repository data…
 Reading installed packages…
 Resolving package dependencies…
 The following 16 NEW packages are going to be installed:
   catatonit cni cni-plugins criu libcontainers-common libnet9 libostree-1-1 libprotobuf-c1 libpython2_7-1_0 podman podman-cni-config python2-ipaddr python2-protobuf
   python-base runc slirp4netns
 The following 3 recommended packages were automatically selected:
   cni-plugins criu podman-cni-config
 16 new packages to install.
 Overall download size: 36,1 MiB. Already cached: 0 B. After the operation, additional 138,7 MiB will be used.
 Continue? y/n/v/…? shows all options:

At the end of the installation, Podman will be ready for work.

Testing Podman on OpenSUSE 15.1

The installation has been completed but we are going to test the operation.

To do so, I will download the image of Alpine. It is light and simple and will help us to test the operation of Podman.

:~$ sudo podman pull alpine
Trying to pull docker.io/alpine:latest…Getting image source signatures
 Copying blob c9b1b535fdd9: 2.67 MiB / 2.67 MiB [============================] 8s
 Copying config e7d92cdc71fe: 1.48 KiB / 1.48 KiB [==========================] 0s
 Writing manifest to image destination
 Storing signatures
 e7d92cdc71feacf90708cb59182d0df1b911f8ae022d29e8e95d75ca6a99776a

To check all the images that are downloaded to the system, execute the following command:

:~$ sudo podman images 
REPOSITORY                 TAG      IMAGE ID       CREATED       SIZE
 docker.io/library/alpine   latest   e7d92cdc71fe   5 weeks ago   5.86 MB

And finally, run Alpine’s image. Once inside the image, run a command to prove we’re at Alpine:

:~$ sudo podman run -it --rm docker.io/library/alpine /bin/sh
/ # cat /etc/os-release 
NAME="Alpine Linux"
ID=alpine
VERSION_ID=3.11.3
PRETTY_NAME="Alpine Linux v3.11"
HOME_URL="https://alpinelinux.org/"
BUG_REPORT_URL="https://bugs.alpinelinux.org/"
/ #

So, Podman is ready for the job.

Conclusion

Podman emerges as an alternative to Docker. As I always say, the competition only benefits the user and if Podman improves on the already excellent one made by Docker then it is welcome. So we’ll keep track of the project and now you know how to install it in OpenSUSE 15.1

Please share this post and join our Telegram channel.

The post How to install Podman on OpenSUSE 15.1? appeared first on Linux Windows and android Tutorials.

Podman provides a great way instead of Dockers to develop, manage and run OCI containers on your Linux System. It runs without the daemon process. Let’s move towards the Installation of Podman on Arch Linux / manjaro. The installation process would be easy as the packages are available on upstream repositories.

Installing Podman on Arch Linux / Manjaro

Firstly, update your Arch / Manjaro system.

sudo pacman -Syyu

After the packages are updated, proceed to Install Podman on your Linux system.

sudo pacman -S podman

Output:

 …………………………………………………………………………
 resolving dependencies…
 looking for conflicting packages…
 Packages (6) cni-plugins-0.8.1-1  conmon-1:0.3.0-1  ostree-2019.2-1  skopeo-0.1.37-1  slirp4netns-0.3.0-1  podman-1.4.2-1
 Total Download Size:    31.90 MiB
 Total Installed Size:  186.47 MiB
 :: Proceed with installation? [Y/n] y
 :: Retrieving packages…
  cni-plugins-0.8.1-1-x86_64                                       8.8 MiB   179K/s 00:50 [###################################################] 100%
  conmon-1:0.3.0-1-x86_64                                         21.0 KiB  1615K/s 00:00 [###################################################] 100%
  skopeo-0.1.37-1-x86_64                                           4.6 MiB   496K/s 00:09 [###################################################] 100%
  slirp4netns-0.3.0-1-x86_64                                      62.3 KiB  15.2M/s 00:00 [###################################################] 100%
  podman-1.4.2-1-x86_64     18.4 MiB   464K/s 00:41 [###############] 100%(6/6) checking keys in keyring                     [###############] 100%(6/6) checking package integrity                   [###############] 100%
 (6/6) loading package files                        [###############] 100%
 (6/6) checking for file conflicts                  [###############] 100%
 (6/6) checking available disk space                [###############] 100%
 :: Processing package changes…
 (1/6) installing cni-plugins                       [###############] 100%
 (2/6) installing conmon                            [###############] 100%
 (3/6) installing ostree                            [###############] 100%
 (4/6) installing skopeo                            [###############] 100%
 (5/6) installing slirp4netns                       [###############] 100%
 (6/6) installing podman                            [###############] 100%
 Optional dependencies for podman
     podman-docker: for Docker-compatible CLI
 :: Running post-transaction hooks…
 (1/4) Updating linux initcpios…
 ==> Building image from preset: /etc/mkinitcpio.d/linux.preset: 'default'
   -> -k /boot/vmlinuz-linux -c /etc/mkinitcpio.conf -g /boot/initramfs-linux.img
 ==> Starting build: 5.1.3-arch1-1-ARCH
   -> Running build hook: [base]
   -> Running build hook: [udev]
   -> Running build hook: [autodetect]
   -> Running build hook: [modconf]
   -> Running build hook: [block]
   -> Running build hook: [filesystems]
   -> Running build hook: [keyboard]
   -> Running build hook: [fsck]
 ==> Generating module dependencies
 ==> Creating gzip-compressed initcpio image: /boot/initramfs-linux.img
 ==> Image generation successful
 ==> Building image from preset: /etc/mkinitcpio.d/linux.preset: 'fallback'
   -> -k /boot/vmlinuz-linux -c /etc/mkinitcpio.conf -g /boot/initramfs-linux-fallback.img -S autodetect
 ==> Starting build: 5.1.3-arch1-1-ARCH
   -> Running build hook: [base]
   -> Running build hook: [udev]
   -> Running build hook: [modconf]
   -> Running build hook: [block]
 ==> WARNING: Possibly missing firmware for module: wd719x
 ==> WARNING: Possibly missing firmware for module: aic94xx
   -> Running build hook: [filesystems]
   -> Running build hook: [keyboard]
   -> Running build hook: [fsck]
 ==> Generating module dependencies
 ==> Creating gzip-compressed initcpio image: /boot/initramfs-linux-fallback.img
 ==> Image generation successful
 (2/4) Reloading system manager configuration…
 (3/4) Creating temporary files…
 (4/4) Arming ConditionNeedsUpdate…

You can confirm the Installation of podman by checking it’s version

$podman --version
podman version 1.4.2


 $ pacman -Qi podman
  Name            : podman
  Version         : 1.4.2-1
  Description     : Tool and library for running OCI-based containers in pods
  Architecture    : x86_64
  URL             : https://github.com/containers/libpod
  Licenses        : Apache
  Groups          : None
  Provides        : None
  Depends On      : cni-plugins  conmon  device-mapper  iptables  libseccomp  ostree  runc  skopeo  btrfs-progs  slirp4netns
  Optional Deps   : podman-docker: for Docker-compatible CLI
  Required By     : None
  Optional For    : None
  Conflicts With  : None
  Replaces        : None
  Installed Size  : 96.95 MiB
  Packager        : Bartłomiej Piotrowski bpiotrowski@archlinux.org
  Build Date      : Sun 23 Jun 2019 10:40:38 AM EAT
  Install Date    : Tue 25 Jun 2019 11:54:16 PM EAT
  Install Reason  : Explicitly installed
  Install Script  : No
  Validated By    : Signature

If you want to know in more details you can run the following command

$ sudo podman info
 host:
   BuildahVersion: 1.9.0
   Conmon:
     package: Unknown
     path: /usr/bin/conmon
     version: 'conmon version 0.3.0, commit: 8455ce1ef385120deb827d0f0588c04357bad4c4'
   Distribution:
     distribution: arch
     version: unknown
   MemFree: 665116672
   MemTotal: 16717189120
   OCIRuntime:
     package: Unknown
     path: /usr/bin/runc
     version: |-
       runc version 1.0.0-rc8
       commit: 425e105d5a03fabd737a126ad93d62a9eeede87f
       spec: 1.0.1-dev
   SwapFree: 8479567872
   SwapTotal: 8489267200
   arch: amd64
   cpus: 8
   hostname: techwiz.localhost
   kernel: 5.1.3-arch1-1-ARCH
   os: linux
   rootless: false
   uptime: 14h 44m 47.28s (Approximately 0.58 days)
 registries:
   blocked: null
   insecure: null
   search:
 docker.io
 registry.fedoraproject.org
 quay.io
 registry.access.redhat.com
 registry.centos.org
 store:
 ConfigFile: /etc/containers/storage.conf
 ContainerStore:
 number: 0
 GraphDriverName: overlay
 GraphOptions:
 overlay.mountopt=nodev
 GraphRoot: /var/lib/containers/storage
 GraphStatus:
 Backing Filesystem: extfs
 Native Overlay Diff: "false"
 Supports d_type: "true"
 Using metacopy: "true"
 ImageStore:
 number: 0
 RunRoot: /var/run/containers/storage
 VolumePath: /var/lib/containers/storage/volumes 

Testing Podman on Arch Linux / Manjaro

Download the Alpine Linux docker image.

$ podman pull alpine

Trying to pull docker.io/library/alpine…Getting image source signatures

Copying blob 921b31ab772b done

Copying config 4d90542f06 done

Writing manifest to image destination

Storing signatures

4d90542f0623c71f1f9c11be3da23167174ac9d93731cf91912922e916bab02c

You can list your downloaded images by running

podman images

Now, run the alpine image container to test our installation.

$ podman run --name test --rm docker.io/library/alpine "cat" etc/os-release
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.10.0
 PRETTY_NAME="Alpine Linux v3.10"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"

To know in more details follow the link below

How To Run Docker Containers using Podman & Libpod

The post How To Install Podman on Arch Linux / Manjaro appeared first on Linux Windows and android Tutorials.

Podman is used to develop, manage and run OCI Containers on our Linux System. It runs without starting daemon every time. In today tutorial, we will cover the installation of Podman on our Debian System.

Step 1: Updating your system

Update your system by running

sudo apt -y update && sudo apt -y upgrade

Step 2: Installing pre-requisites

In our case we are going to build the packages from source code. Install the required dependencies you want to use

sudo apt -y install \

gcc \

  make \

  cmake \

  git \

  btrfs-progs \

  golang-go \

  go-md2man \

  iptables \

  libassuan-dev \

  libc6-dev \

  libdevmapper-dev \

  libglib2.0-dev \

  libgpgme-dev \

  libgpg-error-dev \

  libostree-dev \

  libprotobuf-dev \

  libprotobuf-c-dev \

  libseccomp-dev \

  libselinux1-dev \

  libsystemd-dev \

  pkg-config \

  runc \

  uidmap \

  libapparmor-dev

Step 3: Installing common

Common is used to monitor OCI run times on your Linux System. Install the latest version of common on Debian by cloning.

git clone https://github.com/containers/common
cd common
sudo make podman
sudo cp /usr/local/libexec/podman/common /usr/local/bin/

Step 4: Installing CNI Plugins

Make sure that the CNI Plugins are installed on your system. If they are not installed yet, Install them by typing

git clone https://github.com/containernetworking/plugins.git $GOPATH/src/github.com/containernetworking/plugins
cd $GOPATH/src/github.com/containernetworking/plugins
./build_linux.sh
sudo mkdir -p /usr/libexec/cni
sudo cp bin/* /usr/libexec/cni

Step 5: Setting Up CNI Networking

Now, add the configuration files by

sudo mkdir -p /etc/cni/net.d
curl -qsSL https://raw.githubusercontent.com/containers/libpod/master/cni/87-podman-bridge.conflist | sudo tee /etc/cni/net.d/99-loopback.conf

Step 6: Populate Config files

You have to manually add configuration files like registry and policy files.

sudo mkdir -p /etc/containers
sudo curl https://raw.githubusercontent.com/projectatomic/registries/master/registries.fedora -o /etc/containers/registries.conf
sudo curl https://raw.githubusercontent.com/containers/skopeo/master/default-policy.json -o /etc/containers/policy.json

Step 7: Installing Podman

After doing all the above requirements, its time to download and Install Podman on your system.

git clone https://github.com/containers/libpod/ $GOPATH/src/github.com/containers/libpod
cd $GOPATH/src/github.com/containers/libpod
make
sudo make install

You can run the command podman version to check the installed version of podman

$ podman info
 host:
   BuildahVersion: 1.9.2
   Conmon:
     package: Unknown
     path: /usr/local/bin/conmon
     version: 'conmon version 1.0.1-dev, commit: 8392df88fba944510b51c7d5b92aa745a15863f8'
   Distribution:
     distribution: debian
     version: "10"
   MemFree: 6179495936
   MemTotal: 8167223296
   OCIRuntime:
     package: 'runc: /usr/sbin/runc'
     path: /usr/sbin/runc
     version: |-
       runc version 1.0.0~rc6+dfsg1
       commit: 1.0.0~rc6+dfsg1-3
       spec: 1.0.1
   SwapFree: 0
   SwapTotal: 0
   arch: amd64
   cpus: 2
   eventlogger: journald
   hostname: debian10
   kernel: 4.19.0-5-amd64
   os: linux
   rootless: false
   uptime: 13m 44.64s
 registries:
   blocked: null
   insecure: null
   search:
 docker.io
 registry.fedoraproject.org
 registry.access.redhat.com
 store:
 ConfigFile: /etc/containers/storage.conf
 ContainerStore:
 number: 0
 GraphDriverName: overlay
 GraphOptions: null
 GraphRoot: /var/lib/containers/storage
 GraphStatus:
 Backing Filesystem: extfs
 Native Overlay Diff: "true"
 Supports d_type: "true"
 Using metacopy: "false"
 ImageStore:
 number: 0
 RunRoot: /var/run/containers/storage
 VolumePath: /var/lib/containers/storage/volumes 

Here are the main configuration files.

• /etc/containers/regestries.conf : We use this file to store the registries of domain or new container images.
• /etc/containers/mounts.conf: Keeps the record of mounted directories.

Step 8: Testing Podman Installation on Debian

Download the Alpine image by running

$ podman pull alpine
Trying to pull docker.io/library/alpine…
Getting image source signatures
Copying blob 050382585609 done
Copying config b7b28af77f done
Writing manifest to image destination
Storing signatures
b7b28af77ffec6054d13378df4fdf02725830086c7444d9c278af25312aa39b9

Run Docker Container

[root@localhost sabi]# podman images
 REPOSITORY                 TAG      IMAGE ID       CREATED       SIZE
 docker.io/library/alpine   latest   b7b28af77ffe   3 weeks ago   5.85 MB
 $ podman run -ti b7b28af77ffe /bin/sh
 / # cat /etc/os-release 
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.10.1
 PRETTY_NAME="Alpine Linux v3.10"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/
 /# exit

You can remove the container by running the below command

[root@localhost sabi]# podman rm -f podman ps -aq
d16db8f39c82f50f3a2bbf4834d948b660525a5c2b98979e433c3428f613c18d

And that is it.

The post How To Install Podman on Debian on 10 / 9 appeared first on Linux Windows and android Tutorials.

How To Install podman on CentOS 8

As you know you can not run Docker containers without Docker Engine daemon.

Following tools will help you to power the use of Containers without an all time running daemon process.

Buildah:

It will facilitate building of OCI images.

Skopeo:

For sharing/findings container images on Docker registries, the Atomic registry, private registries, local directories and local OCI-layout directories.

Podman

Podman is used for running containers without the need of daemon.

Buildah’s commands replicate all of the commands that are found in Docker file. We create Buildah’s containers to allow to connect to be added back to the container image.

Podman helps us to have commands and functions required to maintain and modify OCI images, such as downloading, tagging and removing etc. It will give you access to create, run, and maintain containers created from those images.

Step 1: Installing Podman on Ubuntu

First of all the podman package is on a PPA repository which needs to be added prior to installation. For this start a new session on your Ubuntu system and run the below command.

sudo apt update
sudo apt-y install software-properties-common
sudo add-apt-repository -y ppa:projectatomic/ppa

After adding the repository, begin with the installation

sudo apt update
sudo apt -y install podman

Note: If you ran into any problems try the following for some version

How to fix issues with some ubuntu versions

When you’ve finish installing, you can display information related to the host, current storage stats, and build of podman.

podman  info
 host:
   BuildahVersion: 1.7-dev
   Conmon:
     package: 'cri-o-1.12: /usr/lib/crio/bin/conmon'
     path: /usr/lib/crio/bin/conmon
     version: 'conmon version 1.12.4-dev, commit: '
   Distribution:
     distribution: ubuntu
     version: "18.04"
   MemFree: 720404480
   MemTotal: 1033080832
   OCIRuntime:
     package: 'cri-o-runc: /usr/sbin/runc'
     path: /usr/sbin/runc
     version: 'runc version spec: 1.0.1-dev'
   SwapFree: 2047864832
   SwapTotal: 2047864832
   arch: amd64
   cpus: 2
   hostname: ubuntu-01
   kernel: 4.15.0-42-generic
   os: linux
   rootless: false
   uptime: 2m 5.03s
 insecure registries:
   registries: []
 registries:
   registries:
 docker.io
 registry.fedoraproject.org
 quay.io
 registry.access.redhat.com
 registry.centos.org
 store:
 ConfigFile: /etc/containers/storage.conf
 ContainerStore:
 number: 1
 GraphDriverName: overlay
 GraphOptions: null
 GraphRoot: /var/lib/containers/storage
 GraphStatus:
 Backing Filesystem: extfs
 Native Overlay Diff: "true"
 Supports d_type: "true"
 Using metacopy: "false"
 ImageStore:
 number: 2
 RunRoot: /var/run/containers/storage 

Populate Configuration files

You have to add manually configuration files like registry and policy files.

sudo mkdir -p /etc/containers
sudo curl https://raw.githubusercontent.com/projectatomic/registries/master/registries.fedora -o /etc/containers/registries.conf
sudo curl https://raw.githubusercontent.com/containers/skopeo/master/default-policy.json -o /etc/containers/policy.json

Step 2: Testing Podman Installation on Ubuntu

Download the Alpine docker image by pull command.

podman pull alpine

Type the following command to see the list of downloaded images.

podman images

Podman’s local repository is located in /var/lib/contianers

$ podman  run -it  --rm docker.io/library/alpine /bin/sh
 / # apk update
 fetch http://dl-cdn.alpinelinux.org/alpine/v3.9/main/x86_64/APKINDEX.tar.gz
 fetch http://dl-cdn.alpinelinux.org/alpine/v3.9/community/x86_64/APKINDEX.tar.gz
 v3.9.2-1-g592d872fb8 [http://dl-cdn.alpinelinux.org/alpine/v3.9/main]
 v3.9.2-2-ge7dc3349a9 [http://dl-cdn.alpinelinux.org/alpine/v3.9/community]
 OK: 9754 distinct packages available
 / # apk add vim
  (1/5) Installing lua5.3-libs (5.3.5-r1)
  (2/5) Installing ncurses-terminfo-base (6.1_p20190105-r0)
  (3/5) Installing ncurses-terminfo (6.1_p20190105-r0)
  (4/5) Installing ncurses-libs (6.1_p20190105-r0)
  (5/5) Installing vim (8.1.0630-r0)
  Executing busybox-1.29.3-r10.trigger
  OK: 40 MiB in 19 packages
  / # exit

List the running containers by

podman ls

If you want to learn in more details then check out the below link

How To Run Docker Containers using Podman and Libpod.

The post How To Install Podman on Ubuntu appeared first on Linux Windows and android Tutorials.

Docker CLI working

Docker CLI operates as a client/server to communicate with the Docker engine upon creation of operations of a container. But it will raise issues when you have to start the Docker daemon before accessing Docekr CLI live. After it CLI sends API call to the Docker Engine to launch Open Contianer Initiative (OCI) runtime.

Difference between Docker and Podman

One of the main difference between Docker and Podman is that there is no daemon in the Podman. Upon applying any cgroup constraints you apply on the podman command containers will recieve those constraints directly. Moreover, advanced features of systemd can be utilized using this model.

Libpod

Libpod provides the library for those applications which are looking to use the Container Pod concept. It is also refereed as the Home of Podman.
So now lets proceed further

Step 1: Managing Container Images

Type the below command to download the container Images using Podman

$ podman pull ubuntu
$ podman pull centos
$ podman pull centos:8

Run the below command to list the downloaded images

$ podman  images
 REPOSITORY                 TAG      IMAGE ID       CREATED        SIZE
 docker.io/library/ubuntu   latest   3556258649b2   2 weeks ago    66.6 MB
 docker.io/library/alpine   latest   b7b28af77ffe   3 weeks ago    5.85 MB
 docker.io/library/debian   latest   00bf7fdd8baf   4 weeks ago    119 MB
 docker.io/library/centos   latest   9f38484d220f   4 months ago   209 MB

Follow the below syntax to remove the images

$ podman rmi <Type your Container Image ID here>
$ podman rmi 00bf7fdd8baf
 00bf7fdd8baf2ba6f0918e1f48415b2a4a1a616806e7cf32527a749dd2ce4b2c
 $ podman rmi docker.io/library/ubuntu
 3556258649b2ef23a41812be17377d32f568ed9f45150a26466d2ea26d926c32

Tagging Image

Check out the tag by running podman images command

podman tag  <Image ID> webserver

Step 2: Running Containers with Podman

Let’s print a message using simple container

[sabi@localhost ~]$ podman run --rm centos /bin /echo/ "Osradar"
Osradar

Use -d option to run the container in background

podman run -dt -p 8080:8080/tcp -e HTTPD_VAR_RUN=/var/run/httpd -e HTTPD_MAIN_CONF_D_PATH=/etc/httpd/conf.d \

                  -e HTTPD_MAIN_CONF_PATH=/etc/httpd/conf \

                  -e HTTPD_CONTAINER_SCRIPTS_PATH=/usr/share/container-scripts/httpd/ \

                  registry.fedoraproject.org/f29/httpd /usr/bin/run-httpd

It will return the contianer ID:

Trying to pull registry.fedoraproject.org/f29/httpd…Getting image source signatures
 Copying blob d77ff9f653ce done
 Copying blob aaf5ad2e1aa3 done
 Copying blob 7692efc5f81c done
 Copying config 25c76f9dcd done
 Writing manifest to image destination
 Storing signatures
 d2cdf0efb0ddc6e2ae52a5a0bdadababa6ee6cc2e1e49145c92a0474b089b664

To List the running containers, use the below command

$ podman ps
 CONTAINER ID  IMAGE                                        COMMAND               CREATED        STATUS            PORTS                   NAMES
 d2cdf0efb0dd  registry.fedoraproject.org/f29/httpd:latest  container-entrypo…  4 minutes ago  Up 4 minutes ago  0.0.0.0:8080->8080/tcp  cranky_borg
 To include stopped / exited containers, use:
 $ podman ps --all

For accessing a container shell use the option -it

podman run -it ubuntu bash
 root@d273c12899cd:/#
 root@d273c12899cd:/# apt update
  Get:1 http://archive.ubuntu.com/ubuntu bionic InRelease [242 kB]
  Get:2 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]          
  Get:3 http://security.ubuntu.com/ubuntu bionic-security/universe amd64 Packages [717 kB]
  Get:4 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]        
  Get:5 http://security.ubuntu.com/ubuntu bionic-security/main amd64 Packages [535 kB]
  Get:6 http://archive.ubuntu.com/ubuntu bionic-backports InRelease [74.6 kB]

Step 3: Searching in Podman

podman search httpd

Inspect Containers

It will display the some basic info on containers & images identified by name or ID

podman inspect <image id>

For help run the below command

podman inspect --help

Step 4: Removing Containers

To remove the containers, list all running containers.

podman ps -a

Now type the command podman rm with the ID of container image to remove it.

podman rm <image id>

For removing all containers, type the following command.

Note it will remove all containers running and stopped.

podman rm $(podman ps -a -q)

Step 5: View the container’s logs

Here we will view the containers logs in different ways

View by latest category

podman logs --latest

View by mentioning container ID:

podman p
podman logs <image id>

For attaining real-time, use the below command

podman logs -f 
podman logs --follow=true --since 10m Container ID

You can also specify the number of lines in logs:

podman logs --tail 10 

Step 6: View the container’s pids

Type podman top to view container pids.

podman top <image id>

Output:

$ podman top d2cdf0efb0dd
 USER      PID   PPID   %CPU    ELAPSED            TTY     TIME   COMMAND
 default   1     0      0.000   29m22.496484247s   pts/0   0s     httpd -D FOREGROUND 
 default   22    1      0.000   29m21.496767511s   pts/0   0s     /usr/bin/coreutils --coreutils-prog-shebang=cat /usr/bin/cat 
 default   23    1      0.000   29m21.496866314s   pts/0   0s     /usr/bin/coreutils --coreutils-prog-shebang=cat /usr/bin/cat 
 default   24    1      0.000   29m21.497020539s   pts/0   0s     /usr/bin/coreutils --coreutils-prog-shebang=cat /usr/bin/cat 
 default   25    1      0.000   29m21.497127237s   pts/0   0s     /usr/bin/coreutils --coreutils-prog-shebang=cat /usr/bin/cat 
 default   26    1      0.000   29m21.49723933s    pts/0   0s     httpd -D FOREGROUND 
 default   27    1      0.000   29m21.497361006s   pts/0   0s     httpd -D FOREGROUND 
 default   28    1      0.000   29m21.497459891s   pts/0   0s     httpd -D FOREGROUND 
 default   29    1      0.000   29m21.497552695s   pts/0   0s     httpd -D FOREGROUND 

Step 7: Checkpointing the container

Checkpointing a container stops the container while writing the state of all processes in the container to disk. To do this you’ll requires CRIU 3.11 or later installed on the system.

See CRIU Installation guide here.

podman container checkpoint <container id>

Example:

podman container checkpoint d1hf0dbf0dd

It can later be restored and continue running exactly at the same point in time as the checkpoint.

podman container restore <container id>

Step 8: Migrate Container

Migrating the container contains 3 steps.

In first step, checkpoint the container on the source system.

podman container checkpoint <container id> -e /tmp/checkpoint.tar.gz

In Second Step copy it to the destination server.

scp /tmp/checkpoint.tar.gz :/tmp

Last step involve the restoration on the destination system.

Step 9: Manage Container pods with Podman

Podman pods are similar to the Kubernetes concept of Pods.

You can expose most of the interaction with pods through the podman pod command.

podman pod --help

Create a pod called web

podman pod create --name web

Below will creates a pod without the extra attributes available on:

podman pod create --help

Make sure pod is created

podman pod list

By default, the created pod will have a container called infra. The infra container holds the namespace associated with the pod to allow podman to connect to the containers to the pod. It is in sleep mode by default.

podman ps -a --pod

After creating pod, we can add a container to it.

podman run -dt --pod web alpine:latest top

You’ll see that the pod has two containers.

podman ps -a --pod
CONTAINER ID  IMAGE                            COMMAND  CREATED             STATUS                 PORTS  NAMES               POD
 36ccace2d653  docker.io/library/alpine:latest  top      About a minute ago  Up About a minute ago         zen_hugle           0f565b11e9cb
 44cca777d12f  k8s.gcr.io/pause:3.1                      28 minutes ago      Up 28 minutes ago             0f565b11e9cb-infra  0f565b11e9cb

You can also expose a port to the created container with root privileges.

sudo podman pod create -p 8080:80 --name web1
sudo podman run -dt --pod web1 -p  8080 nginx:latest

You need to publish as many port as will be used during the pod creation. This can't be changed after the creation.

So this is how we can run Docker Container using podman and libpod.

The post How To run Docker Containers using Podman and Libpod. appeared first on Linux Windows and android Tutorials.