Phase Console

Phase is an open-source platform designed for engineering teams to secure and deploy application secrets from development to production. It provides a centralized dashboard (Phase Console) for managing secrets and environment variables, a CLI for local development and secret injection, and various integrations for automated secret syncing.

Key capabilities include:

• Secret Management: Manage secrets across environments, track version history, and view diffs.
• Role-Based Access Control (RBAC): Fine-grained, cryptographic access control per application and environment.
• Secret Syncing: Automatically sync secrets to platforms like GitHub, Vercel, AWS Secrets Manager, and Kubernetes via the Phase Secrets Operator.
• Programmatic Access: Manage secrets via a REST API or language-specific SDKs (Node.js, Python, Golang).

Phase follows an open-core model.

• Community Edition: The core repository is available under the MIT Expat license.
• Enterprise/Pro Edition: Features located in the ee directory are proprietary and require a Phase license to use.

If the backend GraphQL schema (schema.graphql) has been upgraded, you must regenerate the frontend GraphQL types and hooks to maintain compatibility. Navigate to the frontend directory and run the codegen command.

cd frontend && yarn codegen

The backend uses Graphene to provide a GraphQL API. To keep the frontend in sync, you must generate the GraphQL schema file.

If running locally via Django management commands:

./manage.py graphql_schema --schema backend.schema.schema --out ../frontend/apollo/schema.graphql

If running within a development Docker environment:

docker compose -f dev-docker-compose.yml exec backend python manage.py graphql_schema --schema backend.schema.schema --out schema.graphql

After generation, ensure the schema is overwritten in /frontend/apollo/schema.graphql. Note that you must also generate TypeScript types separately by following the instructions in frontend/README.md.

To begin using Phase, you can choose between the managed Phase Cloud service or self-hosting the platform on your own infrastructure.

Use Phase Cloud

The fastest way to get started is to sign up via the Phase Console.

Self-host Phase

You can deploy the Phase Console on your own infrastructure using several supported methods:

• Docker Compose
• Kubernetes (via Helm chart)
• AWS
• AWS EKS (via Helm chart)
• Google Cloud Platform (GCP)
• Azure
• DigitalOcean

For detailed deployment instructions, refer to the Self-hosting Phase documentation.

To start the Phase Console frontend in development mode, use your preferred package manager to run the dev script. The application will be available at http://localhost:3000.

npm run dev
# or
yarn dev
# or
pnpm dev

For technical details on how Phase handles encryption, consult the Security Docs.

Important: Do not report security vulnerabilities via GitHub issues or public forums. Please follow the instructions in SECURITY.md to report vulnerabilities privately.

Phase provides official SDKs to integrate its capabilities into your applications. Currently supported languages include:

• Golang: Golang SDK Documentation
• Node.js: @phasehq/node-sdk
• Python: @phasehq/python-sdk

To mock UI screens and workflows, you can generate fake users and assign them to an organization using the create_dummy_users management command.

Prerequisites

1. Install development dependencies in your virtual environment:

   pip install -r dev-requirements.txt

2. Perform a manual signup and create an organization via the application.

Execution Steps

If using Docker, first find your backend container ID using docker ps, then shell into it:

docker exec -it <container_id> /bin/sh

Run the command to create users. It is recommended to use the --domain flag to make these users easily identifiable for future cleanup.

python manage.py create_dummy_users --count 10 --org "OrgName" --domain "example.com"

Phase can be self-hosted using the provided docker-compose.yml configuration. The setup orchestrates several services including an Nginx reverse proxy, a Next.js frontend, a Python backend, a migration runner, a background worker, PostgreSQL, and Redis.

To configure the environment, you must provide a .env file containing the following variables used by the services:

# Example .env requirements based on docker-compose.yml
HTTP_PROTOCOL=http
HOST=localhost
DATABASE_NAME=phase
DATABASE_USER=phase
DATABASE_PASSWORD=password

The create_dummy_users command is used to populate the backend with fake user data for development and testing purposes.

python manage.py create_dummy_users \
  --count <number> \
  --org <organization_name> \
  --domain <email_domain>