Deploying and Managing Podman PaaS Instances

LYNIO Cloud Podman PaaS provides a lightweight, daemonless Platform-as-a-Service environment built directly on top of LYNIO Compute Instances. With Podman PaaS, you can deploy and run OCI-compliant containerized workloads without the overhead of managing a Kubernetes cluster or Docker daemon.

Pods, containers, images, and volumes can be managed visually through the Lynio Console or fully automated using Gitea Actions and GitHub Actions via the Lynio Deployment Action (lynio-action-deploy).

Key Features

• Daemonless Container Management: Native Podman integration for rootless, secure container execution.
• Console Orchestration: Provision instances, inspect running containers, view real-time CPU/RAM metrics, and configure environment variables directly from the console.
• Image & Volume Management: Sub-browsers in the console to manage container images and persistent storage volumes.
• One-Click Application Presets: Quick-deploy standard application templates like Nginx, Redis, PostgreSQL, and Traefik.
• Automated CI/CD Workflows: Deploy containers automatically on code push using OAuth2 Application Credentials.
• Integrated VPC Networking: Route traffic securely using Lynio Security Lists and Floating IPs.

Prerequisites

Before setting up a Podman PaaS instance, ensure you have:

• An active LYNIO Cloud Account.
• A configured Virtual Private Cloud (VPC) with at least one active subnet.
• An SSH Key added to your organization (recommended for direct terminal access).

Provisioning a Podman PaaS Instance

Launching a Podman PaaS node is as simple as creating a standard Compute Instance.

1. Log in to the Lynio Console.
2. Navigate to Compute > Instances in the main sidebar.
3. Click Create Instance.
4. Set the Instance Type to Podman PaaS.
5. Select your desired compute shape (e.g., c1.medium or c1.large based on your container resource needs).
6. Select your VPC Subnet and attach an SSH key.
7. Click Deploy Instance.

Once provisioned, the instance status will transition to Running, and the underlying Podman runtime and Lynio Node Agent (lynio-guest-agent) will initialize automatically.

Managing Containers via Lynio Console

After your Podman PaaS instance is operational, click on the instance name in Compute > Instances to open the Podman PaaS Dashboard. The dashboard contains three main tabs: Containers, Images, and Volumes.

1. Deploying a Container Manually

1. Click Deploy Container in the top right of the dashboard.
2. Select a Quick Preset (optional):
   • Nginx: Lightweight HTTP server (exposes port 80).
   • Redis: In-memory key-value cache (exposes port 6379).
   • PostgreSQL: Relational database engine (exposes port 5432).
   • Traefik: Modern HTTP reverse proxy and load balancer (exposes ports 80 and 8080).
3. Or manually configure the deployment settings:
   • Container Name: A unique identifier for your container (e.g., web-frontend).
   • Container Image: The full OCI image name (e.g., nginx:alpine or registry.lynio.cloud/my-org/my-app:v1.0.0).
   • Port Mappings: Map host ports to container ports (e.g., 8080:80).
   • Environment Variables: Add key-value pairs required by your application (e.g., NODE_ENV=production, DATABASE_URL=...).
   • Volume Mounts: Mount host paths or Podman named volumes to container directories (e.g., app-data:/var/lib/data).
   • Restart Policy: Select always, unless-stopped, or no.
4. Click Launch Container.

2. Live Performance Metrics & Lifecycle Controls

The Containers tab provides real-time monitoring and lifecycle operations:

• Live CPU % and RAM Stats: Streams real-time resource utilization with periodic sampling so you can identify resource bottlenecks instantly.
• Lifecycle Buttons: Start, Stop, or Restart containers with a single click without opening an SSH terminal.
• Force Delete: Gracefully stop and permanently remove container instances.

3. Log Viewer & Inspection Drawer

• Terminal Log Viewer: Click Logs on any container to open a dark monospace modal displaying streaming standard output (stdout) and error logs (stderr).
• Inspect Drawer: Click Inspect to open a side panel showing raw JSON runtime specifications, network IP assignments, environment variables, and active volume bindings.

Managing Images & Persistent Volumes

1. Image Sub-Browser (Images Tab)

From the Images tab on the Podman PaaS Dashboard, you can:

• Browse Local Images: View all cached OCI images, image tags, sizes, and image IDs stored on the instance host.
• Pull New Image: Click Pull Image and specify any image tag from public registries (Docker Hub, Quay.io) or private registries (git.lynio.cloud).
• Delete Unused Images: Remove unused or dangling container images to free up host disk space.

2. Volume Sub-Browser (Volumes Tab)

Containers are ephemeral by default. To preserve data across container reinstantiations:

• List Storage Volumes: View all Podman named storage volumes, mount points, and driver details.
• Create Volume: Click Create Volume to allocate a new persistent storage volume on the host.
• Bind to Container: Reference the volume name in your container deployment settings under Volume Mounts (e.g., my-db-data:/var/lib/postgresql/data).
• Delete Volume: Remove unattached storage volumes when no longer needed.

Automating Deployments with CI/CD (Git Actions)

You can automate container deployments to your Podman PaaS instances whenever code is pushed to your repository using Gitea Actions or GitHub Actions.

Step 1: Register an Application in Lynio IAM

To allow your CI/CD runner to communicate with the Podman PaaS service securely:

1. Open the Lynio Console and go to IAM > Applications.
2. Click Create Application.
3. Fill in the details:
   • Name: Gitea Deployment Bot
   • Type: service
   • Scopes: openid profile email
4. Click Save and safely store the generated credentials:
   • client_id
   • client_secret (shown only once)

Step 2: Store Secrets in Your Git Repository

In your Gitea or GitHub repository, navigate to Settings > Actions > Secrets and add:

Step 3: Create the Workflow File

Create .gitea/workflows/deploy.yml (or .github/workflows/deploy.yml) in your repository:

name: Deploy to Podman PaaS

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Deploy Container to Podman PaaS
        uses: https://git.lynio.cloud/lynio-actions/deploy@main
        with:
          iam_url: 'https://iam.lynio.cloud'
          core_url: 'https://api.lynio.cloud'
          client_id: ${{ secrets.LYNIO_CLIENT_ID }}
          client_secret: ${{ secrets.LYNIO_CLIENT_SECRET }}
          instance_id: 'podman-paas-01'  # Instance Hostname or ID
          name: 'my-web-app'
          image: 'nginx:alpine'
          ports: '8080:80'
          env: |
            NODE_ENV=production
            PORT=80
          volumes: 'app-data:/app/data'
          restart_policy: 'always'
          force_pull: 'true'
          recreate: 'true'

Action Input Reference

The lynio-action-deploy action supports the following inputs:

Core API Endpoints Reference

For custom integrations or CLI automation, Podman PaaS provides REST endpoints on the Lynio Core API:

• OAuth2 Token: POST /oauth2/token (grant_type=client_credentials)
• Deploy Container: POST /api/v1/nodes/{instance_id}/containers
• Container Stats: GET /api/v1/nodes/{instance_id}/containers/stats?container={name}
• Restart Container: POST /api/v1/nodes/{instance_id}/containers/restart
• Inspect Container: GET /api/v1/nodes/{instance_id}/containers/inspect?container={name}
• List Images: GET /api/v1/nodes/{instance_id}/podman/images
• Pull Image: POST /api/v1/nodes/{instance_id}/podman/images/pull
• Delete Image: DELETE /api/v1/nodes/{instance_id}/podman/images/{id}
• List Volumes: GET /api/v1/nodes/{instance_id}/podman/volumes
• Create Volume: POST /api/v1/nodes/{instance_id}/podman/volumes
• Delete Volume: DELETE /api/v1/nodes/{instance_id}/podman/volumes/{name}
• Delete Container: DELETE /api/v1/nodes/{instance_id}/containers/{container_name}

Troubleshooting & Best Practices

• Container Fails to Start: Check container logs in the Lynio Console or inspect port conflicts on host ports.
• Persistent Data: Always use named Podman volumes for database or stateful workloads so data persists across container reinstantiations.
• Private Image Registries: Ensure you run podman login on the host or pass registry access tokens via environment variables.
• Network Ingress: To expose container ports publicly, assign a Floating IP to the Podman PaaS instance and configure ingress rules in your Security List.