deploy.yml

- hosts: builder
  gather_facts: yes
  connection: ssh
  vars_files:
    - vars.yaml
  vars_prompt:
    - name: github_token
      prompt: "Enter your github personal access token?"
      private: true
  tasks:
    - name: Install Maven
      ansible.builtin.apt:
        name: maven
        state: present
      become: true

    - name: Checking out sources
      ansible.builtin.include_role:
        name: github-add-deploy-key
      vars:
        key_path: ~/gh_deploy_key
        known_hosts_path: ~/.ssh/known_hosts
        key_title: ansible_key
        github_access_token: "{{ github_token }}"
        clone_dest: "~/{{ item.name }}"
        github_account_id: jrb-s2c-github
        repo: "{{ item.git_repo }}"
        branch: "{{ item.git_branch }}"
      loop:
        "{{ apps }}"

#  # should this step take forever, SSH is prompting for user authorization and the remote host's public key should be added to /etc/ssh/ssh_known_hosts
## with key scan: ssh-keyscan -H remote_host.com >> /etc/ssh/ssh_known_host
#    - name: Git checkouts
#      ansible.builtin.git:
#        repo: "https://github.com/jrb-s2c-github/{{ item.git_repo }}.git"
#        dest: "~/{{ item.name }}"
#        version: "{{ item.git_branch }}"
#      loop:
#        "{{ apps }}"


    - name: Maven install
      ansible.builtin.command: "mvn install"
      args:
        chdir: "~/{{ item.name }}"
      register: mvn_out
      #      become: true
      changed_when: mvn_out.rc == 0
      loop:
        "{{ git_repos }}"

    - name: Run JIB builds
      ansible.builtin.command: "mvn clean compile jib:buildTar -Dimage={{ item.name }}:{{ item.namespace }}"
      args:
        chdir: "~/{{ item.name }}/{{ item.jib_dir }}"
      register: mvn_out
      changed_when: mvn_out.rc == 0
#      become: true
#      changed_when: '"BUILD SUCCESS" in mvn_output'
      loop:
        "{{ apps }}"
#
#    - name: Print result of JIB build
#      ansible.builtin.debug:
#        var: mvn_out

# https://blog.scottlowe.org/2020/01/25/manually-loading-container-images-with-containerd/
    - name: Load images into containerd
      ansible.builtin.command: ctr -n=k8s.io images import jib-image.tar
      args:
        chdir: "/home/ansible/{{ item.name }}/{{ item.jib_dir }}/target"
      register: ctr_out
      become: true
      #      changed_when: '"BUILD SUCCESS" in mvn_output'
      loop:
        "{{ apps }}"

    - name: Print result of CTR Load
      ansible.builtin.debug:
        var: ctr_out

- hosts: masters
  gather_facts: yes
  connection: ssh
  vars_files:
    - vars.yaml

  tasks:
    - name: Install PIP
      ansible.builtin.apt:
        name: pip
        state: present
      become: true

    - name: install Python pre-requisites for Kubernetes
      ansible.builtin.pip:
        name:
          - openshift
          - pyyaml
          - kubernetes

    - name: Remove all k8s namespaces
      remote_user: ansible
      kubernetes.core.k8s:
        kubeconfig: /home/ansible/.kube/config
        name: "{{ item.name }}"
        api_version: v1
        kind: Namespace
        state: absent
      loop:
        "{{ namespaces }}"

    - pause: seconds=30

    - name: Create k8s namespaces
      remote_user: ansible
      kubernetes.core.k8s:
        kubeconfig: /home/ansible/.kube/config
        name: "{{ item.name }}"
        api_version: v1
        kind: Namespace
        state: present
      loop:
        "{{ namespaces }}"

    - name: Running the kubectl pre-commands
      ansible.builtin.shell: "{{ item }}"
      loop:
        "{{ pre_k8s_cmds }}"

    - name: Create application.property configmaps
      kubernetes.core.k8s:
        kubeconfig: /home/ansible/.kube/config
        namespace: "{{ item.namespace }}"
        state: present
        definition:
          apiVersion: v1
          kind: ConfigMap
          metadata:
            name: "{{ item.name }}-cm"
          data:
            "{{ item.application_properties }}"
      loop:
        "{{ apps }}"

    - name: Create deployments
      kubernetes.core.k8s:
        kubeconfig: /home/ansible/.kube/config
        namespace: "{{ item.namespace }}"
        state: present
        definition:
          apiVersion: apps/v1
          kind: Deployment
          metadata:
            creationTimestamp: null
            labels:
              app: "{{ item.name }}"
            name: "{{ item.name }}"
          spec:
            selector:
              matchLabels:
                app: "{{ item.name }}"
            strategy: { }
            template:
              metadata:
                creationTimestamp: null
                labels:
                  app: "{{ item.name }}"
              spec:
                containers:
                  - image: "{{ item.name }}:{{ item.namespace }}"
                    name: "{{ item.name }}"
                    resources: { }
                    imagePullPolicy: IfNotPresent
                    volumeMounts:
                      - mountPath: /config
                        name: config
                volumes:
                  - configMap:
                      items:
                        - key: application.properties
                          path: application.properties
                      name: "{{ item.name }}-cm"
                    name: config
          status: { }
      loop:
        "{{ apps }}"

    - name: Scale relevant deployments
      ansible.builtin.shell: "kubectl -n cc scale deployment {{ item.name }} --replicas {{ item.replicas }}"
      when: item.replicas is defined
      loop:
        "{{ apps }}"

    - name: Create services
      kubernetes.core.k8s:
        kubeconfig: /home/ansible/.kube/config
        namespace: "{{ item.namespace }}"
        state: present
        definition:
          apiVersion: v1
          kind: List
          items:
            - apiVersion: v1
              kind: Service
              metadata:
                creationTimestamp: null
                labels:
                  app: "{{ item.name }}"
                name: "{{ item.name }}"
              spec:
                ports:
                  - port: 80
                    protocol: TCP
                    targetPort: 8080
                selector:
                  app: "{{ item.name }}"
                type: ClusterIP
              status:
                loadBalancer: {}
      loop:
        "{{ apps }}"


    - name: Running the kubectl post-commands
      ansible.builtin.shell: "{{ item }}"
      loop:
        "{{ post_k8s_cmds }}"

    - name: Create ingress master
      kubernetes.core.k8s:
        kubeconfig: /home/ansible/.kube/config
        namespace: default
        state: present
        definition:
          apiVersion: networking.k8s.io/v1
          kind: Ingress
          metadata:
            name: ingress-master
            annotations:
              nginx.org/mergeable-ingress-type: "master"
          spec:
            ingressClassName: nginx
            rules:
              - host: "{{ ingress.host }}"

    - name: Create ingress minions
      kubernetes.core.k8s:
        kubeconfig: /home/ansible/.kube/config
        namespace: "{{ item.namespace }}"
        state: present
        definition:
          apiVersion: networking.k8s.io/v1
          kind: Ingress
          metadata:
            annotations:
              nginx.ingress.kubernetes.io/rewrite-target: " {{ item.service_path }} "
              nginx.org/mergeable-ingress-type: "minion"
            name: "ingress-{{ item.namespace }}"
          spec:
            ingressClassName: nginx
            rules:
              - host: "{{ ingress.host }}"
                http:
                  paths:
                    - path: "{{ item.ingress_path }}"
                      pathType: Prefix
                      backend:
                        service:
                          name: "{{ item.service }}"
                          port:
                            number: 80
      #                    - path: /bar
      #                      pathType: Prefix
      #                      backend:
      #                        service:
      #                          name: service2
      #                          port:
      #                            number: 8080
      loop:
        "{{ ingress.rules }}"