Skip to main content
Agent skill

Secrets Management

Implement secure secrets management for CI/CD pipelines using Vault, AWS Secrets Manager, or native platform solutions. Use when handling sensitive credentials, rotating secrets, or securing CI/CD environments.

Get started

Get the complete skill folder, including its scripts and reference files.

·

When to use this skill

Use Secrets Management when an AI agent needs a reusable SKILL.md workflow for this job: Implement secure secrets management for CI/CD pipelines using Vault, AWS Secrets Manager, or native platform solutions. Use when handling sensitive credentials, rotating secrets, or securing CI/CD environments.

When not to use it

Skip Secrets Management when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/secrets-management
# Save SKILL.md to ~/.claude/skills/secrets-management/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/secrets-management/SKILL.md. For a shared project, commit the folder at .claude/skills/secrets-management/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Secrets Management skill for this task: Store API keys and credentials. Confirm any required inputs or files before making changes.

What supports this recommendation?

90/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
100/100
Practical detail
100/100
Source evidence
63/100
Source signals
80/100
Model compatibility evidence
  • claudeuntested

    No model-specific signal or recorded compatibility test was found.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# Secrets Management

Secure secrets management practices for CI/CD pipelines using Vault, AWS Secrets Manager, and other tools.

## Purpose

Implement secure secrets management in CI/CD pipelines without hardcoding sensitive information.

## When to Use

- Store API keys and credentials - Manage database passwords - Handle TLS certificates - Rotate secrets automatically - Implement least-privilege access

## Secrets Management Tools

### HashiCorp Vault

- Centralized secrets management - Dynamic secrets generation - Secret rotation - Audit logging - Fine-grained access control

### AWS Secrets Manager

- AWS-native solution - Automatic rotation - Integration with RDS - CloudFormation support

### Azure Key Vault

- Azure-native solution - HSM-backed keys - Certificate management - RBAC integration

### Google Secret Manager

- GCP-native solution - Versioning - IAM integration

## HashiCorp Vault Integration

### Setup Vault

```bash # Start Vault dev server vault server -dev

# Set environment export VAULT_ADDR='http://127.0.0.1:8200' export VAULT_TOKEN='root'

# Enable secrets engine vault secrets enable -path=secret kv-v2

# Store secret vault kv put secret/database/config username=admin password=secret ```

### GitHub Actions with Vault

```yaml name: Deploy with Vault Secrets

on: [push]

jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4

- name: Import Secrets from Vault uses: hashicorp/vault-action@v2 with: url: https://vault.example.com:8200 token: ${{ secrets.VAULT_TOKEN }} secrets: | secret/data/database username | DB_USERNAME ; secret/data/database password | DB_PASSWORD ; secret/data/api key | API_KEY

- name: Use secrets run: | echo "Connecting to database as $DB_USERNAME" # Use $DB_PASSWORD, $API_KEY ```

### GitLab CI with Vault

```yaml deploy: image: vault:1.17 before_script: - export VAULT_ADDR=https://vault.example.com:8200 - export VAULT_TOKEN=$VAULT_TOKEN - apk add curl jq script: - | DB_PASSWORD=$(vault kv get -field=password secret/database/config) API_KEY=$(vault kv get -field=key secret/api/credentials) echo "Deploying with secrets..." # Use $DB_PASSWORD, $API_KEY ```

## AWS Secrets Manager

### Store Secret

```bash aws secretsmanager create-secret \ --name production/database/password \ --secret-string "super-secret-password" ```

### Retrieve in GitHub Actions

```yaml - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v4 with: aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} aws-region: us-west-2

- name: Get secret from AWS run: | SECRET=$(aws secretsmanager get-secret-value \ --secret-id production/database/password \ --query SecretString \ --output text) echo "::add-mask::$SECRET" echo "DB_PASSWORD=$SECRET" >> $GITHUB_ENV

- name: Use secret run: | # Use $DB_PASSWORD ./deploy.sh ```

### Terraform with AWS Secrets Manager

```hcl data "aws_secretsmanager_secret_version" "db_password" { secret_id = "production/database/password" }

resource "aws_db_instance" "main" { allocated_storage = 100 engine = "postgres" instance_class = "db.t3.large" username = "admin" password = jsondecode(data.aws_secretsmanager_secret_version.db_password.secret_string)["password"] } ```

## GitHub Secrets

### Organization/Repository Secrets

```yaml - name: Use GitHub secret env: API_KEY: ${{ secrets.API_KEY }} DATABASE_URL: ${{ secrets.DATABASE_URL }} run: | # Secrets are injected as env vars — never print them to logs ./deploy.sh ```

### Environment Secrets

```yaml deploy: runs-on: ubuntu-latest environment: production steps: - name: Deploy env: PROD_API_KEY: ${{ secrets.PROD_API_KEY }} run: | # Secret injected as env var — never print to logs ./deploy.sh ```

## GitLab CI/CD Variables

### Project Variables

```yaml deploy: script: # Fail if a variable is missing, but never print its value - test -n "$API_KEY" || { echo "API_KEY is not set"; exit 1; } - test -n "$DATABASE_URL" || { echo "DATABASE_URL is not set"; exit 1; } ```

### Protected and Masked Variables

- Protected: Only available in protected branches - Masked: Hidden in job logs - File type: Stored as file

## Best Practices

1. **Never commit secrets** to Git 2. **Use different secrets** per environment 3. **Rotate secrets regularly** 4. **Implement least-privilege access** 5. **Enable audit logging** 6. **Use secret scanning** (GitGuardian, TruffleHog) 7. **Mask secrets in logs** 8. **Encrypt secrets at rest** 9. **Use short-lived tokens** when possible 10. **Document secret requirements**

## Secret Rotation

### Automated Rotation with AWS

```python import boto3 import json

def lambda_handler(event, context): client = boto3.client('secretsmanager')

# Get current secret response = client.get_secret_value(SecretId='my-secret') current_secret = json.loads(response['SecretString'])

# Generate new password new_password = generate_strong_password()

# Update database password update_database_password(new_password)

# Update secret client.put_secret_value( SecretId='my-secret', SecretString=json.dumps({ 'username': current_secret['username'], 'password': new_password }) )

return {'statusCode': 200} ```

### Manual Rotation Process

1. Generate new secret 2. Update secret in secret store 3. Update applications to use new secret 4. Verify functionality 5. Revoke old secret

## External Secrets Operator

### Kubernetes Integration

```yaml apiVersion: external-secrets.io/v1beta1 kind: SecretStore metadata: name: vault-backend namespace: production spec: provider: vault: server: "https://vault.example.com:8200" path: "secret" version: "v2" auth: kubernetes: mountPath: "kubernetes" role: "production"

--- apiVersion: external-secrets.io/v1beta1 kind: ExternalSecret metadata: name: database-credentials namespace: production spec: refreshInterval: 1h secretStoreRef: name: vault-backend kind: SecretStore target: name: database-credentials creationPolicy: Owner data: - secretKey: username remoteRef: key: database/config property: username - secretKey: password remoteRef: key: database/config property: password ```

## Secret Scanning

### Pre-commit Hook

```bash #!/bin/bash # .git/hooks/pre-commit

# Check for secrets with TruffleHog docker run --rm -v "$(pwd):/repo" \ trufflesecurity/trufflehog:3.88 \ filesystem --directory=/repo

if [ $? -ne 0 ]; then echo "❌ Secret detected! Commit blocked." exit 1 fi ```

### CI/CD Secret Scanning

```yaml secret-scan: stage: security image: trufflesecurity/trufflehog:3.88 script: - trufflehog filesystem . allow_failure: false ```

## Related Skills

- `github-actions-templates` - For GitHub Actions integration - `gitlab-ci-patterns` - For GitLab CI integration - `deployment-pipeline-design` - For pipeline architecture

Intended uses

  • Store API keys and credentials
  • Manage database passwords
  • Handle TLS certificates
  • Rotate secrets automatically
  • Implement least-privilege access

Implementation notes

  • Never commit secrets to Git
  • Use different secrets per environment
  • Rotate secrets regularly
  • Implement least-privilege access
  • Enable audit logging
  • Use secret scanning (GitGuardian, TruffleHog)
  • Mask secrets in logs
  • Encrypt secrets at rest
  • Use short-lived tokens when possible
  • Document secret requirements

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.