← Files LaunchDarklyARCHIVED FILE
skills/projects/references/iac-automation.md
11.8 KB · Oct 2, 2026 · 00:24 UTC
# Infrastructure as Code (IaC) Automation
Automate project management using IaC tools and CI/CD pipelines.
## Terraform
### LaunchDarkly Terraform Provider
Install and configure the LaunchDarkly Terraform provider:
```hcl
# terraform/main.tf
terraform {
required_providers {
launchdarkly = {
source = "launchdarkly/launchdarkly"
version = "~> 2.0"
}
}
}
provider "launchdarkly" {
access_token = var.launchdarkly_access_token
}
```
### Define Projects
```hcl
# terraform/projects.tf
variable "launchdarkly_access_token" {
description = "LaunchDarkly API access token"
type = string
sensitive = true
}
resource "launchdarkly_project" "customer_ai" {
key = "customer-ai"
name = "Customer Agent Service"
tags = ["ai-configs", "production", "terraform"]
}
resource "launchdarkly_project" "platform_ai" {
key = "platform-ai"
name = "Platform Agent Service"
tags = ["ai-configs", "production", "terraform"]
}
# Output SDK keys
output "customer_ai_sdk_key_production" {
value = launchdarkly_project.customer_ai.environments[0].api_key
sensitive = true
}
output "customer_ai_sdk_key_test" {
value = launchdarkly_project.customer_ai.environments[1].api_key
sensitive = true
}
```
### Custom Environments
```hcl
resource "launchdarkly_project" "my_project" {
key = "my-project"
name = "My Project"
environments = [
{
key = "production"
name = "Production"
color = "FF0000"
},
{
key = "staging"
name = "Staging"
color = "FFA500"
},
{
key = "development"
name = "Development"
color = "00FF00"
}
]
}
```
### Apply Terraform
```bash
# Initialize
terraform init
# Plan changes
terraform plan -var="launchdarkly_access_token=$LAUNCHDARKLY_API_TOKEN"
# Apply
terraform apply -var="launchdarkly_access_token=$LAUNCHDARKLY_API_TOKEN"
# Get SDK key
terraform output -raw customer_ai_sdk_key_production
```
### Save SDK Keys to Files
```hcl
# Save SDK keys to local files (for development only)
resource "local_file" "sdk_key_production" {
content = launchdarkly_project.customer_ai.environments[0].api_key
filename = "${path.module}/.env.production"
# Don't commit these files!
provisioner "local-exec" {
command = "echo '.env.production' >> .gitignore"
}
}
```
## GitHub Actions
Automate project creation in CI/CD:
### Create Project on Deploy
```yaml
# .github/workflows/setup-launchdarkly.yml
name: Setup LaunchDarkly Project
on:
workflow_dispatch:
inputs:
project_key:
description: 'Project key'
required: true
project_name:
description: 'Project name'
required: true
jobs:
setup:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python
uses: actions/setup-python@v4
with:
python-version: '3.11'
- name: Install dependencies
run: |
pip install requests python-dotenv
- name: Create LaunchDarkly Project
env:
LAUNCHDARKLY_API_TOKEN: ${{ secrets.LAUNCHDARKLY_API_TOKEN }}
run: |
python scripts/create_project.py \
--name "${{ github.event.inputs.project_name }}" \
--key "${{ github.event.inputs.project_key }}" \
--tags "github-actions,automated"
- name: Save SDK Keys to Secrets
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
PROJECT_KEY: ${{ github.event.inputs.project_key }}
run: |
SDK_KEY=$(python scripts/get_sdk_key.py $PROJECT_KEY production)
gh secret set LAUNCHDARKLY_SDK_KEY --body "$SDK_KEY"
```
### Automated Project Creation on New Service
```yaml
# .github/workflows/new-service.yml
name: New Service Setup
on:
create:
branches:
- 'service/*'
jobs:
setup-project:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Extract service name
id: service
run: |
BRANCH_NAME="${{ github.ref }}"
SERVICE_NAME="${BRANCH_NAME#refs/heads/service/}"
echo "name=$SERVICE_NAME" >> $GITHUB_OUTPUT
echo "key=${SERVICE_NAME//_/-}" >> $GITHUB_OUTPUT
- name: Create LaunchDarkly Project
env:
LAUNCHDARKLY_API_TOKEN: ${{ secrets.LAUNCHDARKLY_API_TOKEN }}
run: |
python scripts/create_project.py \
--name "${{ steps.service.outputs.name }} Service" \
--key "${{ steps.service.outputs.key }}-service" \
--tags "service,automated"
```
## GitLab CI
```yaml
# .gitlab-ci.yml
stages:
- setup
- deploy
setup-launchdarkly:
stage: setup
image: python:3.11
script:
- pip install requests
- |
python -c "
from launchdarkly.projects import ProjectManager
pm = ProjectManager('$LAUNCHDARKLY_API_TOKEN')
project = pm.create_project(
name='$CI_PROJECT_NAME',
key='$CI_PROJECT_NAME',
tags=['gitlab-ci', '$CI_ENVIRONMENT_NAME']
)
sdk_key = pm.get_sdk_key('$CI_PROJECT_NAME', 'production')
print(f'SDK_KEY={sdk_key}')
" > .env.production
artifacts:
paths:
- .env.production
expire_in: 1 day
only:
- main
```
## CircleCI
```yaml
# .circleci/config.yml
version: 2.1
jobs:
setup-launchdarkly:
docker:
- image: cimg/python:3.11
steps:
- checkout
- run:
name: Install dependencies
command: pip install requests
- run:
name: Create LaunchDarkly project
command: |
python scripts/create_project.py \
--name "$CIRCLE_PROJECT_REPONAME" \
--key "$CIRCLE_PROJECT_REPONAME" \
--tags "circleci,automated"
- run:
name: Save SDK key
command: |
SDK_KEY=$(python scripts/get_sdk_key.py $CIRCLE_PROJECT_REPONAME production)
echo "export LAUNCHDARKLY_SDK_KEY='$SDK_KEY'" >> $BASH_ENV
workflows:
setup:
jobs:
- setup-launchdarkly
```
## Ansible
Manage projects with Ansible:
```yaml
# playbooks/setup-launchdarkly.yml
---
- name: Setup LaunchDarkly Projects
hosts: localhost
vars:
launchdarkly_api_token: "{{ lookup('env', 'LAUNCHDARKLY_API_TOKEN') }}"
projects:
- name: "Customer Agent Service"
key: "customer-ai"
tags: ["ai-configs", "production"]
- name: "Platform Agent Service"
key: "platform-ai"
tags: ["ai-configs", "production"]
tasks:
- name: Create LaunchDarkly projects
uri:
url: "https://app.launchdarkly.com/api/v2/projects"
method: POST
headers:
Authorization: "{{ launchdarkly_api_token }}"
Content-Type: "application/json"
body_format: json
body:
name: "{{ item.name }}"
key: "{{ item.key }}"
tags: "{{ item.tags }}"
status_code: [201, 409]
loop: "{{ projects }}"
register: project_results
- name: Get SDK keys
uri:
url: "https://app.launchdarkly.com/api/v2/projects/{{ item.key }}?expand=environments"
method: GET
headers:
Authorization: "{{ launchdarkly_api_token }}"
loop: "{{ projects }}"
register: sdk_keys
- name: Save SDK keys to .env
copy:
content: |
LAUNCHDARKLY_SDK_KEY={{ item.json.environments.items[0].apiKey }}
dest: ".env.{{ item.item.key }}"
loop: "{{ sdk_keys.results }}"
no_log: true
```
**Run playbook:**
```bash
ansible-playbook playbooks/setup-launchdarkly.yml
```
## Pulumi
Infrastructure as code with Pulumi:
### Python
```python
# __main__.py
import pulumi
import pulumi_launchdarkly as launchdarkly
# Create projects
customer_ai = launchdarkly.Project(
"customer-ai",
key="customer-ai",
name="Customer Agent Service",
tags=["ai-configs", "production", "pulumi"]
)
platform_ai = launchdarkly.Project(
"platform-ai",
key="platform-ai",
name="Platform Agent Service",
tags=["ai-configs", "production", "pulumi"]
)
# Export SDK keys
pulumi.export("customer_ai_sdk_key_prod", customer_ai.environments[0]["api_key"])
pulumi.export("customer_ai_sdk_key_test", customer_ai.environments[1]["api_key"])
```
### TypeScript
```typescript
// index.ts
import * as pulumi from "@pulumi/pulumi";
import * as launchdarkly from "@pulumi/launchdarkly";
// Create projects
const customerAi = new launchdarkly.Project("customer-ai", {
key: "customer-ai",
name: "Customer Agent Service",
tags: ["ai-configs", "production", "pulumi"],
});
const platformAi = new launchdarkly.Project("platform-ai", {
key: "platform-ai",
name: "Platform Agent Service",
tags: ["ai-configs", "production", "pulumi"],
});
// Export SDK keys
export const customerAiSdkKeyProd = customerAi.environments[0].apiKey;
export const customerAiSdkKeyTest = customerAi.environments[1].apiKey;
```
**Deploy:**
```bash
pulumi up
pulumi stack output customerAiSdkKeyProd
```
## Docker Compose
Initialize projects in Docker setup:
```yaml
# docker-compose.yml
version: '3.8'
services:
setup-launchdarkly:
image: python:3.11-slim
environment:
- LAUNCHDARKLY_API_TOKEN=${LAUNCHDARKLY_API_TOKEN}
volumes:
- ./scripts:/scripts
- ./.env.production:/output/.env
command: >
sh -c "
pip install requests &&
python /scripts/create_project.py --name 'My Service' --key my-service &&
python /scripts/save_sdk_key.py my-service production > /output/.env
"
app:
build: .
depends_on:
- setup-launchdarkly
env_file:
- .env.production
```
## Kubernetes Operator
Custom operator to manage projects:
```yaml
# k8s/launchdarkly-project.yaml
apiVersion: launchdarkly.com/v1
kind: Project
metadata:
name: customer-ai
spec:
key: customer-ai
name: Customer Agent Service
tags:
- ai-configs
- production
- kubernetes
secretName: launchdarkly-sdk-keys
```
**Operator implementation (Python):**
```python
# operator/controller.py
import kopf
from launchdarkly.projects import ProjectManager
from kubernetes import client, config
@kopf.on.create('launchdarkly.com', 'v1', 'projects')
def create_project(spec, name, namespace, **kwargs):
"""Handle Project creation."""
pm = ProjectManager()
# Create project
project = pm.create_project(
name=spec['name'],
key=spec['key'],
tags=spec.get('tags', [])
)
# Get SDK keys
sdk_key_prod = pm.get_sdk_key(spec['key'], 'production')
sdk_key_test = pm.get_sdk_key(spec['key'], 'test')
# Create Kubernetes Secret
config.load_incluster_config()
v1 = client.CoreV1Api()
secret = client.V1Secret(
metadata=client.V1ObjectMeta(
name=spec.get('secretName', f"{name}-sdk-keys"),
namespace=namespace
),
string_data={
'sdk-key-production': sdk_key_prod,
'sdk-key-test': sdk_key_test
}
)
v1.create_namespaced_secret(namespace, secret)
return {'message': f'Created project {spec["key"]}'}
```
## Make/Taskfile
Simple automation with Make:
```makefile
# Makefile
.PHONY: create-project list-projects get-key
create-project:
@python scripts/create_project.py \
--name "$(NAME)" \
--key "$(KEY)" \
--tags "$(TAGS)"
list-projects:
@python scripts/list_projects.py
get-key:
@python scripts/get_sdk_key.py $(PROJECT) $(ENV)
setup-env:
@python scripts/save_sdk_key.py $(PROJECT) production > .env.production
@echo "✓ Saved SDK key to .env.production"
```
**Usage:**
```bash
make create-project NAME="My Agent" KEY=my-ai TAGS=ai-configs,production
make list-projects
make get-key PROJECT=my-ai ENV=production
make setup-env PROJECT=my-ai
```
## Next Steps
- [Build admin tooling](admin-tooling.md)
- [Configure project cloning](project-cloning.md)
- [Manage environment configuration](env-config.md)
SHA-256: c69908978ee05ccf814da6c6f34793013ef7dbcb911409044521674e7c624e5c