Adam is a backend software engineer at Spacelift. He has a background in full-stack web development, infrastructure automation, and deploying applications to Azure.

All posts by Adam Connelly - Infrastructure as Code Expert

Adam Connelly

Author title

Title category

Get all the latest content on Infrastructure as Code, DevOps, Spacelift features & news directly to your inbox!

Level up your IaC knowledge. Stay up to date with educational devops guides & news in infrastructure as code, cloud & more!

Managing Infrastructure at Scale | Spacelift Blog

AWS: Spacelift Reduces Time Spent on Cloud Management by 90% 🚀

applepodcasts

spotify

missionctrl

Welcome to missionCTRL, a show dedicated to exploring the frontiers of modern DevOps. Listen (or watch) as we sit down with the practitioners who are pushing the boundaries of development

Learn more about new features, updates, and Spacelift product announcements.

Product Features and Updates | Spacelift Blog

Product

At Spacelift, we&#8217;re excited to announce our new Cloud Integrations section and our update to support account-level AWS integrations. Public Cloud integration is nothing new in Spacelift, but we wanted to simplify the implementation and organization. Cloud Integrations brings feature parity to AWS and Azure integrations across your Spacelift account.

We’ve created a new Cloud Integrations section in the Spacelift console. This section allows you to manage AWS and Azure integrations from a single location. Azure integrations were previously in the settings section and have been moved from there.

spacelift-cloud-integration-aws

spacelift cloud integration - aws

In addition, we’ve added the ability to attach more than one AWS integration to your stack:

spacelift-cloud-integration-more-than-one-aws-integration

spacelift cloud integration - more than one AWS integration

A stack can have at most two AWS integrations attached, with only one read and one write integration (see “<a href="#read-vs-write-attachments">Read vs. Write Attachments</a>” for more info). An integration can also be attached as both read and write for simple use-cases.
Finally, we’ve also altered the external ID format used when assuming roles. More details are available later in this post.

Don’t worry, your existing AWS integrations will continue to work, and the existing <code>spacelift_aws_role</code> resource can still be used. The only caveat to this is that you will only be able to add new integrations to stacks via the front end using the new Cloud Integrations approach.

Migrating from legacy integrations is easy, with slightly different steps depending on whether you manage your integrations via Terraform or the Spacelift UI. In the simplest case, you just need to create a new integration, delete your old integration, and attach a new one, but you may also need to adjust the Trust Relationships for your IAM roles depending on exactly how they are configured.
For more information on migrating, take a look at our <a href="https://docs.spacelift.io/integrations/cloud-providers/aws#migrating-from-legacy-integrations" target="_blank" rel="noopener">documentation</a>.

An integration can be attached to a stack as either read or write. This tells Spacelift which run phases to use each integration during. For simple use-cases, you can attach a single integration as both read and write, but if you want more control, you can create a read-only role and a write role, and attach both to your stack. An example use-case for this is to make sure that a proposed run doesn’t have write permissions to avoid infrastructure changes being made via a pull request.
Read attachments are used during the Initialize and Plan phases of runs. Write attachments are used during the Apply phase of a run, the Perform phase of a task, and the Destroy phase of a stack destructor.

When choosing to assume the role at Spacelift’s end rather than on your private workers, we automatically generate an External ID based on the stack the integration is attached to. Previously we used the following external ID format:

As part of the changes we’ve made, we’ve adjusted our external ID format to the following:

The change means that you can use the “read” or “write” suffix to ensure that a read phase of a run can only assume a read-only role.

We really hope that these changes will be useful and will provide extra flexibility for those users who need it while making simple use-cases easier through reusing integrations. To find out more about Cloud Integrations, review the <a href="https://docs.spacelift.io/integrations/cloud-providers/" target="_blank" rel="noopener">documentation</a>.

Spacelift is a sophisticated SaaS product for Infrastructure as Code that helps DevOps develop and deploy new infrastructures or changes quickly and with confidence.

Monitoring Your Spacelift Account via Prometheus

Spacelift in the GitHub Marketplace

How Spacelift Can Improve Your Infrastructure as Code

We are excited to announce our new Cloud Integrations section and our update to support account-level AWS integrations.

111-spacelift-cloud-integration

Introducing Cloud Integrations

Introducing Spacelift Cloud Integrations

Monitoring your Spacelift account via Prometheus

For a while now, we have received feedback from customers that they would like to be able to connect their Spacelift account to external monitoring systems. Today we are excited to announce the <a href="https://github.com/spacelift-io/prometheus-exporter" target="_blank" rel="nofollow noopener">Prometheus Exporter for Spacelift</a>! We also have plans to add support for &lt;insert monitoring system X here&gt;, so if you’re using another system, we should have you covered soon.

The Prometheus exporter allows you to monitor various metrics about your Spacelift account over time. You can then use tools like Grafana to visualize those changes and Alertmanager to take actions based on account metrics. Several metrics are available, and you can find the complete list of available metrics <a href="https://github.com/spacelift-io/prometheus-exporter#available-metrics" target="_blank" rel="nofollow noopener">here</a>. Below are a few examples of the information the exporter currently provides:
<ul>
<li style="font-weight: 400;" aria-level="1">The number of runs pending and currently executing in both public and private worker pools.</li>
<li style="font-weight: 400;" aria-level="1">The number of workers in a pool.</li>
<li style="font-weight: 400;" aria-level="1">Usage information, including the number of public and private worker minutes used during the current billing period.</li>
</ul>
Once you have that information, it opens a number of possibilities, including visualizing information about your account via Grafana dashboards, alerting on events like a lack of private workers, as well as using that information to autoscale worker pools via the Horizontal Pod Autoscaler.
To give you a taste, here’s an example Grafana dashboard showing some of the information available from the exporter:

grafana-dashboard

Grafana dashboard

The Prometheus exporter is an adaptor between Prometheus and the Spacelift GraphQL API. Whenever Prometheus asks for the current metrics, the exporter makes a GraphQL request and converts it into the metrics format Prometheus expects.
The following diagram gives an overview of this process:

prometheus-exporter-diagram

Prometheus exporter diagram

Ok, great, but how do I use the Prometheus Exporter?
To help with setup and deployment, we are going to guide you through the following:
<ol>
<li style="font-weight: 400;" aria-level="1">Deploy a Prometheus stack to a Kubernetes cluster.</li>
<li style="font-weight: 400;" aria-level="1">Deploy the exporter.</li>
<li style="font-weight: 400;" aria-level="1">Configure  Prometheus to monitor it.</li>
</ol>
The <a href="https://github.com/spacelift-io/prometheus-exporter#quick-start" target="_blank" rel="nofollow noopener">Quick Start</a> section in the exporter repo outlines several options for deploying the exporter. Review the best deployment option that makes sense, depending on your setup and requirements.
If you already have a Prometheus stack setup and have plenty of experience, feel free to skip to the “Installing the Prometheus Exporter” section.
We also assume that you already have a Kubernetes cluster provisioned (hopefully <a href="https://docs.spacelift.io/vendors/kubernetes" target="_blank" rel="noopener">via Spacelift!</a>) and available to complete the following steps. If not, a local installation like <a href="https://minikube.sigs.k8s.io/docs/start/" target="_blank" rel="nofollow noopener">Minikube</a> will work fine for illustration purposes.
<h3>Installing kube-prometheus-stack</h3>
The first step is to install the <a href="https://github.com/prometheus-community/helm-charts/tree/main/charts/kube-prometheus-stack" target="_blank" rel="nofollow noopener">kube-prometheus-stack Helm chart</a>. You can do that with the following commands:

That will install a Prometheus, Grafana, and Alertmanager stack into your cluster&#8217;s namespace called <code>monitoring</code>. Run the <code>kubectl get pods -n monitoring</code> command to see the installed components.

<h3>Getting API Credentials</h3>
The Prometheus exporter authenticates to the Spacelift GraphQL API using an API key. Follow the <a href="https://docs.spacelift.io/integrations/api#spacelift-api-key-greater-than-token" target="_blank" rel="noopener">guide</a><a href="https://docs.spacelift.io/integrations/api#spacelift-api-key-greater-than-token" target="_blank" rel="noopener"> to create a new API key</a> required by the explorer. After you create your key, please note the API Key ID and API Key Secret &#8211; you’ll need both when configuring the exporter.
<h3>Installing the Prometheus Exporter</h3>
The exporter is available via a Docker image published to the <code>public.ecr.aws/spacelift/promex</code> container registry. To deploy the exporter to Kubernetes, we need to create the following resources:
<ul>
<li style="font-weight: 400;" aria-level="1">A Deployment &#8211; to run the exporter container.</li>
<li style="font-weight: 400;" aria-level="1">A Service &#8211; to allow Prometheus to scrape the exporter.</li>
<li style="font-weight: 400;" aria-level="1">A ServiceMonitor &#8211; to let Prometheus know that it needs to scrape the exporter.</li>
</ul>
The following is an example Deployment definition for running the exporter. Make sure to replace the <code>&lt;account name&gt;</code>, <code>&lt;API Key&gt;</code> and <code>&lt;API Secret&gt;</code> placeholders with the correct values:

Note: The example above defines the API key and secret as normal environment variables. We would recommend that you use <a href="https://spacelift.io/blog/kubernetes-secrets" target="_blank" rel="noopener">Kubernetes Secrets</a> for anything other than testing purposes.
Next, create a Service to expose the exporter:

And finally create your ServiceMonitor:

The ServiceMonitor definition above tells Kubernetes to scrape any services that contain an <code>app</code> label. The granularity of the metrics can be increased or decreased depending on requirements and organizational standards. The above example is configured for 15-second intervals.
<h3>Viewing your Metrics</h3>
Once you have your Prometheus stack up and running and have deployed the Spacelift exporter, you can use port-forwarding to access each component. First, let’s port-forward the exporter to port 8080 locally using the following command:

Assuming all is well, you should be able to see the raw metrics output by accessing <a href="http://localhost:8080/metrics" target="_blank" rel="nofollow noopener">http://localhost:8080/metrics</a>:

localhost8080-metrics

localhost8080 metrics

You can also port-forward to your Grafana instance to view the metrics in Grafana:

You can then quickly discover the available metrics via the Grafana Explore view:

grafana-explore-view

Grafana Explore view

One of the things that I think is amazing about the Prometheus stack is the ability to use PromQL queries not just for monitoring but for defining alerts. For example, if we want to trigger an alert whenever our worker pool has no available workers for a specific time period, we can use a query like this:

Similarly, if we want to alert when the number of queued runs for a pool gets too high, we can use a query like this:

NOTE: This section is intended to outline some of the possibilities that exist when using the Prometheus exporter and should NOT be used as a guide for a production-ready autoscaling solution. For example, it does not consider properly draining workers before scaling them down to avoid in-progress runs being terminated.
Since we have metrics related to queued runs, we can use them to autoscale private workers. We can use the <code>spacelift_worker_pool_runs_pending</code> metric, which tells us how many runs for a given worker pool are waiting to be scheduled, to detect when we need to add more workers to our pool. Similarly, we can use the <code>spacelift_worker_pool_workers</code> and <code>spacelift_worker_pool_workers_busy</code> metrics to decide when to scale down.
We need to take both sets of metrics into account to avoid scaling down just because there are no queued runs. In this situation, we might still have runs in progress that need workers.
For this to work, we need the following components available:
<ol>
<li style="font-weight: 400;" aria-level="1">A working Prometheus stack with the Spacelift Prometheus Exporter running.</li>
<li style="font-weight: 400;" aria-level="1">A Spacelift <a href="https://github.com/spacelift-io/spacelift-workerpool-k8s" target="_blank" rel="nofollow noopener">worker pool</a>.</li>
<li style="font-weight: 400;" aria-level="1">A <a href="https://github.com/kubernetes-sigs/prometheus-adapter" target="_blank" rel="nofollow noopener">prometheus-adapter</a> installation.</li>
<li style="font-weight: 400;" aria-level="1">A Horizontal Pod Autoscaler resource to tell Kubernetes how to scale our worker pool.</li>
</ol>
For the sake of simplicity, I’m going to assume that you already have steps 1 and 2 covered, and let&#8217;s assume that you’ve deployed the Spacelift worker pool chart with the default settings. I’ll also assume that you have a standard installation of the <a href="https://github.com/prometheus-community/helm-charts/tree/main/charts/kube-prometheus-stack" target="_blank" rel="nofollow noopener">kube-prometheus-stack</a> chart.
The first thing we need to do is set up a Prometheus-adapter installation. The Prometheus-adapter works like a bridge between the Kubernetes metrics API and your Prometheus installation. It allows you to use Prometheus metrics to make autoscaling decisions within your cluster. We can visualize it something like this:

kubernetes-cluster-2

Kubernetes cluster

The Prometheus-adapter uses a configuration format to map between Prometheus queries and Kubernetes metrics. In our case, we can use something like the following to generate the two metrics we need:

After deploying the adapter, you can query your metrics via the Kubernetes API, using the following commands (assuming you’ve deployed everything to a namespace called <code>monitoring</code>):

Finally, we can create a Horizontal Pod Autoscaler definition to scale our worker pool Deployment based on those metrics automatically:

Notice the metrics are grouped by the <code>worker_pool_id</code>; we can use this to target an individual worker pool when creating our HPA!
That’s it &#8211; bask in your autoscaling glory:

public-workers

worker pool

We are excited to learn how our customers use the exporter and the problems they solve with it! Feel free to provide feedback and comments via Issues in the <a href="https://github.com/spacelift-io/prometheus-exporter" target="_blank" rel="nofollow noopener">Prometheus Exporter Github repository</a>.

Spacelift is an alternative to using homegrown solutions on top of a generic CI. It helps overcome common state management issues and adds several must-have capabilities s for infrastructure management.

Alternative to Atlantis – Spacelift

Spacelift Worker Pools on Kubernetes with Spacelift

Working with Pull Requests on Spacelift

We are excited to announce the Prometheus Exporter for Spacelift! See how it allows you to monitor various metrics about your Spacelift account over time.

98-monitoring_spacellift_with_prometheus

Running Spacelift CICD Workers in Kubernetes Using DinD

Check out the Spacelift Engineering blog to discover internal technical architecture posts written by Spacelift's very own engineers. 

Engineering | Spacelift Blog

Engineering

Want to level up your Kubernetes knowledge? Explore our tutorials and step-by-step guides written by Kubernetes experts. Learn Kubernetes best practices and solutions to the most difficult problems.

Kubernetes Guides and Tutorials | Spacelift Blog

Kubernetes

For a while now at Spacelift we’ve been hearing from users that they’d like to be able to run <a href="https://docs.spacelift.io/concepts/worker-pools" target="_blank" rel="noopener">Spacelift worker pools</a> in their Kubernetes clusters. As a first step towards that we decided to investigate whether we could run workers in Kubernetes using a Docker-in-Docker sidecar container. The rest of this post gives a rough overview of the architecture of Spacelift workers, and also explains how the sidecar container strategy works.
I’d just like to say thanks to <a href="https://medium.com/@v.m_hs" target="_blank" rel="nofollow noopener">Vadym Martsynovskyy</a> for his great article about running <a href="https://medium.com/hootsuite-engineering/building-docker-images-inside-kubernetes-42c6af855f25" target="_blank" rel="nofollow noopener">Jenkins agents in Kubernetes</a>. In that article he outlines the general approach taken here, and also describes some of the pros and cons of using Docker-in-Docker. It’s definitely well worth a read.

Before going into more detail, it’s worth explaining what a Spacelift worker is, and giving a quick overview of our architecture. At Spacelift, we provide a hybrid-SaaS model like many other CI/CD systems. What this means in practice is that the control plane that handles scheduling runs is managed by us, but the execution of runs happens in a separate process called a worker. We provide a public worker pool, but also allow you to self-host your own workers, providing complete control over your infrastructure.
Perhaps confusingly, if you follow the instructions to create a private worker pool, you’ll notice that it involves downloading something called the “launcher”. The launcher is responsible for communicating with the Spacelift mothership (control plane), and creating and destroying worker containers using Docker for each Spacelift run:

image2-5

Spacelift mothership (control plane)

As you can see, the launcher process needs access to a Docker daemon in order to create a container for each run.

We found that the launcher architecture maps very nicely to Kubernetes using a sidecar container to run the Docker daemon. For each worker in the pool, we need to create a Kubernetes Pod with two containers: one for the launcher; and another for Docker. The following shows a stripped down Deployment definition for creating a worker pool with 4 workers:

The launcher communicates with the Docker-in-Docker sidecar container via TCP, which is configured via the <code>DOCKER_HOST</code> environment variable for the launcher container. This works because the containers in a Kubernetes Pod share the same <a href="https://kubernetes.io/docs/concepts/workloads/pods/#pod-networking" target="_blank" rel="nofollow noopener">IP address and port space, and can communicate with each other via localhost</a>.
In addition, a shared volume called <code>launcher-storage</code> is mounted into each container. This is used by the launcher to store the workspaces for runs, along with other things like cached tool binaries (for example Terraform). The Docker sidecar needs access to the run workspaces in order to mount them into the worker containers, and it also uses that volume to store its image cache.
The last thing worth pointing out is that the <code>dind</code> container sets <code>securityContext.privileged</code> to <code>true</code>. This is required for Docker-in-Docker to function correctly.

The Spacelift launcher is distributed as a statically linked binary, making it simple to build an image. As you can see, the Dockerfile simply copies the launcher into an Alpine container, and then sets the startup command:

This image is rebuilt and published to our public ECR repository any time the launcher binary is updated.

We provide <a href="https://spacelift.io/blog/what-are-terraform-modules-and-how-do-they-work" target="_blank" rel="noopener">Terraform modules</a> to make it really easy for users to deploy worker pools to AWS, Azure and GCP, and we wanted to provide a similar experience for Kubernetes. To achieve this, we created a Helm chart that makes it simple to deploy workers to Kubernetes clusters: <a href="https://github.com/spacelift-io/spacelift-workerpool-k8s" target="_blank" rel="nofollow noopener">https://github.com/spacelift-io/spacelift-workerpool-k8s</a>.
Assuming you’ve already configured your worker pool in Spacelift and have access to the credentials for the pool, deploying this chart to your cluster simply requires two steps.
First, add the Spacelift Helm chart repository and update your local chart cache:

Next, install the chart:

Replace <code>&lt;worker-pool-token&gt;</code> and <code>&lt;worker-pool-private-key&gt;</code> with your own credentials, and make sure to base64-encode the private key.
If all goes well, you should be able to view the pods for your worker pool using <code>kubectl get pods</code>:

You should also be able to view the workers in your pool in Spacelift:

image1-5

Bitbucket DC Local Pool

When implementing in a production environment, you may want to use an alternative approach to providing credentials, and may want to configure a custom storage volume for the worker Pods. For more information about configuring the chart, check out the README in the <a href="https://github.com/spacelift-io/spacelift-workerpool-k8s" target="_blank" rel="nofollow noopener">chart GitHub repo</a>.

If you’re interested in running <a href="https://spacelift.io/blog/spacelift-worker-pools-on-kubernetes" target="_blank" rel="noopener">Spacelift workers in Kubernetes</a>, we’d welcome any feedback about the approach, contributions to the Helm chart, and also any issues you encounter so that we can make improvements. Also, if you aren’t already using Spacelift but are interested in trying it, you can signup and <a href="https://spacelift.io/free-trial?utm_source=blog&amp;utm_medium=text&amp;utm_id=blogpost&amp;utm_content=%7Bci_cd_workers_in_kubernetes_dind%7D" target="_blank" rel="noopener">start your free evaluation of Spacelift</a>.

5 Ways to Manage Terraform at Scale - Best Practices

Building a Secure CI/CD Integration with Azure

Kubernetes Cheat Sheet - 15 Kubectl Commands & Objects

Spacelift is an alternative to using homegrown solutions on top of a generic CI. It helps overcome common state management issues and adds several must-have capabilities for infrastructure management.

Infrastructure as Code : Best Practices, Benefits & Examples

Managing Azure Resources using Spacelift

This article is an overview of the architecture of Spacelift workers with an explanation of how the sidecar container strategy works.

49-running_spacelift_cicd_workers_in_kubernetes_using_dind-3

Running Spacelift CI/CD workers in Kubernetes using DinD

Securing your infrastructure is critical for the success of your business. Failure to take security seriously can result in major damage, including fines, loss of customer confidence, or the inability to carry out crucial business functions. The growth of Infrastructure as Code tools and CI/CD systems has allowed developers to integrate infrastructure management into our typical development workflows, improving quality and delivery speed.
At the same time, in order to manage your infrastructure, the CI/CD system used needs access to sensitive credentials. At Spacelift, we aim to give our users the maximum balance between flexibility and security. Because of this, we provide multiple options for connecting your Azure subscriptions to Azure, including setting static credentials, using our fully managed integration, as well as utilizing private workers to avoid sharing credentials at all.
In this post, we wanted to give you an overview of how the <a href="https://docs.spacelift.io/integrations/cloud-providers/azure#spacelift-managed-integration" target="_blank" rel="noopener">Spacelift Azure integration</a> works from a technical perspective, as well as discuss some of the issues we encountered and solved while designing and developing it.
As a CI/CD system, we do quite a lot of work to integrate with other systems that our users use. Occasionally, like in the case of Azure, things get non-trivial. If you’re keen to learn more, read on, no Azure knowledge required!

Let’s start with a quick description of how our <a href="https://docs.spacelift.io/integrations/cloud-providers" target="_blank" rel="noopener">cloud integrations</a> work. The overall workflow is very simple and looks something like this:
&nbsp;

9-2-2

cloud integrations

Breaking the requirements down, we need to be able to get management credentials for a user’s cloud provider account and pass them to <a href="https://spacelift.io/blog/how-to-use-terraform-variables" target="_blank" rel="noopener">Terraform via environment variables</a>, at which point Terraform can run an apply with access to the customer’s infrastructure.
Note: For simplicity, this post uses <a href="https://spacelift.io/blog/what-is-terraform" target="_blank" rel="noopener">Terraform</a> in all its examples, but this overall approach also applies to the other tools that we support, for example, <a href="https://docs.spacelift.io/vendors/pulumi" target="_blank" rel="noopener">Pulumi</a>.
The concept behind the Azure integration was to provide a similar experience to our <a href="https://docs.spacelift.io/integrations/cloud-providers/aws" target="_blank" rel="noopener">AWS</a> and <a href="https://docs.spacelift.io/integrations/cloud-providers/gcp" target="_blank" rel="noopener">GCP</a> integrations, but for our Azure customers. The following diagram shows a simplified outline of how the AWS integration works:

10-2

how the AWS integration works

AWS provides the ability to temporarily <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html" target="_blank" rel="nofollow noopener">assume a role</a> in another AWS account. This allows our users to create a role in IAM with any permissions they might want to give Spacelift. They can then set up a trust relationship for this role with our AWS account, which will allow our AWS account to assume the role.
Role assumption provides us with raw AWS credentials and works seamlessly with any AWS tooling, including the Terraform AWS provider. It additionally allows us to specify the validity duration, so each run can get its own credentials which are constrained to a short period of time. 
Although Azure doesn’t have the same capability, it provides another approach called Azure Active Directory Applications, that allow service accounts to be created. Azure AD Applications are the resources that allow Spacelift to seamlessly manage access to a customer’s Azure resources.

It’s worth explaining a few pieces of terminology that are used throughout the rest of this post:
<ul>
<li style="font-weight: 400;" aria-level="1"><a href="https://azure.microsoft.com/en-gb/services/active-directory/" target="_blank" rel="nofollow noopener">Azure Active Directory</a> (Azure AD) &#8211; the identity and access management component of Azure.</li>
<li style="font-weight: 400;" aria-level="1">Directory / tenant &#8211; an individual instance of Azure AD owned by a company or individual.</li>
<li style="font-weight: 400;" aria-level="1">Subscription &#8211; the container for any Azure compute resources. This roughly corresponds to an AWS Account. A subscription is linked to a single Azure AD tenant, but multiple subscriptions can be linked to the same tenant.</li>
<li style="font-weight: 400;" aria-level="1"><a href="https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-how-applications-are-added" target="_blank" rel="nofollow noopener">Azure AD Application</a> &#8211; a way of creating external integrations with Azure AD.</li>
<li style="font-weight: 400;" aria-level="1"><a href="https://docs.microsoft.com/en-us/azure/active-directory/manage-apps/what-is-application-management" target="_blank" rel="nofollow noopener">Enterprise Application</a> &#8211; an instance of an Azure AD application that has been installed in another user’s Azure AD tenant.</li>
<li style="font-weight: 400;" aria-level="1"><a href="https://docs.microsoft.com/en-us/azure/active-directory/develop/app-objects-and-service-principals#service-principal-object" target="_blank" rel="nofollow noopener">Service Principal</a> &#8211; a service account that is automatically created when an Azure AD application is installed. This can be used to grant permissions that allow the application to <a href="https://spacelift.io/blog/managing-azure-resources-using-spacelift" target="_blank" rel="noopener">manage Azure resources</a>.</li>
<li style="font-weight: 400;" aria-level="1"><a href="https://docs.microsoft.com/en-us/graph/" target="_blank" rel="nofollow noopener">Microsoft Graph API</a> &#8211; the main API for managing Azure AD resources.</li>
</ul>

We set a number of goals for the integration:
<ul>
<li style="font-weight: 400;" aria-level="1">Making it really easy for customers to manage Azure infrastructure using Spacelift.</li>
<li style="font-weight: 400;" aria-level="1">Automatic handling of credential rotation so that customers don&#8217;t have to deal with this themselves, or use very long-lived credentials to avoid it entirely.</li>
<li style="font-weight: 400;" aria-level="1">Providing a mechanism for customers to configure granular permissions in Azure for different stacks or different types of runs (e.g. PRs vs Tracked Runs).</li>
</ul>

Initially, our idea was to create a single <a href="https://docs.microsoft.com/en-us/azure/active-directory/develop/single-and-multi-tenant-apps" target="_blank" rel="nofollow noopener">multi-tenant AD Application</a>:

multi-tenant AD Application

The idea was that we would generate an Access Token that could only be used for a specific customer directory, and pass that token to the Terraform Azure RM provider during runs. In the end, we had to revise our approach because of the following issues:
<ul>
<li style="font-weight: 400;" aria-level="1">The <a href="https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs" target="_blank" rel="nofollow noopener">Terraform Azure RM provider</a> doesn&#8217;t support authentication via an Access Token. Instead, you have to supply the underlying credentials for the account &#8211; either a Client Secret or a Client Certificate. In our case, that would have meant passing the credentials for our own multi-tenant application to Spacelift runs. Since that application would have been installed in the Azure AD tenants of any Spacelift user who had setup the integration, this could have allowed users to access other user’s Azure accounts.</li>
<li style="font-weight: 400;" aria-level="1">The integration would have been less flexible. Using a single multi-tenant AD application would have prevented customers from creating more than one Azure integration per Active Directory tenant. The ability to create multiple integrations per tenant is useful because it allows different Azure permissions to be applied to each integration.</li>
</ul>

After days of brainstorming on an alternative approach, we came up with a new architecture. We could programmatically generate a new Azure AD Application on our side for each Azure Integration created by Spacelift users.
This way, having access to the credentials for an Azure AD Application would only lead to having access to a single Azure AD Tenant on a user’s side. This approach allows Client Secrets to be passed to Spacelift runs without fear of inter-user permission leakage. The final design ended up as shown in the following diagram:

generating Azure AD application

Applications are installed into a customer’s Active Directory tenant via a process called <a href="https://docs.microsoft.com/en-us/azure/active-directory/manage-apps/grant-admin-consent" target="_blank" rel="nofollow noopener">Admin Consent</a>. After admin consent has been completed, a Service Principal is created in the user’s Azure Active Directory to which the user can grant permissions. This allows users to decide the exact level of access that Spacelift has to their resources.

The next issue we faced was related to generating credentials for a run. As described in the <a href="https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/guides/service_principal_client_secret" target="_blank" rel="nofollow noopener">provider documentation</a>, the Azure RM provider can be configured by setting certain environment variables. Initially, we took a basic approach of attempting to generate credentials during a Spacelift run. This is what we do for our AWS and GCP integrations, so we weren’t expecting major issues. The steps taken looked something like this:
<ol>
<li style="font-weight: 400;" aria-level="1">Run triggered.</li>
<li style="font-weight: 400;" aria-level="1">Generate a new Client Secret with a short expiry time.</li>
<li style="font-weight: 400;" aria-level="1">Populate the required environment variables.</li>
<li style="font-weight: 400;" aria-level="1">Execute terraform.</li>
</ol>
This seemed to work&#8230; but only some of the time.
While testing the integration, strange things were happening. As an example, the planning phase for a run would succeed, but the apply would fail with a permissions error from Azure. After investigating, we came to the conclusion that this was being caused by <a href="https://docs.microsoft.com/en-us/azure/active-directory/fundamentals/active-directory-architecture" target="_blank" rel="nofollow noopener">eventual consistency</a> in Azure AD.
You can visualize the problem using the following diagram (note: this is just an illustration, and is not meant to be completely accurate):

generating credentials issue

In the example above, step 2 may succeed or fail depending on whether the secret has managed to replicate to the Azure AD server that its request is routed to. Initially, we attempted to test whether or not the secret was usable by making an API request, and retrying until the request succeeded using an exponential backoff. What we soon realized was that even then, subsequent requests could be routed to a different Azure AD instance, which still hasn’t received the new Client Secret, and potentially fail.
Even if it was possible to verify when the secret was fully replicated, waiting for replication to complete would have added a minimum of 30 seconds, and potentially another several minutes. Because of this, we decided to move credential generation and rotation out of the run flow, and into a scheduled task:

moving credential generation and rotation into a scheduled task

The scheduled task runs once per hour, generates secrets with an expiry of 24 hours, and attempts to generate a new secret for an integration roughly 2 hours before expiry of the old secret. This allows credential rotation while always keeping a valid secret.
When a new secret is generated, we use AWS’s <a href="https://aws.amazon.com/kms/" target="_blank" rel="nofollow noopener">Key Management Service</a> to encrypt it so that it is never stored in plaintext.
When a run is triggered, we try to find the secret for the integration with the most amount of time until expiry. We also avoid using new secrets until roughly 10 minutes after generation to avoid the eventual consistency issues caused by Azure AD&#8217;s architecture.
You can visualize the secret lifecycle using the following diagram:

the secret lifecycle

In addition, when creating a new integration, we immediately generate a secret. This helps to ensure that the secret will have successfully propagated within Azure AD by the time a run is triggered.

The last major issue we faced was figuring out how to implement credential rotation for our own management account. The integration itself uses an Azure AD Service Principal to manage customer AD Applications using the Microsoft Graph API.
Because we run most of our own infrastructure in AWS, we didn&#8217;t have the option of using a <a href="https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/overview" target="_blank" rel="nofollow noopener">Managed Service Identity</a>, meaning that we needed to handle credential rotation ourselves. In addition, our goal was to automate the process to avoid developers having to periodically perform a manual task, and to reduce the risk of forgetting to renew the credentials before expiry.
In the end, we decided to take the relatively simple approach of storing the certificate in Secrets Manager and writing a scheduled task to periodically check whether the certificate was ready to expire, similar to the approach we took for Client Secrets for the integration. If so the scheduled task generates a new certificate and uploads it to both Secrets Manager and Azure AD:

scheduled task generates a new certificate and uploads it to Secrets Manager and Azure AD

The parts of the system that need to use the client certificate for authentication periodically check for an updated certificate. As with the client secret rotation, we avoid using the new certificate for approximately 10 minutes to allow time for the certificate to propagate throughout Azure AD.
Similar to what happens with the integration client secrets, Secrets Manager uses AWS Key Management Service to encrypt the certificate at rest.

Hopefully, this post has given you a glimpse into the internals of Spacelift&#8217;s Azure integration, along with some of the problems we had to solve while implementing it. As you probably noticed, we’re willing to go to great lengths to ensure a secure and pleasant experience for our users. To find out more, take a look at our Azure integration documentation available at <a href="https://docs.spacelift.io/integrations/cloud-providers/azure" target="_blank" rel="noopener">Spacelift Documentation</a>.

How to Manage Active Directory Objects with Azure AD Provider for Terraform

Introducing the Spacelift Azure Integration!

Learn how to build a secure CI/CD integration with Azure. See how Spacelift Azure integration works from a technical perspective.

2-building_a_secure_cicd_integration_with_azure

At Spacelift, we&#8217;re excited to announce our new fully-managed integration with Azure. This integration makes it even easier for customers to get up and running fast without having to manually manage Azure Service Principal credentials.

In keeping with our tagline &#8220;the most flexible management platform for Infrastructure as Code&#8221;, and to give you maximum flexibility, you have multiple choices to integrate Spacelift with Azure:
<ul>
<li style="font-weight: 400;" aria-level="1"><a href="https://docs.spacelift.io/integrations/cloud-providers/azure#spacelift-managed-integration" target="_blank" rel="noopener">Using our Azure integration</a>.</li>
<li style="font-weight: 400;" aria-level="1"><a href="https://docs.spacelift.io/integrations/cloud-providers/azure#static-credentials" target="_blank" rel="noopener">Manually configuring Azure credentials via environment variables</a>.</li>
<li style="font-weight: 400;" aria-level="1"><a href="https://docs.spacelift.io/integrations/cloud-providers/azure#managed-identities" target="_blank" rel="noopener">Running a private worker, and using a Managed Identity</a>.</li>
</ul>
Spacelift’s Azure integration is aimed at customers who want a fully managed experience, new customers who want to quickly get up and running, and existing customers who are manually managing their Azure credentials via Spacelift environment variables or contexts.
We recommend that customers who desire more control for security or compliance reasons should continue using private runners.

Spacelift’s Azure integration provides the following features:
<ul>
<li style="font-weight: 400;" aria-level="1">Easily connect to your Azure subscriptions and attach them to your stacks.</li>
<li style="font-weight: 400;" aria-level="1">Automatic credential rotation.</li>
<li style="font-weight: 400;" aria-level="1">The ability to use granular permissions depending on the action being performed.</li>
</ul>

To connect to your Azure subscription, simply add a new Azure integration via your account settings, specifying your Tenant ID and optionally a default subscription ID:

Azure Integration

Install the Enterprise Application for the integration into your Azure AD tenant using the Provide Consent button:

Azure AD Provide Consent

Setup your permissions in Azure:

setting up permissions in Azure

Attach the integration to any Spacelift stacks that require it:

Attaching the integration to any Spacelift stacks

That’s it, you’re now ready for launch!

When you set up an Azure integration in Spacelift, a Service Principal is created in your directory that you can use to manage permissions. We automatically rotate the credentials for this Service Principal roughly every 24 hours while making sure that there is always a valid credential for your stacks to use.

Spacelift’s Azure integration supports granular permissions by allowing you to setup more than one integration per tenant:

Spacelift’s Azure integration

Each integration will create a Service Principal in Azure with a unique display name:

Service Principal

You can then assign the relevant permissions to each role in Azure:

assigning the relevant permissions

And finally attach them to your stack as read or write:

read or write integration

Once you’ve attached both Azure integrations to your stack, Spacelift will automatically use the correct one depending on the phase of the run being executed. This allows you to provide read-only roles to planning runs (for example PRs), while providing write access for deployments.

To find out more about the Azure integration, take a look at our documentation available at <a href="https://docs.spacelift.io/integrations/cloud-providers/azure" target="_blank" rel="noopener">Spacelift Documentation</a>. You might also be interested in the detailed overview of <a href="https://spacelift.io/blog/building-secure-cicd-integration-with-azure" target="_blank" rel="noopener">How we Built a Secure CI/CD Integration with Azure</a> and some of the issues we encountered and solved while designing and developing it.

We're excited to announce our new fully-managed integration with Azure. This integration makes it even easier for customers to get up and running fast without having to manually manage Azure Service Principal credentials.

1-azure-integration

Introducing the Spacelift Azure Integration

Want to level up your Terraform knowledge? Explore our tutorials and step-by-step guides written by Terraform experts. Learn Terraform best practices and solutions to the most difficult problems.

Terraform Guides and Tutorials | Spacelift Blog

Terraform

The <a href="https://registry.terraform.io/providers/hashicorp/azuread/latest/docs" target="_blank" rel="nofollow noopener">Azure AD provider for Terraform</a> can be used to manage your Azure Active Directory resources declaratively. This allows you to do things like:
<ul>
<li style="font-weight: 400;" aria-level="1">Automatically provision users and make sure they belong to the correct groups.</li>
<li style="font-weight: 400;" aria-level="1">Manage Azure compute permissions via Azure AD groups.</li>
</ul>
In this post, you will learn what the Azure AD Terraform provider is used for, how to authenticate and grant permissions, and see examples of what you can do with it. Let’s get started.

The following example shows how to use the Azure AD provider to create a <a href="https://registry.terraform.io/providers/hashicorp/azuread/latest/docs/resources/group" target="_blank" rel="nofollow noopener">group</a> in Azure AD:

The <code>terraform</code> section at the beginning is used to specify the version of the provider that we want to use, while the <code>azuread_group</code>  resource defines our group.

The Azure AD provider allows for multiple authentication methods, which are outlined in the <a href="https://registry.terraform.io/providers/hashicorp/azuread/latest/docs#authenticating-to-azure-active-directory" target="_blank" rel="nofollow noopener">provider&#8217;s documentation</a>. To allow you to get up and running quickly, the AD provider will attempt to get your credentials via the <a href="https://docs.microsoft.com/en-us/cli/azure/install-azure-cli" target="_blank" rel="nofollow noopener">Azure CLI</a>.
While this is fine for experimentation and local testing, for non-interactive scenarios like CI you will need to use a Service Principal or a Managed Service Identity.

In order to manage your Azure AD objects, the account used by <a href="https://spacelift.io/blog/what-is-terraform" target="_blank" rel="noopener">Terraform</a> needs to have the correct permissions to perform its actions. You can manage these permissions via the Roles and administrators section of Azure AD:

Roles and administrators section of Azure AD

For example, to allow a Service Principal to manage groups, you would add it to the Groups administrator role:

Azure AD Groups administrator

The Terraform provider is well documented, and will typically contain a notice at the top of each resource explaining the permissions that are required for using it.

Another option that can be used with Service Principals instead of granting an administrator role is to assign specific API permissions to them. To do this, first find the AD Application linked to your Service Principal in the App Registrations section:

Service Principal in the App Registrations section

Go to the API permissions page for the application, and click on Add a permission:

Manage Active Directory Objects

In the window that appears, choose the Azure Active Directory Graph API, and then select the relevant permission you want to add:

Azure Active Directory Graph API

Before the Service Principal can actually use the permission you just added, you need to take a final step called granting Admin Consent. You can do this by clicking on the Grant admin consent for &lt;tenant&gt; button displayed above the permissions table:

5-5-2

Azure AD Admin Consent

NOTES:
<ul>
<li style="font-weight: 400;" aria-level="1">When adding permissions to your Service Principal, you need to add Application permissions rather than Delegated permissions. This means that the Service Principal is allowed to perform the specified actions as itself, rather than on behalf of another user.</li>
<li style="font-weight: 400;" aria-level="1">The set of permissions that you can add via API permissions is quite limited. For example, to create AD groups you need to add the Directory.ReadWrite.All permission, but this will not allow your Service Principal to delete any of the groups it creates. In order to be able to delete groups, you need to grant it the Group Administrator role, so depending on your requirements there may not be any point in granting API permissions.</li>
<li style="font-weight: 400;" aria-level="1">The Azure AD Terraform provider switches to the Microsoft Graph API as of version 2.0.0, so when version 2 is released you will need to grant permissions to the Microsoft Graph API instead of to the Azure Active Directory Graph API.</li>
</ul>

<h3>Example 1 &#8211; Managing Users and Groups</h3>
The following example creates two users and two groups, and assigns each user to a group:

<h3>Example 2 &#8211; Creating a Service Principal and granting RBAC permissions</h3>
The following example combines the Azure AD provider with the <a href="https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs" target="_blank" rel="nofollow noopener">Azure RM provider</a>, allowing you to create a Service Principal and assign it permission to <a href="https://spacelift.io/blog/managing-azure-resources-using-spacelift" target="_blank" rel="noopener">manage certain Azure resources</a>:

In this post, we’ve covered what the Azure AD Terraform provider is used for, how to authenticate and grant the correct permissions, as well as showing a few examples of what can be done with it. Hopefully, you’ve found it useful!
If you’re interested in finding out about how you can use Spacelift to manage your Azure resources via the Terraform <a href="https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs" target="_blank" rel="nofollow noopener">Azure Provider</a>, check out our <a href="https://docs.spacelift.io/integrations/cloud-providers/azure" target="_blank" rel="noopener">Azure documentation</a>. There you can also learn how to configure the following authentication methods in Spacelift: Spacelift Managed Integration, Static Credentials and Managed Service Identities. And don’t forget that you can easily take Spacelift for a <a href="https://spacelift.io/free-trial?utm_source=blog&amp;utm_medium=text&amp;utm_id=blogpost&amp;utm_content=%7Bhow_to_manage_active_directory_objects_with_azure_ad_provider_for_terraform%7D" target="_blank" rel="noopener">free test drive</a>!

Spacelift helps manage Terraform state, build more complex workflows, supports policy as code, programmatic configuration, context sharing, drift detection, resource visualization and many more.

Importing Existing Infrastructure into Terraform - Step by Step

Learn how to manage Active Directory Objects with Azure AD Provider for Terraform. See examples of how to authenticate and grant the correct permissions.

15-azure-directories

Active Directory Objects with Azure AD Provider for Terraform

<dfn>Open Policy Agent</dfn> is an open-source engine that provides a way of declaratively writing policies as code and then using those policies as part of a decision-making process. It uses a policy language called Rego, allowing you to write policies for different services using the same language.
OPA can be used for a number of purposes, including:
<ul>
<li style="font-weight: 400;" aria-level="1">Authorization of REST API endpoints.</li>
<li style="font-weight: 400;" aria-level="1">Allowing or denying Terraform changes based on compliance or safety rules.</li>
<li style="font-weight: 400;" aria-level="1">Integrating custom authorization logic into applications.</li>
<li style="font-weight: 400;" aria-level="1">Implementing Kubernetes Admission Controllers to validate API requests.</li>
</ul>
OPA was originally created by <a href="https://www.styra.com/" target="_blank" rel="noopener">Styra</a>, and is now part of the Cloud Native Computing Foundation (CNCF), alongside other CNCF technologies like Kubernetes and Prometheus.
In this article, I will give an overview of Open Policy Agent, explain why you would want to use it, as well as showcase how you can use OPA with your Spacelift account. Although OPA can serve many purposes, I’m going to focus on how it can be used alongside <a href="https://spacelift.io/blog/infrastructure-as-code" target="_blank" rel="noopener">Infrastructure as Code</a>.

We can visualise how OPA works using the following diagram:

how-does-opa-work

Open Policy Agent (OPA) Example

What is Open Policy Agent (OPA)? See Open Policy Agent examples and a full tutorial on when to use it.