Master Ansible Automation for Docker, Podman, and Kubernetes

- name: Install Docker on Ubuntu
  hosts: docker_hosts
  become: true
  tasks:
    - name: Install prerequisites
      ansible.builtin.apt:
        name:
          - apt-transport-https
          - ca-certificates
          - curl
          - gnupg
          - lsb-release
        state: present

    - name: Add Docker GPG key
      ansible.builtin.apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present

    - name: Add Docker repository
      ansible.builtin.apt_repository:
        repo: "deb https://download.docker.com/linux/ubuntu {{ ansible_distribution_release }} stable"
        state: present

    - name: Install Docker
      ansible.builtin.apt:
        name:
          - docker-ce
          - docker-ce-cli
          - containerd.io
        state: present
        update_cache: true

    - name: Start Docker service
      ansible.builtin.systemd:
        name: docker
        state: started
        enabled: true

- name: Manage Docker images
  community.docker.docker_image:
    name: nginx
    tag: "1.25"
    source: pull
    state: present

- name: Build custom image
  community.docker.docker_image:
    name: myapp
    tag: "{{ app_version }}"
    source: build
    build:
      path: ./docker/
      dockerfile: Dockerfile
    state: present

- name: Run nginx container
  community.docker.docker_container:
    name: web
    image: nginx:1.25
    state: started
    restart_policy: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /opt/nginx/conf:/etc/nginx/conf.d:ro
      - /opt/nginx/html:/usr/share/nginx/html:ro
    env:
      NGINX_HOST: "example.com"
    networks:
      - name: app_network

- name: Deploy with Docker Compose
  community.docker.docker_compose_v2:
    project_src: /opt/myapp
    state: present
  register: compose_output

- name: Show running containers
  ansible.builtin.debug:
    msg: "{{ compose_output.services }}"

- name: Create Docker network
  community.docker.docker_network:
    name: app_network
    driver: bridge
    ipam_config:
      - subnet: 172.20.0.0/16

- name: Create Docker volume
  community.docker.docker_volume:
    name: app_data
    state: present

ansible-galaxy collection install containers.podman

- name: Run container with Podman
  containers.podman.podman_container:
    name: web
    image: docker.io/library/nginx:latest
    state: started
    ports:
      - "8080:80"
    volumes:
      - /opt/html:/usr/share/nginx/html:ro

- name: Run rootless Podman container
  containers.podman.podman_container:
    name: app
    image: quay.io/myorg/myapp:latest
    state: started
    user: appuser
    env:
      DATABASE_URL: "postgresql://db:5432/myapp"

- name: Pull image
  containers.podman.podman_image:
    name: docker.io/library/redis
    tag: "7-alpine"

- name: Build from Containerfile
  containers.podman.podman_image:
    name: myapp
    tag: latest
    path: ./containers/
    build:
      file: Containerfile

- name: Create systemd service from container
  containers.podman.podman_container:
    name: web
    image: nginx:latest
    state: started
    generate_systemd:
      path: /etc/systemd/system/
      restart_policy: always

ansible-galaxy collection install kubernetes.core

- name: Create namespace
  kubernetes.core.k8s:
    state: present
    definition:
      apiVersion: v1
      kind: Namespace
      metadata:
        name: myapp-production

- name: Deploy application
  kubernetes.core.k8s:
    state: present
    definition:
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: myapp
        namespace: myapp-production
      spec:
        replicas: 3
        selector:
          matchLabels:
            app: myapp
        template:
          metadata:
            labels:
              app: myapp
          spec:
            containers:
              - name: myapp
                image: "myregistry/myapp:{{ app_version }}"
                ports:
                  - containerPort: 8080
                resources:
                  requests:
                    memory: "128Mi"
                    cpu: "250m"
                  limits:
                    memory: "256Mi"
                    cpu: "500m"

- name: Expose service
  kubernetes.core.k8s:
    state: present
    definition:
      apiVersion: v1
      kind: Service
      metadata:
        name: myapp-service
        namespace: myapp-production
      spec:
        selector:
          app: myapp
        ports:
          - port: 80
            targetPort: 8080
        type: ClusterIP

- name: Apply all manifests from directory
  kubernetes.core.k8s:
    state: present
    src: "{{ item }}"
  loop: "{{ lookup('fileglob', 'manifests/*.yml', wantlist=True) }}"

- name: Wait for deployment to be ready
  kubernetes.core.k8s_info:
    kind: Deployment
    name: myapp
    namespace: myapp-production
  register: deployment
  until: deployment.resources[0].status.readyReplicas | default(0) == deployment.resources[0].spec.replicas
  retries: 30
  delay: 10