scripting
Use when running acli commands non-interactively in scripts, CI/CD pipelines, or automation where interactive prompts must be suppressed.
How do I install this agent skill?
npx skills add https://github.com/acquia/acquia-skills --skill scriptingIs this agent skill safe to install?
- Gen Agent Trust Hubpass
This skill provides instructions for automating Acquia CLI tasks in scripts and CI/CD pipelines. It adheres to security best practices by promoting the use of environment variables and secret managers for credential handling and correctly identifies risks associated with command-line argument exposure. External downloads originate from the official vendor repository.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
What does this agent skill do?
Scripting & Automation with Acquia CLI
Use when:
- Automating acli commands in shell scripts
- Integrating acli into CI/CD pipelines
- Running acli non-interactively
Use acli in scripts, CI/CD pipelines, and automation workflows to manage Acquia Cloud resources programmatically.
Non-Interactive Commands
All acli commands can run non-interactively by providing options. This is essential for scripts and CI/CD.
Basic pattern
# Interactive - prompts for missing information
acli ide:create
# Non-interactive - provides all info upfront
acli ide:create \
--application=abc123 \
--label="Automated IDE"
Common options
# No prompts - fails if info is missing
acli <command> --no-interaction
# Don't wait for async operations
acli <command> --no-wait
# Skip confirmations
acli <command> --yes
Simple Automation Examples
Example 1: Deploy on schedule
#!/bin/bash
# deploy.sh - Deploy to staging nightly
BRANCH="develop"
ENVIRONMENT="staging"
ENV_ID="<environment-id>"
acli api:environments:code-switch $ENV_ID $BRANCH
# Verify Drupal status
acli remote:drush status
MEO (V3) subscriptions: replace the
api:environments:code-switchline withacli api:v3:environments:create-deployment $ENV_ID true $BRANCH(see MEO Deployments). Likewise,acli remote:drush crhas an API-driven equivalent,acli api:v3:environments:clear-caches <environmentId> <domains>(see MEO Environments).
Run via cron:
# crontab -e
# Deploy every night at 2am
0 2 * * * /path/to/deploy.sh >> /tmp/deploy.log 2>&1
Example 2: Cache clearing workflow
#!/bin/bash
# cache-clear.sh - Clear caches across environments
set -e # Exit on any error
acli remote:drush cr
echo "Caches cleared!"
CI/CD Integration
GitHub Actions
Deploy on push to main:
# .github/workflows/deploy.yml
name: Deploy to Acquia
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Install acli
run: |
curl -fsSL https://github.com/acquia/cli/releases/latest/download/native-acli-linux-x86_64.tar.gz \
| tar -xz -C /usr/local/bin acli
chmod +x /usr/local/bin/acli
- name: Deploy to production
env:
ACLI_KEY: ${{ secrets.ACQUIA_KEY }}
ACLI_SECRET: ${{ secrets.ACQUIA_SECRET }}
run: |
acli api:environments:code-switch ${{ vars.ACQUIA_PROD_ENV_ID }} main
Store the credentials as repository secrets named ACQUIA_KEY/ACQUIA_SECRET; the env:
block above maps them into the job as ACLI_KEY/ACLI_SECRET, which is what ACLI itself
reads. They take first priority over any stored credentials, so there's no credentials file
to write — just map them for the step that needs them.
GitLab CI/CD
# .gitlab-ci.yml
deploy_production:
stage: deploy
image: ubuntu:latest
variables:
ACLI_KEY: $ACQUIA_KEY
ACLI_SECRET: $ACQUIA_SECRET
before_script:
- apt-get update && apt-get install -y curl ca-certificates
- curl -fsSL https://github.com/acquia/cli/releases/latest/download/native-acli-linux-x86_64.tar.gz
| tar -xz -C /usr/local/bin acli
- chmod +x /usr/local/bin/acli
script:
- acli api:environments:code-switch $ACQUIA_PROD_ENV_ID $CI_COMMIT_BRANCH
only:
- main
Set ACQUIA_KEY and ACQUIA_SECRET as masked CI/CD variables in the project's Settings →
CI/CD → Variables. GitLab injects CI/CD variables into the job environment under the same
name they're stored as, so the variables: block above re-maps them to ACLI_KEY/ACLI_SECRET
for the job — that's the name ACLI itself reads.
Error Handling
Check exit codes
#!/bin/bash
acli ide:create --application=abc123
if [ $? -eq 0 ]; then
echo "IDE created successfully"
else
echo "IDE creation failed"
exit 1
fi
Handle errors gracefully
#!/bin/bash
set -e # Exit on first error
trap 'echo "Error occurred on line $LINENO"' ERR
acli api:environments:code-switch $ENV_ID main
echo "Deploy successful!"
Retry logic
#!/bin/bash
retry_count=0
max_retries=3
while [ $retry_count -lt $max_retries ]; do
if acli remote:drush updatedb; then
echo "Database updates completed"
exit 0
fi
retry_count=$((retry_count + 1))
if [ $retry_count -lt $max_retries ]; then
echo "Attempt $retry_count failed. Retrying..."
sleep 10
fi
done
echo "Failed after $max_retries attempts"
exit 1
Logging & Monitoring
Log output
#!/bin/bash
LOGFILE="/var/log/acli-deploy.log"
{
echo "=== Deploy started at $(date) ==="
acli api:environments:code-switch $ENV_ID main
echo "=== Deploy finished at $(date) ==="
} >> $LOGFILE 2>&1
Send notifications
#!/bin/bash
SLACK_WEBHOOK="$SLACK_WEBHOOK_URL"
send_slack() {
curl -X POST $SLACK_WEBHOOK \
-H 'Content-Type: application/json' \
-d "{
\"text\": \"Acquia deployment: $1\",
\"channel\": \"#deployments\"
}"
}
if acli api:environments:code-switch $ENV_ID main; then
send_slack "✓ Production deployment successful"
else
send_slack "✗ Production deployment failed"
exit 1
fi
Advanced: Authenticating Without a Human Present
Three options for unattended automation, depending on whether a human is in the loop at all:
API key + secret via environment variables — for a true service account with nobody ever
approving a login (a long-running CI bot, a scheduled job). Generate a key in Acquia Cloud UI
under Settings → API Tokens, store it in your secrets manager as ACQUIA_KEY/ACQUIA_SECRET,
then export it as ACLI_KEY/ACLI_SECRET — the name ACLI itself reads:
export ACLI_KEY="$ACQUIA_KEY"
export ACLI_SECRET="$ACQUIA_SECRET"
acli api:applications:list
These take first priority over any stored credentials, so no prior acli auth:login is
needed on the machine running this — every command reads them fresh, and nothing is written
to disk.
API key + secret via auth:login --key/--secret — the same credentials, used instead
to persist a stored session once rather than exporting the pair for every command:
acli auth:login --key="$ACLI_KEY" --secret="$ACLI_SECRET" --no-interaction
This writes the credentials to cloud_api.conf, so subsequent commands in the same job pick
them up without re-passing anything. --key/--secret put the secret value in the
process's argv either way — the shell expands "$ACLI_KEY" before acli ever runs, so the
real value is visible to ps aux/process listings on the same machine whether you pass it as
a variable or as literal text. A variable only keeps the literal value out of your shell
history. On a shared or multi-tenant runner, prefer the environment-variable-only option
above instead — exporting ACLI_KEY/ACLI_SECRET never puts the secret on the command line
at all, so there's nothing for another process on the box to read.
Device code with --no-interaction — for agent-driven automation where a human still
exists to approve the sign-in (just not interactively, in this exact process). Running
acli auth:login --no-interaction with no stored credentials starts the device code flow and
prints the verification URL and code to stdout without prompting for anything; an existing
device session re-authenticates the same way. A human still has to approve in a browser, and the
command keeps polling until they do or the code expires after 10 minutes — run it so its output
streams to the agent (e.g. in the background), since the URL and code are needed while it's
still running. Many agent harnesses only show a command's output after it exits, and the
point of this flow is to relay the code during the wait, not after.
Secure credential management
# Option 1: AWS Secrets Manager
aws secretsmanager get-secret-value --secret-id acquia-cli-key
# Option 2: HashiCorp Vault
vault kv get secret/acquia/cli-key
# Option 3: GitHub Secrets (for Actions)
# Set ACQUIA_KEY and ACQUIA_SECRET as repository secrets
Best Practices
- Use
--no-interaction— Always pass this in scripts to prevent prompts from blocking the process. - Use
set -e— Exit immediately on any error so failures don't silently continue. - Store credentials securely — Use environment variables or secrets managers, never hardcode.
- Use
app:task-wait— After async operations, wait for completion before the next step.
Troubleshooting
Authentication fails in CI
For a service account with no human ever approving a login, export the key and secret —
these take priority over any stored credentials automatically, with no auth:login step and
no --no-interaction flag needed. If the key is stored as ACQUIA_KEY/ACQUIA_SECRET in
your CI platform, export it as ACLI_KEY/ACLI_SECRET for ACLI to read:
export ACLI_KEY="$ACQUIA_KEY"
export ACLI_SECRET="$ACQUIA_SECRET"
acli api:applications:list
If a human does approve sign-in (agent-driven automation, not a pure service account), use
acli auth:login --no-interaction instead — there's no separate environment variable for
suppressing prompts, only the --no-interaction/-n flag on the command itself.
Command hangs waiting for input
Always pass --no-interaction in scripts:
acli ide:create --application=abc123 --label="CI IDE" --no-interaction
Exit code not propagated correctly
Use set -e at the top of your script:
#!/bin/bash
set -e
acli auth:login --no-interaction
acli api:environments:code-switch $ENV_ID main
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/acquia/acquia-skills/scripting">View scripting on skillZs</a>