Podman Machine

 Podman Machine é um recurso que ajuda a criar uma máquina virtual (VM) com Fedora CoreOS básico para usar com contêineres e cargas de trabalho em contêiner.

Para iniciar uma vm com podman use o comando

podman machine init <nome da vm > se não use ele vai usar um nome default

$ podman machine init

$ podman machine init fcoreos

use o comando podman machine start <nome da vm >para iniciar a vm se não colocar o nome ele inicia a vm default

$ podman machine start fcoreos

Pode listar as vm que tu tens e se estão rodando ou não com o comando podman machine list

$ podman machine list

e para acessar a VM use o comando

podman machine ssh <nome da vm>onde irar acessar via ssh a VM se não colocar o nome ele ira acessar a mv default caso esteja rodando se não ele não vai conectar via ssh e tem que por o nome da vm para acessar

$ podman machine ssh fcoreos

E para parar a VM digite o comando

podman machine stop <nome da vm> caso esteja usando a vm default não precisa por o nome , mas caso contrário

tem que por o nome da vm que esta rodando

Tem o comando podman machine --help onde ajudar

$ podman machine --help

Espero que ajude

Guia de Referencia :

https://opensource.com/article/21/7/linux-podman

http://docs.podman.io/en/latest/markdown/podman-machine.1.html

ManageIQ em Podman

 Um dia rápida pra subir o MaangeIQ via podman

efetue o pull da imagem

$ sudo podman pull docker.io/manageiq/manageiq:latest

Agora vamos subir 

$ sudo podman run -d -p 8443:443 --name manageiq namageiq

Só acessar agora 

Fedora CoreOS K3S AWX

Uma dica rápida pra subir o AWX no Fedora CoreOS com K3S

Primeiro, vamos instalar o pacote k3s-selinux via rpm-ostree:

# rpm-ostree install https://github.com/k3s-io/k3s-selinux/releases/download/v0.3.stable.0/k3s-selinux-0.3-0.el8.noarch.rpm

Reinicie 

#  systemctl reboot

Agora vamos fazer a instalação do k3s:

# export K3S_KUBECONFIG_MODE="644"

# export INSTALL_K3S_EXEC="--flannel-backend=host-gw"

# curl -sfL https://get.k3s.io | sh -

Vamos criar o diretório para o  Persistent Volume

#mkdir -p /var/k8s-pv/awx-postgres

# cat <<EOF >> awx-postgres-pv.yml

apiVersion: v1

kind: PersistentVolume

metadata:

  name: postgres-awx-postgres-0

  labels:

    type: local

spec:

  capacity:

    storage: 10Gi

  accessModes:

    - ReadWriteOnce

  hostPath:

    path: "/var/k8s-pv/awx-postgres"

EOF

cria um arquivo agora 

# echo "

apiVersion: awx.ansible.com/v1beta1

kind: AWX

metadata:

  name: awx

spec:

  tower_ingress_type: Ingress

" > awx.yml

Agora vamos executar 

# kubectl apply -f awx-postgres-pv.yml

# kubectl apply -f https://raw.githubusercontent.com/ansible/awx-operator/devel/deploy/awx-operator.yaml

# kubectl apply -f awx.yml

Agora só acompanhar vendo os logs 

kubectl logs -f awx-operator-........

e ao final 

Verifique em qual porta esta rodando o awx no caso na porta 30922

 # kubectl get svc 

e verifique a senha de admin 

# kubectl get secret awx-admin-password -o jsonpath='{.data.password}' | base64 --decode

e só acessar agora 

 

Joomla no Podman

Bom, vamos rodar o Joomla via podman.

Vamos criar o nosso pod primeiramente:

$ podman pod create --name joomlapod --publish 8080:80

vamos rodar o mariadb:

$ podman run -dit --pod joomlapod \
-e MYSQL_DATABASE=joomla \
-e MYSQL_USER=joomlauser \
-e MYSQL_PASSWORD=joomlapassword \
-e MYSQL_ROOT_PASSWORD=joomla \
--name mariadb docker.io/library/mariadb

Agora vamos rodar o Joomla:

$ podman run -dit --pod joomlapod \
-e JOOMLA_DB_HOST=127.0.0.1 \
-e JOOMLA_DB_USER=joomlauser \
-e JOOMLA_DB_PASSWORD=joomlapassword \

-e JOOMLA_DB_NAME=joomla \

--name joomla docker.io/library/joomla


Pronto só acessar a web http://<seu ip>:8080 e finalizar as configurações.

JENKINS NO PODMAN

 Uma dica rápida pra rodar o Jenkins no Podman.

Cria um diretório no seu /home:

$ mkdir jenkins

Agora vamos subir o contêiner no Podman:

$ sudo podman run --privileged -dit
             --name jenkins
             -p 8080:8080  
             -p 50000:50000
             -v ${PWD}/jenkins:/var/jenkins_home  
             jenkins/jenkins:lts

Pronto, já esta rodando!

Visualize o conteúdo no diretório criado do Jenkins:

Temos 2 maneiras de conseguir a senha de admin do Jenkins:

1. Pelos logs do contêiner no Podman:

$ sudo podman logs --tail 20 jenkins

2. Direto no arquivo "initialAdminPassword" localizado dentro do diretório secrets:

$ cat jenkins/secrets/initialAdminPassword

Só acessar via browser na porta 8080:

http://localhost:8080

e logar com a senha.

Tu podes escolher os plugins a serem instalados ou instalar os plugins padrões, que é a primeira opção.

INSTALANDO OS PLUGINS

Define um usuário ou podes usar a conta de admin, melhor ter um usuário.

Pronto, já podes usar o Jenkins!

Guia de Referencia : Jenkins

LAMP EM CONTÊINER COM PODMAN

 Vamos subir rapidamente um ambiente LAMP em nossa máquina de maneira simples e fácil, tudo rodando em contêineres.

Vamos criar criar 2 diretórios em nosso /home/ , onde um deles será o diretório da aplicação e o outro para o banco de dados MySQL:

 mkdir app
 mkdir mysql

Agora, vamos subir o servidor LAMP:

$ sudo podman run --privileged -dit
            --name lamp
            -p 8080:80
            -p 3306:3306
            -v ${PWD}/app:/app
            -v ${PWD}/mysql:/var/lib/mysql
            mattrayner/lamp:latest

Verificar se está rodando:

 sudo podman ps

Vamos setar um usuário e senha no MySQL:

$ sudo podman exec lamp mysql -u root -e "GRANT ALL PRIVILEGES ON *.* TO 'danniel'@'%' IDENTIFIED BY 'fedora';"
$ sudo podman exec lamp mysql -u root -e "FLUSH PRIVILEGES;"

Podemos verificar se está tudo ok, acesse via browser: http://localhost:8080

PhpMyAdmin: http://localhost:8080/phpmyadmin

Guia de Referencia :

Fedora Silverblue Ambiente LAMP

NEXTCLOUD VIA PODMAN COM POD

Uma dica rápida para subir o NextCloud via podman rapidamente.

Bom vamos criar 01 diretório e 03 subdiretórios:

$ mkdir -p nextcloud/app
$ mkdir nextcloud/data
$ mkdir nextcloud/db

Agora vamos criar o nosso Pod:

$ podman pod create --name ncloud -p8080:80

E agora vamos subir o contêiner do MariaDB:

$ podman run -d --pod=ncloud \
     --env MYSQL_DATABASE=nextcloud \
     --env MYSQL_USER=nextcloud \
     --env MYSQL_PASSWORD=nextcloud \
     --env MYSQL_ROOT_PASSWORD=nextcloud \
      -v ~/nexcloud/db:/var/lib/mysql:Z \
     --restart always \
     --name nextcloud-db \
     docker.io/library/mariadb:10

Agora vamos subir o contêiner do NextCloud:

$ podman run -d --pod=ncloud \
  --env MYSQL_HOST=127.0.0.1 \
  --env MYSQL_DATABASE=nextcloud \
  --env MYSQL_USER=nextcloud  \
  --env MYSQL_PASSWORD=nextcloud \
  --env NEXTCLOUD_ADMIN_USER=nextcloud \
  --env NEXTCLOUD_ADMIN_PASSWORD=nextcloud \
  -v ~/nextcloud/app:/var/www/html \
  -v ~/nextcloud/data:/var/www/html/data \
  --restart always  \
  --name nextcloud  \
  docker.io/library/nextcloud:20

Verifique se ficou ok:

$ podman ps

Pronto, só acessar pelo seu browser: http://localhost:8080

Caso tenha o cockpit, pode visualizar por lá também:

Guia de referência: 

Nextcloud With Podman

RODANDO WILDFLY NO PODMAN

 Bom, primeiro vamos fazer o pull da imagem:

$ podman pull jboss/wildfly

Agora vamos subir nosso contêiner:

$ podman run -d --name wildfly -p 8080:8080 -p 9990:9990 jboss/wildfly

Agora vamos acessar o nosso contêiner e criar um usuário para o console de administração, caso queira:

$ podman exec -it wildfly /bin/bash

Vamos criar um usuário:

$ /opt/jboss/wildfly/bin/add-user.sh

Só acessar via browser: http://<ip ou hostname>:8080

Ou, acesso via console admin: http://<ip ou hostname>:9990

Guia de Referencia: 

Getting Started With Podman

GITLAB NO PODMAN

 Crie o diretório "gitlab" no seu Home:

$ mkdir gitlab

Agora, dentro do "gitlab", vamos criar 3 diretórios "logs", "data" e "config":

$ mkdir gitlab/config
$ mkdir gitlab/logs
$ mkdir gitlab/data

Agora vamos rodar o Gitlab no Podman:

$ sudo podman run --privileged -dit \
            --name gitlab \
            -p80:80 \
            -p443:443 \
            -p22022:22 \
            -v ${PWD}/gitlab/config:/etc/gitlab \
            -v ${PWD}/gitlab/logs/:/var/log/gitlab \
            -v ${PWD}/gitlab/data/:/var/opt/gitlab \
            gitlab/gitlab-ce:latest

Feito, já esta rodando:

Agora é só acessar o Gitlab: