DEV Community

Cover image for Introducing PHP Env Manager: Simplify Environment Management in PHP Applications
Nasrul Hazim Bin Mohamad
Nasrul Hazim Bin Mohamad

Posted on

Introducing PHP Env Manager: Simplify Environment Management in PHP Applications

#php #laravel #symfony #codeigniter

Managing environment variables is crucial for configuring applications across different environments, from development to production. Today, we’re excited to introduce cleaniquecoders/php-env-key-manager, a new PHP package that makes managing environment variables easier and more flexible.

php-env-key-manager allows you to set, enable, or disable environment keys directly in your .env file across any PHP application. Whether you’re working in Laravel, Symfony, CodeIgniter, or a custom PHP project, this package provides a straightforward way to manage configuration.

Why php-env-key-manager?

The .env file holds sensitive information and configurations specific to your environment, such as database credentials, API keys, and debug settings. However, adding, updating, or toggling keys manually can be tedious and error-prone, especially in large projects. php-env-key-manager simplifies this by providing a set of easy-to-use methods that automate these tasks.

Key Features

  • Set Key-Value Pairs: Easily add or update environment variables with setKey.
  • Enable Keys: Uncomment environment keys with enableKey.
  • Disable Keys: Comment out environment keys with disableKey.
  • Framework-Agnostic: Use this package in any PHP project.
  • Framework Integrations: Get dedicated usage examples for Laravel, Symfony, and CodeIgniter.

Installation

Install the package via Composer:

composer require cleaniquecoders/php-env-key-manager
Enter fullscreen mode Exit fullscreen mode

Basic Usage

Using php-env-key-manager is straightforward. Here’s how you can set, disable, and enable keys in your .env file.

use CleaniqueCoders\PhpEnvKeyManager\EnvKeyManager;

// Path to your .env file
$envFilePath = __DIR__ . '/.env';
$envManager = new EnvKeyManager($envFilePath);

// Set a key
$envManager->setKey('APP_DEBUG', 'true');

// Disable a key
$envManager->disableKey('APP_DEBUG');

// Enable a key
$envManager->enableKey('APP_DEBUG');
Enter fullscreen mode Exit fullscreen mode

With these methods, you can quickly update environment configurations without manually editing the .env file.

Framework-Specific Usage

Here’s how you can integrate php-env-key-manager in popular PHP frameworks.

Laravel Integration

In Laravel, you can register EnvKeyManager as a singleton in the AppServiceProvider to make it available throughout your application.

  1. Register as a Singleton

In App\Providers\AppServiceProvider:

   use CleaniqueCoders\PhpEnvKeyManager\EnvKeyManager;

   public function register()
   {
       $this->app->singleton(EnvKeyManager::class, function ($app) {
           return new EnvKeyManager($app->environmentFilePath());
       });
   }
Enter fullscreen mode Exit fullscreen mode
  1. Use in an Artisan Command

Create a Laravel Artisan command to set, disable, or enable environment keys:

   <?php

   namespace App\Console\Commands;

   use CleaniqueCoders\PhpEnvKeyManager\EnvKeyManager;
   use Illuminate\Console\Command;

   class ManageEnvKeyCommand extends Command
   {
       protected $signature = 'env:manage-key {action} {key} {value?}';
       protected $description = 'Manage an environment key';

       protected $envManager;

       public function __construct(EnvKeyManager $envManager)
       {
           parent::__construct();
           $this->envManager = $envManager;
       }

       public function handle()
       {
           $action = $this->argument('action');
           $key = $this->argument('key');
           $value = $this->argument('value');

           switch ($action) {
               case 'set':
                   $this->envManager->setKey($key, $value);
                   $this->info("Key {$key} set to {$value}.");
                   break;

               case 'disable':
                   $this->envManager->disableKey($key);
                   $this->info("Key {$key} has been disabled.");
                   break;

               case 'enable':
                   $this->envManager->enableKey($key);
                   $this->info("Key {$key} has been enabled.");
                   break;

               default:
                   $this->error("Invalid action. Use 'set', 'disable', or 'enable'.");
           }
       }
   }
Enter fullscreen mode Exit fullscreen mode

Symfony Integration

To use EnvKeyManager in Symfony, initialize it with the .env path and use it in Symfony commands or services.

  1. Initialize EnvKeyManager with Symfony’s .env path. 
   use CleaniqueCoders\PhpEnvKeyManager\EnvKeyManager;

   $envFilePath = __DIR__ . '/../../.env';
   $envManager = new EnvKeyManager($envFilePath);
Enter fullscreen mode Exit fullscreen mode
  1. Create a Symfony Command 
   <?php

   namespace App\Command;

   use CleaniqueCoders\PhpEnvKeyManager\EnvKeyManager;
   use Symfony\Component\Console\Command\Command;
   use Symfony\Component\Console\Input\InputArgument;
   use Symfony\Component\Console\Input\InputInterface;
   use Symfony\Component\Console\Output\OutputInterface;

   class ManageEnvKeyCommand extends Command
   {
       protected static $defaultName = 'env:manage-key';
       private $envManager;

       public function __construct(EnvKeyManager $envManager)
       {
           parent::__construct();
           $this->envManager = $envManager;
       }

       protected function configure()
       {
           $this
               ->setDescription('Manage an environment key')
               ->addArgument('action', InputArgument::REQUIRED, 'Action: set, disable, enable')
               ->addArgument('key', InputArgument::REQUIRED, 'The environment key')
               ->addArgument('value', InputArgument::OPTIONAL, 'The value for set action');
       }

       protected function execute(InputInterface $input, OutputInterface $output)
       {
           $action = $input->getArgument('action');
           $key = $input->getArgument('key');
           $value = $input->getArgument('value');

           switch ($action) {
               case 'set':
                   $this->envManager->setKey($key, $value);
                   $output->writeln("Key {$key} set to {$value}.");
                   break;

               case 'disable':
                   $this->envManager->disableKey($key);
                   $output->writeln("Key {$key} has been disabled.");
                   break;

               case 'enable':
                   $this->envManager->enableKey($key);
                   $output->writeln("Key {$key} has been enabled.");
                   break;

               default:
                   $output->writeln("Invalid action. Use 'set', 'disable', or 'enable'.");
                   return Command::FAILURE;
           }

           return Command::SUCCESS;
       }
   }
Enter fullscreen mode Exit fullscreen mode

CodeIgniter Integration

In CodeIgniter, you can initialize EnvKeyManager with the .env path and use it within controllers.

  1. Initialize EnvKeyManager in your controller. 
   use CleaniqueCoders\PhpEnvKeyManager\EnvKeyManager;

   $envFilePath = ROOTPATH . '.env';
   $envManager = new EnvKeyManager($envFilePath);
Enter fullscreen mode Exit fullscreen mode
  1. Controller Method for Managing Environment Keys 
   <?php

   namespace App\Controllers;

   use CleaniqueCoders\PhpEnvKeyManager\EnvKeyManager;

   class EnvController extends BaseController
   {
       protected $envManager;

       public function __construct()
       {
           $this->envManager = new EnvKeyManager(ROOTPATH . '.env');
       }

       public function manageKey($action, $key, $value = null)
       {
           switch ($action) {
               case 'set':
                   $this->envManager->setKey($key, $value);
                   return "Key {$key} set to {$value}.";

               case 'disable':
                   $this->envManager->disableKey($key);
                   return "Key {$key} has been disabled.";

               case 'enable':
                   $this->envManager->enableKey($key);
                   return "Key {$key} has been enabled.";

               default:
                   return "Invalid action. Use 'set', 'disable', or 'enable'.";
           }
       }
   }
Enter fullscreen mode Exit fullscreen mode

For more details, visit the GitHub repository: cleaniquecoders/php-env-key-manager.

This package simplifies environment management, allowing you to quickly toggle, add, or remove settings without directly editing .env files. We hope it brings ease to your development workflow. Give it a try and let us know your feedback!

Photo by Luke Chesser on Unsplash

Top comments (4)

Collapse
 
moopet profile image
Ben Sinclair •

Interesting. Can you give me an example of when you'd want to set something in a .env file from within the application it informs? You have one example of APP_DEBUG but that, or other things like API keys or similar seem more suited to being stored in the application's general database.

Collapse
 
nasrulhazim profile image
Nasrul Hazim Bin Mohamad •

Thank you for your question!

While storing configuration values in a database can be beneficial for settings that need to be dynamically updated, there are some cases where keeping certain environment-specific values in the .env file is preferred, especially for things that impact the application’s behavior at runtime without requiring database interactions.

A few examples include:

  1. Feature Flags for Environment-specific Testing: For example, if you want to enable experimental features only in specific environments (like staging), you can add feature flags in the .env file, which keeps these flags separate from any user-driven data or settings in the database.

  2. Service Connection Details: Often, external services (like Redis, Memcached, or even some third-party API services) might have connection strings or tokens that need to be consistent at deployment and don’t need to change while the app is running. Keeping these in the .env file helps keep sensitive data out of code and configuration files.

  3. Application State Overrides for Emergency Scenarios: Occasionally, you might need to toggle specific behaviors due to an unexpected event (like setting the app to maintenance mode). This can be easily done by changing a value in the .env file rather than relying on database persistence, especially if you’re experiencing issues accessing the database.

Overall, .env files can be ideal for environment-specific settings that the application relies on directly, while database-stored configuration works well for values that might change dynamically or based on user interaction.

Collapse
 
arif98741 profile image
Ariful Islam •

nice article

Collapse
 
nasrulhazim profile image
Nasrul Hazim Bin Mohamad •

thank you!

Read next

navneet_verma profile image

The Hidden Benefits of Modular PHP: How to Build Scalable Applications Like a Pro.

Navneet Verma -

anticoder03 profile image

📂 Building a Simple File Management System with PHP & MySQL 🚀

Ashish prajapati -

thesaltree profile image

Why Golang’s Concurrency conquers over PHP

Saloni Agarwal -

neotechy profile image

Top 10 CodeIgniter Plugins and Libraries to Enhance Your Project

NeoTechy -