Adobe Load & Scale
Overview
Load testing and scaling strategies for Adobe API integrations. Adobe APIs are async and relatively slow (5-30s per operation), requiring different load testing approaches than typical REST APIs.
Prerequisites
- k6 load testing tool installed (
npm install -g k6 or brew install k6)
- Adobe Developer Console credentials for testing (separate from production)
- Kubernetes cluster with HPA configured (for auto-scaling)
- Understanding of your Adobe API rate limits
Instructions
Step 1: k6 Load Test for Firefly API
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';
const errorRate = new Rate('adobe_errors');
const fireflyDuration = new Trend('firefly_duration');
export const options = {
stages: [
{ duration: '1m', target: 2 },
{ duration: '3m', target: 5 },
{ duration: '2m', target: 10 },
{ duration: '1m', target: 0 },
],
thresholds: {
http_req_duration: ['p(95)<30000'],
adobe_errors: ['rate<0.05'],
},
};
const TOKEN = __ENV.ADOBE_ACCESS_TOKEN;
const CLIENT_ID = __ENV.ADOBE_CLIENT_ID;
export default function () {
const response = http.post(
'https://firefly-api.adobe.io/v3/images/generate',
JSON.stringify({
prompt: `Load test image ${Date.now()}`,
n: 1,
size: { width: 512, height: 512 },
}),
{
headers: {
'Authorization': `Bearer ${TOKEN}`,
'x-api-key': CLIENT_ID,
'Content-Type': 'application/json',
},
timeout: '60s',
}
);
const success = check(response, {
'status is 200': (r) => r.status === 200,
'status is not 429': (r) => r.status !== 429,
});
errorRate.add(!success);
fireflyDuration.add(response.timings.duration);
if (response.status === 429) {
const retryAfter = parseInt(response.headers['Retry-After'] || '30');
console.log(`Rate limited, waiting ${retryAfter}s`);
sleep(retryAfter);
} else {
sleep(3);
}
}
Step 2: k6 Load Test for PDF Services
import http from 'k6/http';
import { check, sleep } from 'k6';
export const options = {
stages: [
{ duration: '1m', target: 3 },
{ duration: '5m', target: 10 },
{ duration: '1m', target: 0 },
],
thresholds: {
http_req_duration: ['p(95)<15000'],
http_req_failed: ['rate<0.02'],
},
};
export default function () {
const response = http.post(
`${__ENV.APP_URL}/api/extract-pdf`,
http.file(open('./test-fixtures/sample-5page.pdf', 'b'), 'test.pdf'),
{ timeout: '30s' }
);
check(response, {
'extraction successful': (r) => r.status === 200,
'has text content': .(r.).?. > ,
});
();
}
Step 3: Run Load Tests
export ADOBE_ACCESS_TOKEN=$(curl -s -X POST \
'https://ims-na1.adobelogin.com/ims/token/v3' \
-d "client_id=${ADOBE_CLIENT_ID}&client_secret=${ADOBE_CLIENT_SECRET}&grant_type=client_credentials&scope=${ADOBE_SCOPES}" | jq -r '.access_token')
k6 run --env ADOBE_ACCESS_TOKEN=${ADOBE_ACCESS_TOKEN} \
--env ADOBE_CLIENT_ID=${ADOBE_CLIENT_ID} \
adobe-firefly-load.js
k6 run --env APP_URL=https://staging.yourapp.com \
adobe-pdf-load.js
k6 run --out influxdb=http://localhost:8086/k6 adobe-firefly-load.js
Step 4: Kubernetes Auto-Scaling
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: adobe-service-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: adobe-service
minReplicas: 2
maxReplicas: 20
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 60
- type: Pods
pods:
metric:
name: adobe_pending_jobs
target:
type: AverageValue
averageValue: 5
behavior:
scaleUp:
stabilizationWindowSeconds: 60
policies:
- type: Pods
Step 5: Capacity Planning
interface AdobeCapacityPlan {
api: string;
peakRps: number;
avgLatencyMs: number;
concurrencyNeeded: number;
podsNeeded: number;
monthlyTransactions: number;
tierNeeded: string;
}
function planCapacity(metrics: {
peakRps: number;
avgLatencyMs: number;
connectionsPerPod: number;
}): AdobeCapacityPlan {
const concurrency = metrics.peakRps * metrics.avgLatencyMs / 1000;
const pods = Math.ceil(concurrency / metrics.connectionsPerPod);
return {
api: 'firefly',
peakRps: metrics.peakRps,
avgLatencyMs: metrics.avgLatencyMs,
: .(concurrency),
: pods,
: metrics. * * * ,
: pods > ? : ,
};
}
Output
- k6 load test scripts for Firefly and PDF Services
- Kubernetes HPA with Adobe-aware scaling metrics
- Capacity planning model accounting for async API latency
- Benchmark results template for documentation
Error Handling
| Issue | Cause | Solution |
|---|
| All requests 429 in k6 | Rate limit exceeded | Reduce VU count; add sleep |
| k6 timeout | Adobe API > 60s | Increase k6 request timeout |
| HPA not scaling | Custom metric not exposed | Verify Prometheus metric exists |
| Token expires mid-test | Long test duration | Token valid 24h; pre-generate |
Resources
Next Steps
For reliability patterns, see adobe-reliability-patterns.
