{"id":80289,"date":"2020-05-05T01:42:36","date_gmt":"2020-05-04T23:42:36","guid":{"rendered":"https:\/\/prohoster.info\/blog\/administrirovanie\/ansible-migracziya-konfiguraczii-120-vm-c-coreos-na-centos-za-18-mesyaczev"},"modified":"2020-05-05T01:42:36","modified_gmt":"2020-05-04T23:42:36","slug":"ansible-migracziya-konfiguraczii-120-vm-c-coreos-na-centos-za-18-mesyaczev","status":"publish","type":"post","link":"https:\/\/prohoster.info\/en\/blog\/administrirovanie\/ansible-migracziya-konfiguraczii-120-vm-c-coreos-na-centos-za-18-mesyaczev","title":{"rendered":"Ansible: Migration of configuration for 120 VMs from CoreOS to CentOS over 18 months","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Ansible:<\/p>\n

<\/p>\n

This is a transcript of a presentation at DevopsConf 2019-10-01<\/a><\/noindex> and SPbLUG 2019-09-25<\/a><\/noindex>.<\/p>\n

<\/p>\n

This is the story of a project that used a custom configuration management system and why the transition to Ansible took 18 months.<\/p>\n

<\/a><\/noindex><\/p>\n

Day \u2116 -XXX: Before the beginning<\/h2>\n

<\/p>\n

\"Ansible:<\/p>\n

<\/p>\n

Initially, the infrastructure consisted of many standalone hosts managed by Hyper-V. Creating a virtual machine required several actions: placing disks in the right location, setting up DNS, reserving DHCP, and storing the VM configuration in a git repository. This process was partially automated, but for example, VMs were manually distributed among hosts. However, developers could adjust the VM configuration in git and apply it by rebooting the VM.<\/p>\n

<\/p>\n

Custom Configuration Management Solution<\/h3>\n

<\/p>\n

\"Ansible:<\/p>\n

<\/p>\n

The original idea, I suspect, was envisioned as IaC: numerous stateless VMs that would reset their state upon reboot. What did configuration management of VMs look like? Visually, it seems simple:<\/p>\n

<\/p>\n

    \n
  1. A static MAC was assigned to VMs.<\/li>\n
  2. An ISO with CoreOS and a boot disk were attached to the VM.<\/li>\n
  3. CoreOS runs a customization script downloaded from a web server based on its IP.<\/li>\n
  4. The script fetches the VM configuration via SCP based on the IP address.<\/li>\n
  5. A series of systemd unit files and a series of bash scripts are executed.<\/li>\n<\/ol>\n

    <\/p>\n

    \"Ansible:<\/p>\n

    <\/p>\n

    This solution had many obvious problems:<\/p>\n

    <\/p>\n

      \n
    1. The ISO in CoreOS was deprecated.<\/li>\n
    2. Many complex automated actions and magic during migration\/creation of VMs.<\/li>\n
    3. Challenges with updates and when software of a specific version is needed. Even more fun with kernel modules.<\/li>\n
    4. VMs weren't truly stateless, meaning some VMs had disks mounted with user data.<\/li>\n
    5. Someone constantly messed up the systemd unit dependencies, causing CoreOS to hang on reboot. It was problematic to catch this with the available tools in CoreOS.<\/li>\n
    6. Secret management.<\/li>\n
    7. CM was virtually nonexistent. There was bash and YML configs for CoreOS.<\/li>\n<\/ol>\n

      <\/p>\n

      To apply the VM configuration, it had to be rebooted, but it might fail to reboot. It seemed like an obvious problem, but there were no persistent disks to save logs. Alright, let\u2019s try to add kernel boot options to send logs. But no, it\u2019s all so complicated.<\/p>\n

      <\/p>\n

      Day \u21160: Acknowledgment of the problem<\/h2>\n

      <\/p>\n

      \"Ansible:<\/p>\n

      <\/p>\n

      It was an ordinary development infrastructure: Jenkins, testing environments, monitoring, registry. CoreOS was intended for hosting k8s clusters, so the issue was how CoreOS was used. The first step was choosing the stack. We decided on:<\/p>\n

      <\/p>\n

        \n
      1. CentOS<\/strong> as the base distribution, as it is the closest distribution to production environments.<\/li>\n
      2. Ansible<\/strong> for managing configurations, as there was extensive expertise on it.<\/li>\n
      3. Jenkins<\/strong> as a framework for automating existing processes, as it was already actively used for development processes.<\/li>\n
      4. Hyper-V<\/strong> as a virtualization platform. There are several reasons beyond this explanation, but briefly \u2013 we cannot use clouds, we must use our own hardware.<\/li>\n<\/ol>\n

        <\/p>\n

        Day #30: Documenting existing agreements \u2014 Agreements as Code<\/h3>\n

        <\/p>\n

        \"Ansible:<\/p>\n

        <\/p>\n

        Once the stack was understood, preparations for the move began. Documenting existing agreements in code (Agreements as Code<\/strong>!). Transition manual labor<\/em> -> mechanization<\/em> -> automation<\/em>.<\/p>\n

        <\/p>\n

        1. Configure VMs<\/h4>\n

        <\/p>\n

        \"Ansible:<\/p>\n

        <\/p>\n

        Ansible handles this task excellently. With minimal effort, you can take control of VM configurations:<\/p>\n

        <\/p>\n

          \n
        1. Create a git repository.<\/li>\n
        2. Store the list of VMs in inventory, configurations in playbooks and roles.<\/li>\n
        3. Set up a special Jenkins slave from which Ansible can be run.<\/li>\n
        4. Create a job, configure Jenkins.<\/li>\n<\/ol>\n

          <\/p>\n

          The first process is ready. Agreements documented.<\/p>\n

          <\/p>\n

          2. Create new VM<\/h4>\n

          <\/p>\n

          \"Ansible:<\/p>\n

          <\/p>\n

          Here, it was not very convenient. From Linux, it was not easy to create VMs on Hyper-V. One of the attempts to automate this process was:<\/p>\n

          <\/p>\n

            \n
          1. Ansible connects to the Windows host via WinRM.<\/li>\n
          2. Ansible runs a PowerShell script.<\/li>\n
          3. The PowerShell script creates a new VM.<\/li>\n
          4. Using Hyper-V\/ScVMM, when creating a VM in the guest OS, the hostname is configured.<\/li>\n
          5. The VM sends its hostname when renewing the DHCP lease.<\/li>\n
          6. The standard integration of DDNS & DHCP on the Domain Controller side configures the DNS record.<\/li>\n
          7. VMs can be added to the inventory and configured with Ansible.<\/li>\n<\/ol>\n

            <\/p>\n

            3. Create VM template<\/h4>\n

            <\/p>\n

            \"Ansible:<\/p>\n

            <\/p>\n

            Here, we didn\u2019t reinvent anything \u2014 we took Packer.<\/p>\n

            <\/p>\n

              \n
            1. We store the Packer config and kickstart in the git repository.<\/li>\n
            2. Set up a special Jenkins slave with Hyper-V and Packer.<\/li>\n
            3. Create a job, configure Jenkins.<\/li>\n<\/ol>\n

              <\/p>\n

              How this combination works:<\/p>\n

              <\/p>\n

                \n
              1. Packer creates an empty VM, attaches the ISO.<\/li>\n
              2. The VM boots up, Packer prompts in the bootloader to use our kickstart file from diskette or HTTP.<\/li>\n
              3. Anaconda starts with our config, performing the initial OS setup.<\/li>\n
              4. Packer waits for the VM to become available.<\/li>\n
              5. Packer runs Ansible in local mode inside the VM.<\/li>\n
              6. Ansible operates using exactly the same roles as in step #1.<\/li>\n
              7. Packer exports the VM template.<\/li>\n<\/ol>\n

                <\/p>\n

                Day #75: Refactoring agreements without breaking = Test ansible + Testkitchen.<\/h3>\n

                <\/p>\n

                \"Ansible:<\/p>\n

                <\/p>\n

                It may not be enough to fix agreements in code. If you want to change something in the underlying process, you might break something. Therefore, testing of the infrastructure itself comes into play. To synchronize knowledge within the team, we started testing Ansible roles. I won\u2019t delve deeper since there are articles describing the events at that time. Test me if you can or do YML programmers dream of testing ansible?<\/a><\/noindex>(spoiler this was not the final version and later everything became more complicated How to start testing Ansible, refactor a project in a year and not lose your mind.<\/a><\/noindex>).<\/p>\n

                <\/p>\n

                Day #130: Do we really need CentOS+ansible? What about openshift?<\/h3>\n

                <\/p>\n

                It should be understood that the process of introducing infrastructure was not the only one, and there were side subprojects. For example, a request came to deploy our application in openshift, which resulted in research lasting more than a week. We are launching the application in Openshift and comparing the existing tools.<\/a><\/noindex> What slowed down the migration process. It turned out that openshift does not meet all our needs; we need real hardware or at least the ability to tinker with the kernel.<\/p>\n

                <\/p>\n

                Day #170: Openshift is not suitable, shall we risk with Windows Azure Pack?<\/h3>\n

                <\/p>\n

                \"Ansible:<\/p>\n

                <\/p>\n

                Hyper-V is not very friendly, SCVMM doesn\u2019t make it much better. But there is this thing called Windows Azure Pack, which is an add-on to SCVMM and mimics Azure. However, in reality, the product appears abandoned: documentation has broken links and is quite sparse. But as part of the research into options for simplifying our cloud, we looked into it as well.<\/p>\n

                <\/p>\n

                Day #250: Windows Azure Pack is not great. We will stay with SCVMM.<\/h3>\n

                <\/p>\n

                \"Ansible:<\/p>\n

                <\/p>\n

                Windows Azure Pack looked promising, but it was decided not to introduce WAP with all its complexities into the system for unnecessary features, so we stayed with SCVMM.<\/p>\n

                <\/p>\n

                Day #360: We eat the elephant piece by piece.<\/h3>\n

                <\/p>\n

                \"Ansible:<\/p>\n

                <\/p>\n

                Only after a year was there a platform ready for migration, and the process began. For this, a S.M.A.R.T. task was set. We listed all the VMs and began to deal with the configuration one by one, documenting it in Ansible and covering it with tests.<\/p>\n

                <\/p>\n

                Day #450: What kind of system did we end up with?<\/h3>\n

                <\/p>\n

                \"Ansible:<\/p>\n

                <\/p>\n

                The process itself is not interesting. It's routine, and it's worth noting that most configurations were relatively simple or isomorphic, following the Pareto principle: 80% of configurations took 20% of the time. Similarly, 80% of the time was spent on preparing for the move, and only 20% was spent on the move itself. <\/p>\n

                <\/p>\n

                Day #540: The Finale<\/h2>\n

                <\/p>\n

                \"Ansible:<\/p>\n

                <\/p>\n

                What happened over 18 months?<\/p>\n

                <\/p>\n

                  \n
                1. Agreements became the code.<\/li>\n
                2. Manual labor<\/em> -> Mechanization<\/em> -> Automation<\/em>.<\/li>\n<\/ol>\n

                  <\/p>\n

                  Links<\/h2>\n

                  <\/p>\n