macOS VM image management in Anka Build – macOS cloud solution

Anka Build from Veertu is a complete software solution to configure a macOS cloud on a cluster of Mac hardware (on-prem or hosted) and run macOS VMs like you would run containers.

If you use container based CI setup, you can take the same DevOps process and implement them for CI on macOS for your iOS apps. Alternatively, if you are more used to working with VMs, you can work with Anka VMs in a similar fashion. Anka Build solution supports both methods for DevOps.

Anka macOS VM is created, virtualized and run on top of Anka virtualization technology running on each mac hardware node. In this blog, we will describe the image structure of Anka macOS VM and image management strategy in Anka Registry component.

Creating macOS VM

Use `anka create` method to create a VM with base macOS. While using `anka create` you can specify the disk size for your VM using the `-d` or `–disk-size` parameter. This is not reserved capacity but the total maximum VM hard drive capacity. As you install additional software inside Anka macOS VM, the disk size gets allocated dynamically.

Execute `anka show VM` to look at actual hard drive size.

Anka Show

Anka Show

Cloning Anka VMs

`anka clone VM1 VM2` creates a snapshot file pointing to the parent VM1. Any more changes to VM2 are made only in the snapshot and is still pointing to the parent VM1. The parent VM1 can be changed and/or deleted, but the clone VM2 will stay unaffected. When both parent and clone exists, since the clone is not completely duplicated, the overall disk space is optimized.

Stopping and Suspending Anka VMs

Anka optimizes VM disk space usage on every stop and suspend operation by going over the entire file system and freeing up unclaimed blocks.

Managing Anka VM versions of Anka Registry

You can incrementally install software components on base macOS VMs and maintain versions in Anka Registry. At any time, you can pull an older version of a VM from the Registry.

Anka registry commands

Anka registry commands

Anka VM image hierarchy management

Anka VM image hierarchy management diagram

Anka VM image hierarchy management diagram

Anka VM image and version management are built to optimize disk space usage on the Mac nodes running the VM and also data transfer times when pushing and pulling the VMs on the Mac nodes.

Bootstrapping Anka macOS VM for your iOS Build/Test Job

What is Anka Build

Anka Build is a solution suite to configure a macOS cloud mac hardware, on which you can provision immutable docker like macOS VMs for iOS and macOS CI jobs. Anka hypervisor enables macOS VMs to run in a very resource efficient manner and fast boot feature makes them available on-demand instantly. Anka controller and registry modules provide a simple method to set up a scalable macOS cloud and integrate with third party CI systems.

Anka command-line interface enables you to bootstrap and prepare your macOS VMs in a dockerfile like fashion, for CI build and test jobs.

In this blog, we will look at how you can start to manage your macOS CI infrastructure as a code. Part 1 of this blog will focus on creation and bootstrap your macOS build/test environment that you can use a VM template to provision simple, fast, immutable elastic docker like slaves/agents.

Step 1 – Install AnkaBuild.

Install ankabuild.pkg on your mac and activate license (sudo anka license activate key). You can automate the installation and activation steps.

Step 2 – Create macOS VM. Build a macOS VM running a specific version of macOS, hard drive allocation, CPU, and RAM. You can also modify CPU and ram settings later.

anka create --ram-size 4G --cpu-count 2 --disk-size 45G --app /Applications/Install\ macOS\ High\ myhisierravm


Step 3 – Install Toolkits in the macOS VM.

Use ‘anka run’ to work inside the newly created VM and install dependencies like Xcode etc to prepare your VM for iOS build/test. Anka run is similar to docker run. When you execute ‘anka run’ against an Anka VM, it executes in an isolated manner inside the VM, separate from the host.

Step 3.1 – Install brew, homebrew in Anka macOS VM.

Just execute command, provided on the site, but with ‘anka run’ to install brew inside the Anka VM.

anka run -n myhisierravm ruby -e "$(curl -fsSL"


Step 3.2 – xcode-install in Anka macOS VM.

Execute xcode-select tool command with ‘anka run’ to install it inside the Anka macOS VM.

anka run -n myhisierravm sudo gem install xcode-install


Step 3.3 – Complete Xcode setup in Anka macOS VM.

FASTLANE_PASSWORD='passwd' FASTLANE_USER='usr' anka run -nE myhisierravm xcversion list

Note : -n option of anka run prevents implicit mounting of current folder inside the VM.

-E enables inheriting env variables (eg : FASTLANE variables) in the Anka macOS VM.

FASTLANE_PASSWORD='passwd' FASTLANE_USER='usr' anka run -nE myhisierravm xcversion install 9.2


In some scenarios, it might not be best to provide credentials directly in shell command line (saved history, etc). To secure FASTLANE_ variables, you could store them into a text file (fastlane_cred.txt) in the following form.

  • Then populate the Anka VM environment from the file (with -f | –env-file option).

    anka run -nf fastlane_cred.txt myhisierravm xcversion install 9.2

    Step 4 – Xcode setup is now complete inside Anka macOS VM.


    Step 5 – Mount provisioning profiles from host inside the VM.

    anka mount myhisierravm ~/Library/…/Provisioning\ Profiles /Users/anka/Library/…/Provisioning\ Profiles

    This will make provisioning profiles accessible inside the VM for Xcodebuild.

    Step 6 – Execute Xcodebuild for your project inside the Anka macOS VM.

    anka run myhisierravm xcodebuild test -scheme Kickstarter-Framework-iOS -destination 'platform=iOS Simulator,name=iPhone 8,OS=11.2'

    Note : This command mounts the existing current folder from the host into the VM and executes Xcodebuild on it. Because we mounted provisioning profiles in the previous step to a specific default Xcodebuild location inside the VM, the above command will use those mounted provisioning profiles without the need for any configuration change inside the VM.

    Refer to anka run command line help for additional details.


    In the next blog in this series, we will share how to setup and manage the Anka Build macOS CI cloud with command line/Infra as a code. Stay tuned.

    Anka Build Controller Portal – Provides visibility into the health of macOS cloud for CI

    In our recently released version 1.2 of Anka Build, we made few changes to the management module (Controller) to enable even easier setup, configuration, and management of macOS cloud for CI. For more details on how to configure macOS cloud for CI, refer to Anka Build macOS cloud on Mac Pro or Anka Build macOS cloud on Mac Minis.

    Anka Build Controller and Registry module are packaged in a single download package. These components install as Ubuntu Docker containers and can be either installed on the same machine/instance or on different machines. Refer to this link for more details.

    Registry configuration involves defining a volume to store the VM images and pointing to that in the docker-compose.yml.

    volumes: - `/Users/administrator/Desktop/registryvm:/mnt/vol`

    Note – Make sure to not setup the volume in the same directory where the registry/controller containers are running.

    Controller configuration involves editing the anka.controller.docker to point to the registry IP address.


    Once you have setup controller/registry containers, access the new web-based portal at http://controllerip:8090.

    Dashboard View

    This view displays a single pane view into the current state of your Anka Build macOS cloud. You can see the total no of Anka Build nodes(mac machines which have Anka Build installed and are joined to the controller), the total number of macOS VM instances running, total available storage in the registry and available capacity to run additional macOS VM instances.

    The template usage pie chart displays all current VM templates that are being used to provision VM instances.

    Average resource usage across all active nodes displays the CPU and RAM usage across all nodes for the entire Anka Build macOS cloud.

    Dashboard View

    Nodes View

    This view displays all the mac build/test host machines running Anka Build software package and are joined to the controller.

    Node View

    Templates View

    This view displays all the VM images and their corresponding tags/versions stored in Anka Build Registry.

    Through this view, you can also distribute/pre-populate VM template images to all your Anka Build nodes for faster first time provisioning.

    Templates View

    Distribute to nodes

    Instances View

    This view displays all running macOS VM instances at any given point in time.

    Use Create Instance to manually create macOS VM instances on the cloud. Use this feature for manual troubleshooting.

    Instances View

    Create Instance

    iOS CI infrastructure – macOS cloud on Mac Pros with Anka Build

    In our previous blog post, we discussed setting up macOS cloud for iOS CI on a mac mini cluster. Let’s now look at creating macOS cloud on mac pros for scalable and agile iOS CI. While the CPU on mac minis are much faster(as proven in various benchmarks) than existing Mac Pro models and result in a much high performing macOS cloud for iOS CI, there is still a great deal of interest in setting up iOS CI infrastructure on Mac Pros. Let’s look at how you can use Anka Build technology to very quickly set up and efficiently manage a scalable and agile macOS cloud on Mac Pros. One of the cool things about Anka Build virtualization technology is that it’s built on top of macOS Hypervisor framework and supported on all the Mac hardware. You can configure your iOS CI infrastructure on Mac minis, Mac Pro, iMac Pro, MBP or a combination of these. Download 30 Day trial at and configuring macOS cloud on Mac Pro cluster
    • Anka Build.pkg – This is a mac application package and installed on each of the Mac Pros.
    • Anka Build Controller and Anka Build Registry – This is a docker container package and installed in a VM or an AWS instance. If you set up your Mac Pros in any hosting provider, you can set up and run controller and registry modules in a Linux cloud instance.
    Hosted Anka Build Cloud can be secured entirely with VPN based connectivity between on-premise CI and hosted Anka Build controller.Step 1 – Install AnkaBuild.pkg on the Mac Pros. Check out Getting Started here.Step 2 – Install Anka Controller.Step 3 – Install and configure Anka Registry.Step 4 – Create macOS cloud by joining each Mac pro(running Anka Build) to the controller. Use ‘ankacluster join’ command.Step 5 – View your macOS cloud from controller management portal (this module is not available in the current version). We are providing a sneak peek into this controller portal through this blog. It will release in Anka version 1.2 upcoming release.

    Controller Anka Build macOS cloud dashboard showing overall health


    2 node Mac Pro macOS cluster

    Step 6 – SSH or VNC into one of the Mac Pros(running Anka Build). Let’s call this the builder mac. Create your macOS VM iOS build and test iOS environment (Anka VM Templates). Full command line support is available (‘anka create’) and you can fully automate this step (‘anka create’ & ‘anka run’). In this demo, we are creating a VM with 4vCPU, 8GB RAM and all dependencies to build and test the Kickstarter iOS project. You can change VM settings (CPU, RAM, etc.) with ‘anka modify’ command.

    macOS Hisierra Anka VM created on macOS Hisierra Mac Pro

    Step 7 – Connect the builder Mac Pro to Anka Registry and push the prepared VM template to this central private macOS cloud registry. You can tag (version) and use it as a base VM to create new environments(with different tags) and store and manage them in the registry.

    Latest tagged version of Hisierraga VM template in the Registry

    Step 8 – If you use Jenkins for your CI, install the Anka Build Jenkins plugin. For any other CI system, use the controller REST APIs to integrate. If you use hosted CI services like Buildkite or Gitlab CI, contact us to get additional details on integration. Check out details on Jenkins plugin here.Step 9 – Check the health of all Anka Build components in the controller portal.Step 10 – Let’s do a test run. I will launch multiple macOS VMs on my 2 Mac Pro node macOS Anka Build cloud.

    Manually creating on-demand VMs


    On-demand launched Anka macOS Vms on Anka Build cloud

    Step 11 – Now, let’s create a real job queue in Jenkins to run on this multi-node Mac Pro Anka Build cloud. Jenkins Anka Build plugin instantly launches clean VMs on the Anka Build cloud, and when the build job finishes, the VM dies. Next job starts a fresh VM.

    Kickstarter iOS project jobs in Jenkins


    Automatically launched clean Anka VMs from Jenkins


    Jenkins job running in Anka VMs


    On-demand clean Anka VMs launched automatically for Kickstarter Jenkins Jobs

    Every iOS CI build or test job request instantly gets a clean, consistent macOS VM environment. Test new versions of Xcode, iOS SDKs by creating new tagged Anka VM from a base template, manage them in the registry and use them for your CI jobs. Scale up the capacity by easily adding additional Mac Pros to the existing Anka Build cloud cluster.

    Configuring Jenkins Pipeline for iOS CI to run on Anka Build macOS cloud

    In this blog, we will describe steps to run Jenkins iOS CI jobs defined as pipelines on macOS slave VMs running on Anka Build Anka Build macOS cloud. One of our previous blog titled “configuring Jenkins iOS CI macOS cloud” covered the basic steps to configure Jenkins-Anka Build plugin and steps to use it in Jenkins iOS CI jobs defined through web UI. Jenkins pipeline provides an extensible set of tools for modeling simple-to-complex delivery pipelines “as code” via the Pipeline Domain Specific Language (DSL) syntax. When using it in combination with Anka Build macOS cloud, the steps are relatively straightforward.

    Step 1 – Install and setup Anka Build Jenkins plugin.

    Step 2 – Set Anka Build macOS private cloud IP details in the plugin.

    Step 3 – Create Anka macOS VM Slave templates to use for your iOS CI jobs. In this step, you will define a label for each of these slave templates.

    ANka Build plugin Slave template

    Step 4 – Define your Jenkins pipeline – This example is a simple pipeline definition which executes Build and Test scripts/actions. The pipeline launches Anka macOS VMs (Jenkins slaves) on-demand on Anka Build cloud as per the label definition.

    Sample Jenkins Pipeline Job

    Using Anka Build Slave template label in Pipeline definition

    Step 5 – When this pipeline executes, it launches one or multiple macOS VMs on-demand for job execution. Every build and test job gets a sterilized, consistent environment.

    Pipeline jobs executing on Anka Build macOS cloud

    If you are using other declarative CI tools or platforms like Gitlab CI or Buildkite, you can use anka command line tool interface for easy integration with agents/runners. In such scenarios, the agent/runners running on macOS hosts will be able to launch on-demand Anka macOS VMs from templates (pulled from Anka Registry) , to fulfill job requests. We will be covering these scenarios in our upcoming blogs.

    Running a macOS cloud on mac mini cluster for iOS CI

    It’s been twelve years since the introduction of the first Mac mini. During these twelve years, there have been multiple updates and new models introduced with the last one in 2014. In 2011 the Mac Mini was updated with the power of i5 and i7 processors, and users started using it for the first time in a server capacity, namely as chat, web, mail servers. Then, 2012 Mac mini had exciting updates and demonstrated significant improvement in benchmarks from 2011. 2012 model is still very widely used since it was the last model with a quad-core processor.When iOS development took off, Mac mini became the hardware of choice for app development because of it’s small form factor and the power it packs in this form. First, it was individuals developing iOS apps, then as the complexity of apps increased, the size of iOS development teams also increased. Teams started implementing DevOps and continuous integration and testing to keep up with the increased frequency of commits. Mac mini was again hardware choice for CI because teams could stack a bunch of these and get a build/test cluster going.What’s happening now is that there is no end in sight for the richness of features you see in the mobile applications. “iOS First” philosophy still holds healthy for the majority of mobile application development. As a result, iOS development teams are finding themselves having to build more agile and flexible build and test infrastructure that can scale with the exponentially increasing number of UI regression tests, commit frequency, shorter update cycles and a gradually growing matrix of iOS device types.In this blog, we will describe how you can configure your existing iOS build/test Mac mini hardware into a macOS cloud and operate CI in a docker like fashion.
    • Instant start (quick boot) multiple macOS VMs on-demand from a suspended state to run jobs in parallel.
    • Eliminate the complexity of SAN and other challenges associated with management of traditional virtualization platforms.
    My example setup consists of 2 dual-core Mac minis. My CI system is Jenkins and I am using the Kickstarter open source iOS project to demonstrate build/test job example. If your CI tool is not Jenkins but some other on-prem tool like TeamCity or hosted tool like Buildkite or Gitlab, contact us to get more details on integration. We are working to release more pre-packaged integrations with other CI tools.Start by signing up for Anka Build 30 day trial software at You will receive an email with links to download the following Anka Build modules.Anka Build package – Mac application package which you will install on your Mac minis. Anka Build package is the virtualization hypervisor (lightweight 41MB package).Anka Controller – This is the Anka Build macOS cloud management module packaged as an ubuntu docker container.Anka Registry – This is similar to docker registry and is used to store and manage the macOS VMs and versions you build for your CI jobs.Anka Build Jenkins Plugin – This is the pre-built plugin available for download from Jenkins plugin center to easily integrate with Anka Build macOS cloud.Once you have installed all the above components, you should see the following:Anka Build macOS cloud configured in your Jenkins master instance

    Anka Build Jenkins Plugin

    Anka Build macOS cloud of 2 Mac minis(Data accessed through controller REST API)

    Anka Build Controller Node list

    Anka Build macOS cloud access to VM templates in Anka Registry

    Anka Build Controller Registry access REST API

    Anka Build Registry displaying versions of a VM template

    Anka Build Controller Registry VM Template Describe REST API

    Starting multiple iOS jobs to execute on the macOS CI cloud in JenkinsThree VMs are launched from VM template and instantly started on a cluster of 2 Mac mini nodesQuick boot/Instant Start for macOS VMs

    Anka Build Controller display VM list REST API output

    Displaying access through VNC to VMs launched on the Mac mini macOS cloud

    macOS VMs

    • Scale the macOS cloud by joining new Mac minis with Anka Build package installed to the Controller.
    • Use anka run to fully automate bootstrap/pre-configuration of build/test macOS VM templates. Check anka run documentation here.
    • Configure macOS cloud on on-premise or hosted Mac minis.

    Launching build/test environment for iOS CI jobs at AWS instance launch speeds

    In this blog, we will describe how teams can configure a private (on-prem or hosted) cloud and instantaneously launch on-demand, isolated build/test instances to execute their iOS CI jobs, while still meeting the tough demands of the speed of overall execution of the CI jobs.

    It’s no secret that speed of CI job execution directly impacts developer productivity and you see developer productivity teams making this one of their top priorities. There are multiple variables that impact the speed of execution of the CI jobs – provisioning time for the environment, seeding the environment for the CI job (config mgmt etc), performance in the environment and getting build/test artifacts in and out of the environment.

    If you look outside of macOS dependent development, most of the CI process is happening either in private or public clouds. In these setups, (taking the example of AWS) launching an instance on-demand is super easy, completely extensible and fast. Just start one with an AMI and you have an isolated Linux instance available. Containers make it even easier and more replicable. However, the story is quite different for macOS dev environments for CI.

    Existing virtualization approach to creating a macOS dev cloud on Mac hardware is based on the same solution available to virtualize Linux and Windows. However, since this technology is not optimized for a macOS cloud use case, it suffers from challenges of scalability and manageability and only supports specific mac hardware.

    In the Anka Build solution, our goal was to make sure that these challenges are addressed and that it provides the same level of agility and scalability as one would get from using AWS. So, Anka Build packages a virtualization software that can run on any mac hardware, is built on top of macOS native Hypervisor Framework, exposes an extensible CLI.

    Let’s look at the method of provisioning or launching macOS VMs on-demand in Anka Build.

    Step 1 – Create your macOS Anka VM (this will be your template) and seed it with all your build/test dependencies using Anka CLI. This will ensure that no time is spent on preparing the dependencies in the environment for when a job runs.

    Step 2 – Put this Anka VM (template) in an ‘Instant Start’ State. It’s called `suspend` state in Anka CLI. This will ensure that when your iOS CI job requests an environment, the macOS Anka VM will be available instantly for execution, without any boot time issues. It will also ensure that you always get the same, consistent instance for repeated execution of the same job.

    Demo Video for Instant starting Anka macOS Vm from a suspended state.

    Step 3 – Push the suspended Anka VM to Anka registry.  If you need different flavors of build/test instances for different types of CI jobs, then, create and push different versions of same Anka VM template to the registry and use them by referring to a specific tag in your jobs. You can also create additional Anka VM templates(for when you need different macOS version) and push them to the registry and use them for your CI jobs.

    Step 4 – Install Anka Build mac application on all your build and test mac hardware and join them to Anka Build controller.

    Step 5 – Integrate your CI system to Anka Build controller through one of our existing plugins(Jenkins) or through REST APIs. Anka Build controller will now launch one or multiple macOS VMs on-demand across your build and test mac hardware, based on your CI job requests and your jobs will execute instantaneously.

    Step 6 – Trash the macOS Anka instances or keep them for troubleshooting. Get consistent, isolated instances for the next job execution.

    Step 1 and Step 2 address the tough demands of developer productivity teams to provide faster provisioning time of the macOS build/test instances in a macOS cloud for CI and enables them to keep build and test queue moving along with increased speed, efficiency, and determinism.

    Anka Registry available in a Mac Application Package – Store and manage Anka VMs in macOS cloud for CI

    Anka Registry enables management and distribution of macOS development environments (macOS VMs) across developers and to macOS cloud for CI, for consistent and repeatable build and test operations. With Anka Registry, you can create macOS image and then in an incremental manner provision Xcode, final dependencies and push to the registry, from where it is distributed on-demand to create build/test instances to execute CI jobs.

    Furthermore, you can pull a specific version of your build/test image, make changes, clone it to a new image and start managing it again with Anka Registry.

    When you install Anka Build to set up a macOS build/test cloud, you also set up Anka Registry, which runs as Ubuntu service in a docker container or in a Linux VM. With today’s release of Anka Registry Mac application package, we are making it easy for DevOps and iOS developers to quickly set it up on their Mac machines for testing purposes.

    You can very quickly get started with Anka, by installing Anka Flow or Anka Build package on your Mac and then install the Anka Registry. Use `anka create` command line to create your macOS dev image and push it to the Anka Registry and start managing and distributing it amongst team members.

    Let us know your thoughts on how we can improve it further.

    Configuring Jenkins to scale iOS CI on macOS cloud with on-demand slaves

    This blog is not a comparison of CI tools or services available. It assumes that Jenkins is your CI tool of choice for iOS CI/CD. There have been a lot of blogs written on how to configure Jenkins for iOS CI – starting with plugin installation, using Fastlane and other tools etc to further streamline the process. The last step of this workflow is the slaves on which the Jenkins iOS jobs run. In all the setups I have read about, the last step executes on macOS hardware configured as static slaves/nodes. Some of the common challenges with this static slave setup, that we have discovered through our conversation with the users are as follows.

    Lack of consistent and isolated slave environments for all the jobs

    Almost all iOS build/test jobs irrespective of differences in application, install multiple dependencies(internal or from public repositories). Multiple runs of these jobs pretty much require re-install or fresh install of these dependencies on the Jenkins slave mac node. Often times, the public dependencies which are directly git cloned from public repositories change between different runs of the same job, resulting in build/test failures. Multiple installs, uninstall of the dependencies can leave the Jenkins slave node in a polluted state with leakage between different job runs.

    Difficulty with reproducible slave environments

    When CI build/test fail due to environment-related issues (for example wrong version of a specific library) the CI queue starts to build up rapidly and troubleshooting options become a great challenge. Devops/Developers can’t spend too much time troubleshooting in slave environments as it impacts the overall available slave capacity. The focus then is to quickly patch/fix and get the CI queue moving again. There is no easy way to have reproducible environments to assist in these scenarios.

    No flexibility to iterate changes in the environment

    In a static slave node Jenkins CI setup, most often, when you have to test the CI workflow on new releases of macOS and Xcode, you have to shard the available static node capacity.

    These challenges can be addressed if it was possible to spin up/down macOS slaves on-demand on a pool of hardware, similar to the way you can spin up/down instances on AWS from the AMIs. However, nothing like this exists when your job needs to run on macOS and not on Linux or Windows.

    At Veertu, we built a Jenkins plugin for our Anka macOS cloud technology. The way it works is first, you configure macOS cloud on a cluster of Mac hardware (hosted or on-premise) with Anka Build and create your iOS build/test VM templates. Then, install Anka cloud Jenkins plugin from the Jenkins plugin center. Once the plugin is installed, you can define your slave template definitions and associate them to build/test iOS CI pipelines or jobs. Now, when your jobs execute, they will on-demand spin up a required instances of specific macOS VMs(as defined by the label associated with the job) environments on the Mac hardware cluster to act as your Jenkins slave instances.

    Below steps describe this in more detail.

    Step 1

    Install latest Jenkins – Anka plugin. This plugin code is also available on GitHub at

    Anka Jenkins plugin

    Anka Jenkins plugin

    Step 2

    Point the plugin to connect with the Anka Build macOS cloud. You will need IP address of the Anka Build controller Think of Anka Build controller as a central management server for your macOS cloud built on top of Anka. It exposes a rich set of REST APIs for integration with other third party CI systems

    Anka jenkins plugin

    Anka jenkins plugin setup 2

    Step 3

    Define one or many slave template definitions for your iOS build/test jobs.

    Anka Jenkins plugin setup 3

    Anka Jenkins plugin setup 3

    Template field in the plugin shows all the macOS VM templates that you have created. Think of these templates as AWS AMIs. These templates are stored in a central Anka Registry storage component. You can pull these VM templates on your machine, make changes to them(install new dependencies) and push them back to the Anka Registry with a new tag/version.

    Anka Jenkins plugin setup 4

    Anka Jenkins plugin setup 4

    All the templates stored in the Anka Registry and their versions are available for use as slave templates in the Jenkins plugin. If you don’t select a version, the plugin will use the latest version.
    Anka Jenkins plugin setup 4.1

    Anka Jenkins plugin setup 4.1

    You can now store and manage reproducible environments for iOS CI jobs.

    Step 4

    Assign slave template label to your jobs/pipelines.

    Anka Jenkins Plug Step 4

    Anka Jenkins Plug Step 4

    Step 5

    Now, execute one or multiple concurrent jobs. Jenkins Anka plugin will start the required number of Jenkins slave macOS VMs of the type defined in the slave template definition. Every job executes in a consistent and completely isolated environment.

    The central management server aka Anka Controller manages the request queue for slave instances and provisions instances on available mac hardware nodes in your Anka Build cluster. So, you can run concurrent jobs in Sierra, HiSierra and also different versions of Xcode on the same pool of hardware.

    Anka Jenkins Plugin step 5

    Anka Jenkins Plugin step 5

    Let us know your thoughts and ideas on how we can further enhance the Jenkins-Anka plugin. You can also try it out with Anka Build cloud for iOS CI with a 30 day trial of Anka Build.

    Using Anka to Build Anka – Example of developing locally on workstation in build and test Anka macOS VMs

    Here is a peek into how our development team uses do builds for Anka product locally using Anka itself. We have all seen multiple blog posts shared by developments teams who are developing on top of Linux explaining how their developers are using containers to setup build and test environments locally on their workstations, with all upstream CI dependencies. This eliminates the “But, it works on my machine” issues, reduces failures in the upstream CI process, make it easy to reproduce environments for debugging resulting in greater velocity in application development and release.

    But, most important of all, it provides flexibility to developers to install and play with newer packages, frameworks on their machines without having to worry about breaking things with the mainline application build, test, and release process.

    Our development team is enjoying the same benefits while building Anka product. Since Anka is for development on the macOS platform, we are doing local builds during development inside Anka on developer machines.

    Like many development teams out there, we have set up a central CI to do automated and manual builds and testing for minor and major releases of Anka Flow and Anka Build products. We do CI builds inside Anka virtual machine environment.

    However, we also do a large no of internal releases to continuously try and test new things and quickly address user issues. This is largely due to two things – First, Anka is new technology and as it’s getting adopted by users there is a lot of development activities taking place to address user requests, fix bugs etc and second, in the past 2-3 months with macOS Sierra to macOS HiSierra transition, we had to continuously keep pace with all beta updates. What this means is that our developers need agility to build Anka packages locally with their changes, without having to wait for it to go through the upstream CI pipeline.

    In normal circumstances, this would be impossible because of a complex matrix of dependencies that are needed to do a release build. However, because we were already doing our CI builds in reproducible Anka macOS VMs using Anka Build, our developers just pull the latest version of build VM (build_vm2(sep 5)) from the Anka Registry on their machines and run their builds inside that environment (anka run build_vm2 ./ The output Anka Build and Anka Flow application packages are available on their local machines. We use a fairly large number of external libraries and packages in our application and having them all packaged in Anka build VM that is maintained by our DevOps, frees up the developer to have whatever they want on their laptops. Our developers very quickly transitioned to HiSierra and started working with Xcode 9, while we were still compiling and building Anka on Sierra and Xcode 8.3.3.

    Step1 – pull `build_vm2` from Anka registry on local machine

    Step 2 – Build locally with `anka run` inside build_vm2 Anka VM