Study guide
11.4 Conjur Secrets Manager & Cloud-Native DevOps Workflows
CyberArk Defender - PAM PAM-DEF
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Vault Architecture, Network & Security
1.1 CyberArk PAS Core Architecture & Component Topology 1.2 Vault OS Hardening, Network Isolation & Port Requirements 1.3 Vault Cryptography, Encryption Keys & Master User Recovery
2 Chapter 2: Vault Configuration, Administration & CLI Utilities
2.1 Vault Server Configuration Files & DBParm.ini Tuning 2.2 Vault Administrative Utilities & PARClient Commands 2.3 Event Notification Engine (ENE) & Notification Administration
3 Chapter 3: Password Vault Web Access (PVWA) Administration
3.1 PVWA Web Portal Architecture & Interface Configuration 3.2 PVWA REST API Administration & Lifecycle Automation 3.3 PVWA Security Settings, User Access & Session Timeouts
4 Chapter 4: Central Policy Manager (CPM) Architecture & Operations
4.1 CPM Service Architecture, Logs & Multi-CPM Load Distribution 4.2 The Credential Management State Machine: Change, Verify & Reconcile 4.3 CPM Plug-in Architecture, Process/Prompts Files & Custom Plug-in Troubleshooting 4.4 Loosely Connected Devices: Rotating Laptop & Workstation Credentials
5 Chapter 5: Safe Design, RBAC & Account Governance
5.1 Enterprise Safe Architecture & Naming Conventions 5.2 Safe Permissions, Authorizations & Safe Handler Delegation 5.3 Object Versioning, Retention Policies & Storage Quotas 5.4 Mandatory Account Properties, Account Types & Linked Accounts 5.5 Vault Users, Predefined Groups & Vault-Level Authorizations
6 Chapter 6: Account Discovery & Lifecycle Workflows
6.1 Automated Account Discovery, Detection Rules & Pending Accounts 6.2 Dual Control Workflows, Multi-Level Approvals & Master Approver 6.3 Exclusive Access, One-Time Passwords (OTP) & Check-out Automation 6.4 Bulk Onboarding: Password Upload Utility, Bulk Upload REST API & AccountUploader
7 Chapter 7: Master Policy & Platform Management
7.1 Master Policy Framework & Enterprise Compliance Rules 7.2 Platform Architecture, Settings Tree & Platform Duplication 7.3 Platform Policy Overrides, Advanced Settings & Target Tuning
8 Chapter 8: Privileged Session Manager (PSM) Core Architecture
8.1 PSM Architecture, Jump Host Isolation & Service Accounts 8.2 PSM Connection Components (PSM-RDP, PSM-SSH, PSM-Web) 8.3 PSM Universal Connector Framework & Custom Integrations 8.4 Split Workflow: Separating Session Use from Credential Retrieval
9 Chapter 9: PSMP, HTML5 Gateway & Session Security
9.1 PSM for SSH (PSMP) Architecture & Unix Proxy Brokering 9.2 PSM HTML5 Gateway Architecture & Clientless Web Access 9.3 Session Recording, Storage in Recordings Safes & Vault Retention 9.4 CyberArk Remote Access (Vendor PAM): Administering Third-Party Privileged Access
10 Chapter 10: Live Session Auditing, Reporting & Privileged Threat Analytics
10.1 Live Session Monitoring, Shadowing & Active Termination 10.2 Privileged Threat Analytics (PTA) Behavioral Anomaly Detection 10.3 PTA Automated Incident Response & SIEM Integration (CEF/Syslog) 10.4 Vault Reports, Report Authorizations & the Export Vault Data (EVD) Utility
11 Chapter 11: Application Access Manager (AAM) & Secrets Management
11.1 AAM Credential Provider (CP) Architecture & Local Memory Cache 11.2 Central Credential Provider (CCP) & Web Service Integration 11.3 Application Server Credential Provider (ASCP) & Application Authentication (AppID) 11.4 Conjur Secrets Manager & Cloud-Native DevOps Workflows
12 Chapter 12: Directory Integration, Disaster Recovery & Troubleshooting
12.1 Directory Integration: LDAP Mapping, RADIUS MFA & SAML 2.0 SSO 12.2 Disaster Recovery (DR) Vault & PADR Replication Architecture 12.3 Vault Backup Operations with PAReplicate & Safe Recovery 12.4 Diagnostic Procedures, Vault/CPM/PSM Error Codes & System Recovery
11.4 Conjur Secrets Manager & Cloud-Native DevOps Workflows
Key Takeaways Explain This Topic AI
Conjur Secrets Manager (CyberArk Secrets Manager) provides high-scale, dynamic secrets management tailored for cloud-native microservices, container orchestrators (Kubernetes, OpenShift), and CI/CD pipelines.
The Conjur Kubernetes Authenticator (authn-k8s) solves the 'Secret Zero' dilemma by verifying native Kubernetes Service Account JWT tokens against the Kubernetes API without storing static secrets.
The Kubernetes Secretless Broker pattern abstracts secrets entirely from applications by intercepting connection streams locally and dynamically injecting credentials on the fly.
Security policies, non-human roles, and variable permissions in Conjur are declared as Policy-as-Code in human-readable YAML files, enabling version control and GitOps workflows.
The Vault-Conjur Synchronizer automatically replicates selected enterprise privileged accounts from Digital Vault Safes into Conjur branches, unifying PAM governance with DevOps velocity.
Last updated: September 2026
11.4 Conjur Secrets Manager & Cloud-Native DevOps Workflows
Quick Answer: Conjur Secrets Manager (CyberArk Secrets Manager) is an enterprise secrets management solution purpose-built for DevOps pipelines, microservices, and container platforms (Kubernetes, OpenShift) . It resolves the 'Secret Zero' challenge in containers through native Kubernetes Authentication ( authn-k8s ) , which cryptographically validates Kubernetes Service Account tokens without pre-shared secrets. Conjur policies are managed as Policy-as-Code (YAML) in GitOps workflows. To unify enterprise PAM with DevOps velocity, the Vault-Conjur Synchronizer automatically replicates selected privileged accounts from Digital Vault Safes to Conjur branches in real time.
Conjur Secrets Manager in Cloud-Native & DevOps Ecosystems
Traditional Privileged Access Management (PAM) architectures were designed around static enterprise infrastructure: bare-metal servers, domain controllers, and human administrators. Modern cloud-native environments present fundamentally different operational dynamics:
Ephemeral Workloads: Containers and microservices scale dynamically and terminate within minutes or seconds.
High-Velocity Scale: Distributed applications execute tens of thousands of automated transactions per second, requiring lightweight, low-latency secret retrieval.
Infrastructure as Code (IaC): Environments are continuously provisioned using Terraform and Ansible, which require programmatic access to cloud API keys and certificates.
CI/CD Pipelines: Automated workflows (Jenkins, GitLab CI, GitHub Actions) require temporary credentials to build and deploy applications.
Conjur Secrets Manager provides an API-first platform securing non-human identities across multi-cloud and container environments while enforcing role-based access control (RBAC).
High-Availability Conjur Topology
Conjur Leader (Master): The primary node handling policy evaluation, database writes, variable creation, and audit logging, paired with Standby nodes for automated failover.
Conjur Followers: Horizontally scalable, read-only replicas deployed close to workloads (inside Kubernetes clusters or cloud VPCs). Followers handle client authentication and secret retrieval locally, offloading the Leader and providing localized sub-millisecond response times.
Native Kubernetes Workload Authentication ( authn-k8s )
Securing container machine identities introduces the "Secret Zero" dilemma: for an ephemeral pod to authenticate to a vault, it historically required an initial bootstrap secret (API key or certificate) embedded in the image or ConfigMap, creating a security risk.
Conjur resolves Secret Zero through the Conjur Kubernetes Authenticator ( authn-k8s ) , leveraging native platform identity primitives:
Pod Startup: When Kubernetes launches an application pod, it mounts a cryptographically signed Service Account Token (JWT) into the pod at /var/run/secrets/kubernetes.io/serviceaccount/token .
Authentication Request: The pod transmits an authentication request containing its Service Account JWT to the in-cluster Conjur Follower.
Cryptographic Validation: The Follower contacts the Kubernetes API server using the TokenReview API, which verifies the token signature and returns authenticated attributes (namespace, service account, pod name).
Policy Evaluation: Conjur validates pod metadata against declared policy and issues a short-lived, ephemeral access token (valid for 8 minutes).
Secret Retrieval: The pod uses this token to retrieve secrets over HTTPS from the local Follower.
Because authentication relies on native Kubernetes service account attestation, zero static secrets reside in container images or filesystems.
Secrets Consumption Patterns: Sidecar Injector vs. Secretless Broker
CyberArk provides two architectural patterns for consuming Conjur secrets in Kubernetes:
1. Sidecar Injector / Secrets Provider for Kubernetes
The CyberArk Secrets Provider for Kubernetes runs as an init container or sidecar inside the application pod:
It authenticates via authn-k8s , fetches required secrets from Conjur, and writes them to an in-memory shared volume ( emptyDir with medium: Memory ).
The application mounts the volume and reads secrets as files, or the provider synchronizes secrets directly into native Kubernetes Secret objects.
Use Case: Applications expecting credentials in configuration files or environment variables.
2. Kubernetes Secretless Broker Pattern
The Secretless Broker is an advanced zero-trust pattern that completely abstracts secrets from application code:
The Secretless Broker runs as a sidecar container alongside the application.
The application connects to localhost on the database port (e.g., localhost:5432 for PostgreSQL) with no password provided .
The Secretless Broker intercepts the connection locally, authenticates to Conjur, retrieves database credentials, injects them directly into the native protocol handshake (PostgreSQL, MySQL, MSSQL, HTTP), and proxies the connection to the remote database.
Security Advantage: Application code and memory never see, hold, or touch the secret , eliminating exposure in crash dumps, logs, or application vulnerabilities.
Policy as Code & Declarative Security Governance
Conjur manages security policies, host identities, variable paths, and access permissions using Policy as Code written in declarative YAML files: - !policy
id: production/billing
body:
- !variable db-password
- !layer webapp-tier
- !host
- id: k8s-billing-app
annotations:
- authn-k8s/namespace: production
- authn-k8s/service-account: billing-sa
- !grant
- role: !layer webapp-tier
- member: !host k8s-billing-app
- !permit
- role: !layer webapp-tier
- privileges: [read, execute]
- resource: !variable db-password
- GitOps Integration
Policies are stored in Git repositories, code-reviewed, and deployed via CI/CD pipelines using the Conjur CLI ( conjur policy load -b root -f policy.yml ). This ensures complete auditability and repeatable provisioning.
Vault-Conjur Synchronizer: Unifying PAM & DevOps
The CyberArk Vault-Conjur Synchronizer bridges enterprise PAM governance and cloud-native DevOps:
PAM Governance: Privileged accounts are managed and rotated by the Central Policy Manager (CPM) in the Digital Vault.
DevOps Velocity: Cloud-native microservices consume secrets dynamically from Conjur.
How Synchronization Operates
Safe Selection: Administrators assign the Synchronizer identity ( ConjurSync ) to designated Safes.
Variable Mapping: The Synchronizer queries the Vault over TCP 1858 and maps accounts into Conjur variable trees: vault/<SafeName>/<ObjectName>/password .
Real-Time Replication: When CPM rotates an account in the Vault, the Synchronizer pushes the updated secret to the Conjur Leader over HTTPS port 443, which replicates it to all Followers within seconds.
Unified Value: Central security teams retain full compliance in the Vault while microservices consume up-to-date credentials from Conjur.
Conjur Secrets Manager vs. AAM Credential Provider (CP/CCP)
Architectural Feature Conjur Secrets Manager AAM Credential Provider (CP) AAM Central Credential Provider (CCP)
Primary Workloads Cloud-native microservices, K8s, CI/CD, IaC Enterprise monoliths, DB servers, batch jobs Serverless functions (Lambda), appliances, PaaS
Workload Identity Native K8s ( authn-k8s ), IAM, SPIFFE OS User, Executable Path, SHA-256 Hash Client Certificate (mTLS), IP Address, Domain
Kubernetes Integration Secretless Broker, Secrets Provider Sidecar Not optimized for container clusters Inbound REST API over HTTPS
Policy Management Policy as Code (Declarative YAML) PVWA UI / Master Policy PVWA UI / Master Policy
Architecture Model Distributed Leader / Follower clustering Local agent installed on every application host Centralized REST web service on IIS nodes
Vault Synchronization Vault-Conjur Synchronizer (Automated bridge) Direct connection to Vault over TCP 1858 Direct connection to Vault over TCP 1858