Il existe trois fa?ons principales de définir des variables d'environnement dans PHP: 1. Configuration globale via Php.ini; 2. Passé via un serveur Web (tel que setenv d'Apache ou Fastcgi_param de Nginx); 3. Utilisez la fonction PUTENV () dans les scripts PHP. Parmi eux, PHP.ini convient aux configurations globales et modifiées, la configuration du serveur Web convient aux scénarios qui doivent être isolés et PUTENV () convient aux variables temporaires. Les stratégies de persistance incluent des fichiers de configuration (tels que PHP.ini ou la configuration du serveur Web), les fichiers .env sont chargés de bibliothèque Dotenv et l'injection dynamique de variables dans les processus CI / CD. Les informations sensibles à la gestion de la sécurité doivent être évitées. Il est recommandé d'utiliser des fichiers .env avec .gitignore, Docker Secrets ou des services cloud tels que AWS Secrets Manager. Si la variable d'environnement ne prend pas effet, vous devez vérifier le mode de fonctionnement PHP, confirmer la portée de la variable, vérifier le chemin du fichier de configuration et redémarrer le service.

Il existe généralement plusieurs fa?ons de définition de définir des variables d'environnement dans un environnement PHP: configurer à l'échelle mondiale le fichier de configuration php.ini , le passer en utilisant la configuration d'un serveur Web (tel qu'Apache ou Nginx), ou utiliser la fonction putenv() directement dans un script PHP. La méthode que vous choisissez dépend souvent de votre mode de fonctionnement PHP, des exigences d'isolement de votre environnement et du cycle de vie des variables.

Solution

Pour être honnête, les variables de l'environnement PHP semblent un peu mystérieuses, mais elles sont en fait assez simples à utiliser. Je pense personnellement que le moyen le plus courant et le plus s?r n'est rien de plus que quelques-uns, chacun avec ses propres scénarios applicables, et aucun d'entre eux n'est une "solution universelle".

Tout d'abord, la chose la plus directe est de changer php.ini . Vous pouvez utiliser directement variables_order ou E dans le fichier pour contr?ler les variables qui peuvent être accessibles par PHP. Cependant, les configurations les plus couramment utilisées sont des configurations comme upload_max_filesize . Ce sont des éléments de configuration PHP et ne sont pas tout à fait les mêmes que les variables d'environnement au niveau du système d'exploitation. Mais si vous voulez qu'une certaine variable d'environnement prenne effet globalement, telles que les informations de connexion de la base de données, ou la clé d'API, c'est un moyen d'utiliser env[VAR_NAME] = value dans php.ini . Mais il y a un problème avec cela, c'est-à-dire que si vous modifiez php.ini , vous devez redémarrer PHP-FPM ou serveur Web, et cela affectera toutes les applications exécutées dans cet environnement PHP et ne sont pas assez flexibles.

Ensuite, c'est via le serveur Web. Si vous utilisez Apache, la directive SetEnv se trouve dans le fichier .htaccess ou le fichier de configuration Apache, c'est simplement un outil magique. Par exemple:

 <Ifmodule mod_env.c>
    Setenv app_env "production"
    Setenv database_url "mysql: // utilisateur: pass @ host / db"
</fmodule>

Cette chose est bonne, elle peut être efficace pour des répertoires spécifiques ou des h?tes virtuels, et l'isolement est bien fait. Pour Nginx, vous devez utiliser fastcgi_param , généralement dans le fichier fastcgi_params ou votre bloc de serveur:

 fastcgi_param app_env "développement";
fastcgi_param database_url "mysql: // utilisateur: pass @ localhost / dev_db";

Les deux méthodes sont considérées comme injecter des variables d'environnement de la couche de serveur Web dans le processus PHP. Les scripts PHP peuvent être obtenus via $_SERVER ou getenv() . Je préfère personnellement cette méthode car elle sépare la configuration et le code, et il facilite également l'injection de configurations d'environnement différentes dans le processus CI / CD.

Enfin, bien s?r, putenv() à l'intérieur du script PHP. Cette fonction vous permet de définir une variable d'environnement au moment de l'exécution.

 <? Php
pUtenv ("my_custom_var = hello_world");
echo getenv ("my_custom_var"); // sortie: hello_world
?>

Mais pour être honnête, je l'utilise rarement pour définir des variables d'environnement critiques qui doivent être disponibles tout au long du cycle de vie de la demande. Il est plus utilisé dans certains scénarios temporaires qui ne sont utilisés que par le script actuel ou le processus enfant. étant donné que les variables qu'il définit ne sont valables que pour le processus PHP actuel, ils sont partis une fois la demande terminée et ne peuvent pas affecter le processus parent.

Pour résumer, celui à choisir dépend de vos besoins. Configuration globale et invariante, php.ini ou serveur Web; S'il doit être isolé, la configuration du serveur Web est meilleure; S'il est temporaire, utilisé en interne par les scripts, putenv() .

Quelles sont les stratégies de persistance pour les variables d'environnement PHP?

En ce qui concerne la persévérance, ce n'est pas une question simple, car le mot ?persistant? a des interprétations différentes dans différents contextes. Ce que je comprends la persistance, c'est de permettre aux variables d'environnement de maintenir leur valeur en dehors du cycle de vie du processus PHP, ou du moins de chargement automatiquement chaque fois qu'une nouvelle demande arrive.

La persistance la plus directe est bien s?r d'écrire des variables dans le fichier de configuration. Par exemple, php.ini mentionné tout à l'heure ou le fichier de configuration du serveur Web ( httpd.conf d'Apache ou nginx.conf de Nginx). Une fois ces fichiers configurés, ces variables existeront toujours tant que le serveur ne redémarre pas, ou le processus PHP-FPM n'est pas tué. C'est la persistance la plus "hardcore". Cependant, les inconvénients sont également évidents. Les modifications nécessitent un redémarrage du service et ils ne sont pas suffisamment flexibles pour être adaptés au déploiement multi-environnement.

Une autre méthode courante de "persistance" est en fait une manifestation philosophique de "la convention est supérieure à la configuration", c'est-à-dire des fichiers .env . Bien que PHP lui-même ne reconna?t pas directement les fichiers .env , via des bibliothèques comme vlucas/phpdotenv , vous pouvez charger ces fichiers au début de l'application.

 // Composer.json
// "exiger": {
// "Vlucas / phpdotenv": "^ 5.0"
//}

// public / index.php ou bootstrap fichier $ dotenv = dotenv \ dotenv :: createMutable (__ dir__. '/../'); // pointez vers le répertoire racine de votre projet $ dotenv-> chargée ();

// Après cela, vous pouvez accéder à ces variables via GETENV () ou $ _ENV $ dbhost = getenv ('db_host');

Les avantages de cette méthode sont:

1. Isolement de l'environnement: Différents environnements (développement, tests, production) peuvent avoir différents fichiers .env ou utiliser des variables d'environnement pour spécifier ce .env à charger.
2. Sécurité: les fichiers .env ne sont généralement pas soumis au système de contr?le de version (GIT), évitant ainsi la fuite d'informations sensibles.
3. Flexibilité: remplacer uniquement le fichier .env pendant le déploiement peut changer de configuration sans modifier le code ni redémarrer le service (pour le mode PHP-FPM).

Personnellement, je ne peux pas me .env de projets, en particulier des cadres PHP modernes (comme Laravel et Symfony). Il découple très bien la configuration et le code de l'application et se conforme aux principes de configuration de l'application de douze facteurs.

Il existe un autre type, mais pas entièrement "persistant", mais il est très essentiel pour le processus de déploiement, c'est-à-dire l'injection variable de l'environnement dans les systèmes CI / CD. Par exemple, dans les actions GitHub, GitLab CI ou Jenkins, vous pouvez injecter des informations sensibles en tant que variables d'environnement en conteneurs ou cibles de déploiement pendant l'étape de construction ou de déploiement. Ces variables sont injectées au moment de l'exécution et ne sont pas stockées dans la bibliothèque de code, ce qui est extrêmement s?r.

Par conséquent, le choix d'une stratégie de persistance dépend finalement de vos besoins de sécurité, de vos processus de déploiement et de vos habitudes de collaboration d'équipe. Il n'y a pas de solution argentée, seulement la solution qui vous convient le plus.

Dans le développement de PHP, comment gérer en toute sécurité et efficacement les informations de configuration sensibles?

La gestion des informations de configuration sensible est une grande fosse dans n'importe quel développement, et PHP ne fait pas exception. J'ai vu trop de projets qui écrivent directement des mots de passe de base de données et des clés d'API dans le code, qui est simplement un cauchemar de sécurité. Pour gérer ces choses en toute sécurité et efficacement, mon expérience est que le principe de base est "n'exposez pas les informations sensibles directement à la base de code".

La chose la plus élémentaire, comme je l'ai mentionné plus t?t, est d'utiliser des fichiers .env pour coopérer avec .gitignore . C'est la pratique la plus simple et la plus courante. Votre configuration config.php ou Framework Logic de chargement lira ces variables au lieu de coder directement les valeurs.

 # .env Fichier Exemple App_Key = SomerandomStringGeneratedByFramework
Db_connection = mysql
Db_host = 127.0.0.1
Db_port = 3306
Db_database = my_app
Db_username = root
Db_password = secret

Ensuite, n'oubliez pas d'ajouter .env à .gitignore :

 # .gitignore
.env

De cette fa?on, vos informations sensibles ne seront pas poussées au référentiel public avec le code. Bien s?r, cela vous oblige à créer ou à copier manuellement les fichiers .env lorsqu'il est déployé ou à le faire via des scripts automatisés.

En allant plus loin, pour des scénarios plus avancés, en particulier les déploiements conteneurisés (tels que Docker), je recommande fortement d'utiliser Secrets Management . Docker Swarm a son propre mécanisme de gestion des secrets et Kubernetes a également des objets secrets. Ces mécanismes vous permettent de stocker et de distribuer des données sensibles de manière cryptée et sont exposées à l'application uniquement lorsque le conteneur est en cours d'exécution. Par exemple, dans Docker Compose, vous pouvez définir des secrets:

 # docker-compose.yml
Version: '3.8'
services:
  App:
    Image: my_php_app
    Secrets:
      - DB_PASSWORD

Secrets:
  db_password:
    Fichier: ./db_password.txt # Il s'agit d'un fichier contenant un mot de passe et n'est généralement pas soumis à Git

à l'intérieur des applications PHP, ces secrets sont montés sous forme de chemins spécifiques vers le conteneur en tant que fichiers, et votre application peut lire ces fichiers pour obtenir des informations sensibles. Cette approche est plus s?re que les fichiers .env , car les données sensibles n'appara?tront même pas dans le texte clair dans le système de fichiers (au moins au niveau de l'h?te).

Pour les services cloud, tels que AWS, GCP et Azure, ils ont tous leurs propres services de gestion clés (KMS). AWS a Secrets Manager et GCP a un directeur secret. Ces services peuvent vous aider à gérer, à auditer et à faire tourner les clés de rotation de manière centralisée. Votre application PHP peut obtenir ces clés dynamiquement au moment de l'exécution via le SDK au lieu de codé dur ou stocké dans n'importe quel fichier. Il s'agit sans aucun doute du plus haut niveau de pratique de sécurité, en particulier adapté aux systèmes distribués à grande échelle et multi-services.

Enfin, je veux souligner une chose: ne faites jamais confiance aux clients. Toute information sensible qui doit être transmise à l'extrémité frontale doit être procassée ou traitée via l'API backend, plut?t que d'être directement exposée. Par exemple, vous ne devez pas utiliser la clé API de Stripe directement sur l'avant, mais vous devez laisser le serveur backend appeler l'API Stripe, et le frontal interagit uniquement avec votre API backend.

En général, du simple .env aux KMS de cloud complexes, quelle solution à choisir dépend de la taille de votre projet, des exigences de sécurité et des capacités de fonctionnement et de maintenance. Mais en tout cas, le retrait des informations sensibles de la base de code est la première et la plus critique.

Les variables d'environnement PHP ne sont pas efficaces? Des questions fréquemment posées et des conseils de débogage

Il est assez ennuyeux de rencontrer des variables d'environnement PHP qui ne prennent pas effet, mais il y a généralement des traces à suivre. Mon expérience personnelle est que ce type de problème n'est souvent pas un problème avec PHP lui-même, mais un écart dans la configuration ou la compréhension de l'environnement.

1. Vérifiez le mode de course PHP: c'est le plus facile à ignorer. Dans quel mode votre PHP fonctionne-t-il? Est-ce mod_php d'Apache? Ou PHP-FPM est-il combiné avec Nginx / Apache? Ou le mode CLI?

   • mod_php (non recommandé): les variables d'environnement sont généralement transmises directement par configuration Apache ( SetEnv ).
   • PHP-FPM: Les variables d'environnement sont généralement transmises par fastcgi_param dans NGINX / APACHE, ou sont définies dans la configuration du pool de PHP-FPM ( www.conf , etc.). Si vous définissez fastcgi_param dans NGINX mais ne l'obtenez pas dans PHP, vérifiez si la configuration NGINX est chargée correctement et si le PHP-FPM est redémarré correctement.
   • Mode CLI: Pour le moment, le processus PHP hérite directement des variables d'environnement de la coquille. Vous pouvez le définir avec export VAR=value dans le terminal, puis php your_script.php . Mais si vous exécutez des scripts à crontab , n'oubliez pas que les variables d'environnement de crontab sont indépendantes et peuvent avoir besoin d'être explicitement définies dans crontab .

2. Confirmez la source et la portée de la variable d'environnement: où avez-vous défini la variable d'environnement?

   • php.ini : assurez-vous de modifier le fichier php.ini qui est utilisé par la version PHP actuelle. Vous pouvez afficher Loaded Configuration File via phpinfo() . Après modification, assurez-vous de redémarrer PHP-FPM ou serveur Web .
   • Configuration du serveur Web:

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!