Что такое переменные окружения: Подробное руководство для начинающих

Переменные среды позволяют настраивать приложения без изменения кода. Они отделяют внешние данные от логики приложения, что может оставаться довольно загадочным для начинающих разработчиков (и даже для некоторых опытных).

С помощью этого практического руководства мы раскроем суть переменных среды, чтобы вы могли понять, что они собой представляют, почему они важны и как уверенно использовать переменные среды.

Возьмите ваш любимый напиток (и, возможно, немного печенья), потому что мы собираемся углубиться в тему. Давайте разбираться с концепциями среды выполнения с самого начала.

Что такое переменные среды?

Переменные среды — это динамические именованные значения, которые могут влиять на поведение выполняющихся процессов на компьютере. Некоторые ключевые свойства переменных среды:

• Именованные: Имеют описательные имена переменных, такие как APP_MODE и DB_URL.
• Внешние: Значения устанавливаются вне кода приложения через файлы, командные строки и системы.
• Динамичные: Можно обновлять переменные без перезапуска приложений.
• Настроенные: Код зависит от переменных, но не определяет их.
• Независимые: Не нужно изменять конфигурации кода после установки переменных.

Вот аналогия. Представьте, что вы следуете рецепту шоколадного печенья. В рецепте может быть сказано:

• Добавьте 1 чашку сахара
• Добавьте 1 пачку мягкого масла
• Добавьте 2 яйца

Вместо зашитых значений вы можете использовать переменные среды:

• Добавьте $SUGAR чашку сахара
• Добавьте $BUTTER стика смягченного масла
• Добавьте $EGGS яйца

Перед приготовлением печенья вы должны установить значения выбранных переменных среды:

SUGAR=1 
BUTTER=1
EGGS=2

Таким образом, при следовании рецепту ваши ингредиенты превратятся в:

• Добавьте 1 чашку сахара
• Добавьте 1 кусок смягченного масла
• Добавьте 2 яйца

Это позволяет вам настроить рецепт cookie, не изменяя код рецепта.

Тот же принцип применим к вычислениям и разработке. Переменные среды позволяют вам изменять среду, в которой выполняется процесс, не изменяя исходный код. Вот несколько распространенных примеров:

• Установка среды на “разработка” или “производство”
• Конфигурация API ключей для внешних сервисов
• Передача секретных ключей или учетных данных
• Переключение определенных функций включено/выключено

Переменные среды обеспечивают большую гибкость. Вы можете развертывать один и тот же код в различных средах, не изменяя сам код. Но давайте лучше поймем, почему они так ценны.

Почему переменные среды ценны?

Рассмотрим переменные среды как элементы управления приложением, используемые для настройки предпочтений. Скоро мы рассмотрим отличные примеры использования.

Давайте укрепим интуицию, почему переменные среды имеют значение!

Причина №1: Они разделяют код приложения и конфигурации

Жесткое кодирование конфигураций и учетных данных непосредственно в ваш код может вызвать множество проблем:

• Случайные коммиты в систему контроля версий
• Пересборка и переразвертывание кода ради изменения значения
• Проблемы конфигурации при продвижении через среды

Это также приводит к неаккуратному коду:

import os

# Жестко заданная конфигурация
DB_USER = 'appuser' 
DB_PASS = 'password123'
DB_HOST = 'localhost'
DB_NAME = 'myappdb'

def connect_to_db():
  print(f"Подключение к {DB_USER}:{DB_PASS}@{DB_HOST}/{DB_NAME}")  

connect_to_db()

Это вовлекает бизнес-логику в детали конфигурации. Тесная связь со временем затрудняет обслуживание:

• Изменения требуют модификации исходного кода
• Риск утечки секретов в систему контроля версий

Использование переменных окружения снижает эти проблемы. Например, вы можете установить переменные окружения DB_USER и DB_NAME.

# .env file
DB_USER=appuser
DB_PASS=password123  
DB_HOST=localhost
DB_NAME=myappdb

Код приложения может получать доступ к переменным окружения по мере необходимости, сохраняя чистоту и простоту кода.

import os

# Загрузка конфигурации из переменных окружения 
DB_USER = os.environ['DB_USER']
DB_PASS = os.environ['DB_PASS'] 
DB_HOST = os.environ['DB_HOST']
DB_NAME = os.environ['DB_NAME']

def connect_to_db():
  print(f"Подключение к {DB_USER}:{DB_PASS}@{DB_HOST}/{DB_NAME}")
  
connect_to_db()

Переменные среды четко разделяют конфигурацию и код, сохраняя чувствительные значения абстрагированными в среде.

Вы можете развертывать один и тот же код из среды разработки в производственную среду, не изменяя ничего. Переменные среды могут отличаться в разных средах, не оказывая никакого влияния на код.

Причина №2: Они упрощают настройку приложений

Переменные среды упрощают настройку конфигураций без изменения кода:

# .env file:
DEBUG=true

Вот как мы можем использовать это в файле скрипта:

# Содержание скрипта:
import os

DEBUG = os.environ.get('DEBUG') == 'true' 

if DEBUG:
   print("В режиме отладки")

Переключение режима отладки требует лишь обновления файла .env — изменения в коде, пересборка или переразмещение не требуются. «Переменные окружения» для краткости, также помогают без проблем осуществлять развертывание в разных средах:

import os

# Получение переменной окружения для определения текущего окружения (производственное или временный сайт)
current_env = os.getenv('APP_ENV', 'staging')  # По умолчанию 'временный сайт', если не установлено

# API ключ для производственной среды
PROD_API_KEY = os.environ['PROD_API_KEY']

# API ключ для временного сайта
STG_API_KEY = os.environ['STG_API_KEY']

# Логика, устанавливающая api_key в зависимости от текущего окружения
if current_env == 'production':
    api_key = PROD_API_KEY
else:
    api_key = STG_API_KEY

# Инициализация клиента API с соответствующим API ключом
api = ApiClient(api_key)

Тот же код может использовать отдельные API ключи для продакшена и временного сайта без каких-либо изменений.

И наконец, они позволяют использовать переключатели функций без новых развертываний:

NEW_FEATURE = os.environ['NEW_FEATURE'] == 'true'

if NEW_FEATURE:
   enableNewFeature()

Изменение переменной NEW_FEATURE мгновенно активирует функциональность в нашем коде. Интерфейс для обновления конфигураций зависит от систем:

• Облачные платформы, такие как Heroku, используют Панель управления веб
• Серверы используют инструменты командной строки ОС
• Локальная разработка может использовать файлы .env

Переменные среды полезны при создании приложений, позволяя пользователям настраивать элементы в соответствии с их требованиями.

Причина №3: Они помогают управлять секретами и учетными данными

Размещение секретов, таких как ключи API, пароли и закрытые ключи, непосредственно в исходном коде, представляет собой значительные риски для безопасности:

# Избегайте разглашения секретов в коде!
STRIPE_KEY = 'sk_live_1234abc'
DB_PASSWORD = 'password123'

stripe.api_key = STRIPE_KEY 
db.connect(DB_PASSWORD)

Эти учетные данные теперь станут общедоступными, если этот код будет добавлен в общедоступный репозиторий GitHub!

Переменные среды предотвращают утечку, внешне изолируя секреты:

import os

STRIPE_KEY = os.environ.get('STRIPE_KEY')  
DB_PASS = os.environ.get('DB_PASS')   

stripe.api_key = STRIPE_KEY  
db.connect(DB_PASS)

Фактические секретные значения устанавливаются в локальном файле .env.

# .env file

STRIPE_KEY=sk_live_1234abc
DB_PASS=password123

Не забудьте добавить файл .env в .gitignore, чтобы исключить секреты из системы контроля версий. Это включает в себя указание файла .env в файле .gitignore в корневом каталоге репозитория, что говорит git игнорировать файл при создании коммита.

Это отделяет определения секретов от кода приложения, загружая их безопасно из защищенных сред во время выполнения. Риск случайного разглашения учетных данных существенно снижается.

Причина №4: Они обеспечивают согласованность

Представьте, что у вас разные файлы конфигурации для сред разработки, контроля качества и производства:

# Разработка
DB_HOST = 'localhost'
DB_NAME = 'appdb_dev'

# Производство
DB_HOST = 'db.myapp.com'
DB_NAME = 'appdb_prod'

Это несоответствие приводит к возникновению тонких ошибок, которые сложно обнаружить. Код, который работает безупречно во время разработки, может внезапно сломаться в производстве из-за несоответствия конфигураций.

Переменные среды решают эту задачу, централизуя конфигурацию в одном месте:

DB_HOST=db.myapp.com
DB_NAME=appdb_prod

Теперь одни и те же переменные используются последовательно во всех средах. Вам больше не нужно беспокоиться о случайных или неправильных настройках.

Код приложения просто ссылается на переменные:

import os

db_host = os.environ['DB_HOST']
db_name = os.environ['DB_NAME']

db.connect(db_host, db_name)

Независимо от того, выполняется ли приложение локально или на производственном сервере, оно всегда использует правильный хост и имя базы данных.

Такая однородность снижает количество ошибок, повышает предсказуемость и делает приложение в целом более надежным. Разработчики могут быть уверены, что код будет вести себя одинаково в каждой среде.

Как определить переменные среды

Переменные среды могут быть определены в нескольких местах, что позволяет гибко настраивать их и получать доступ в различных процессах и системах.

1. Переменные среды операционной системы

Большинство операционных систем предоставляют встроенные механизмы для определения глобальных переменных. Это делает переменные доступными во всей системе для всех пользователей, приложений и т. д.

На системах Linux/Unix переменные можно определять в стартовых сценариях Shell.

Например, ~/.bashrc может использоваться для установки переменных на уровне пользователя, в то время как /etc/environment предназначен для системных переменных, к которым имеют доступ все пользователи.

Переменные также могут быть установлены в строке перед выполнением команд с использованием команды export или непосредственно через команду env в bash:

# In ~/.bashrc
export DB_URL=localhost
export APP_PORT=3000

# In /etc/environment
DB_HOST=localhost
DB_NAME=mydatabase

Переменные также могут быть установлены в строке перед выполнением команд:

export TOKEN=abcdef
python app.py

Определение переменных на уровне операционной системы делает их глобально доступными, что очень полезно, когда вы хотите запустить приложение без зависимости от внутренних значений.

Вы также можете ссылаться на определенные переменные в скриптах или аргументах командной строки.

python app.py --db-name $DB_NAME --db-host $DB_HOST --batch-size $BATCH_SIZE

2. Определение переменных среды в коде приложения

В дополнение к переменным уровня ОС, переменные среды могут быть определены и доступны непосредственно в коде приложения во время выполнения.

Словарь os.environ в Python содержит все текущие определенные переменные окружения. Мы можем установить новые, просто добавив пары ключ-значение:

Переменные среды также могут быть определены и доступны непосредственно в коде приложения. В Python, словарь os.environ содержит все определенные переменные среды:

import os
os.environ["API_KEY"] = "123456" 
api_key = os.environ.get("API_KEY")

Таким образом, словарь os.environ позволяет динамически устанавливать и извлекать переменные среды непосредственно из кода Python.

Большинство языков программирования поставляются вместе с их библиотеками, предоставляя доступ к переменным окружения во время выполнения.

Вы также можете использовать фреймворки, такие как Express, Django и Laravel, для более глубокой интеграции, например, для автоматической загрузки .env файлов, содержащих переменные среды.

3. Создание локальных конфигурационных файлов для переменных окружения

В дополнение к системным переменным, переменные среды могут загружаться из локальных файлов конфигурации приложения. Это позволяет отделить детали конфигурации от кода, даже для локальной разработки и тестирования.

Некоторые популярные подходы:

.env файлы

Конвенция формата файла .env, популяризированная Node.js, предоставляет удобный способ указания переменных среды в формате ключ-значение:

# .env
DB_URL=localhost
API_KEY=123456

Веб-фреймворки, такие как Django и Laravel, автоматически загружают переменные, определенные в файлах .env, в среду приложения. Для других языков, таких как Python, библиотеки, например python-dotenv, обрабатывают импорт файлов .env:

from dotenv import load_dotenv
load_dotenv() # Загружает переменные .env

print(os.environ['DB_URL']) # localhost

Преимущество использования файлов .env заключается в том, что они поддерживают чистоту и изолированность конфигурации без внесения изменений в код.

Файлы конфигурации JSON

Для более сложных потребностей в настройке, связанных с использованием нескольких переменных среды, использование файлов JSON или YAML помогает организовать переменные вместе:

// config.json
{
  "api_url": "https://api.example.com",
  "api_key": "123456", 
  "port": 3000
}

Код приложения может быстро загрузить эти данные JSON как словарь для доступа к настроенным переменным:

import json

config = json.load('config.json')  

api_url = config['api_url']
api_key = config['api_key'] 
port = config['port'] # 3000

Это предотвращает путаницу в файлах dotenv при работе с несколькими конфигурациями приложений.

Как получить доступ к переменным среды в разных языках программирования?

Как бы мы ни решили определять переменные среды, нашим приложениям необходим постоянный способ поиска значений во время выполнения.

Существует множество способов определения переменных окружения, однако код приложения требует стандартного способа доступа к ним во время выполнения, независимо от языка. Вот обзор методов доступа к переменным окружения в популярных языках:

Python

Python предоставляет словарь os.environ для доступа к определенным переменным окружения:

import os

db = os.environ.get('DB_NAME')

print(db)

Мы можем получить переменную, используя os.environ.get(), которая возвращает None, если она не определена. Или получить доступ напрямую через os.environ(), который вызовет KeyError, если переменная отсутствует.

Дополнительные методы, такие как os.getenv() и os.environ.get(), позволяют задавать значения по умолчанию, если они не установлены.

JavaScript (Node.js)

В Node.js коде JavaScript, переменные окружения доступны в глобальном объекте process.env:

// Получить переменную окружения
const db = process.env.DB_NAME;

console.log(db);

Если не определено, process.env будет содержать undefined. Мы также можем предоставить значения по умолчанию, например:

const db = process.env.DB_NAME || 'defaultdb';

Ruby

Приложения Ruby получают доступ к переменным среды через хеш ENV:

# Access variable 
db = ENV['DB_NAME']  

puts db

Мы также можем передать значение по умолчанию, если нужный ключ не существует:

db = ENV.fetch('DB_NAME', 'defaultdb')

PHP

PHP предоставляет глобальные методы getenv(), $_ENV и $_SERVER для доступа к переменным среды:

// Получить переменную окружения
$db_name = getenv('DB_NAME');

// Или получить доступ к массивам $_ENV или $_SERVER
$db_name = $_ENV['DB_NAME'];

В зависимости от источника переменной, она может быть доступна в различных глобальных переменных.

Java

В Java метод System.getenv() возвращает переменные окружения, которые можно получить:

String dbName = System.getenv("DB_NAME");

Это позволяет получать доступ к переменным, определенным на глобальном системном уровне в Java.

На данный момент, некоторые лучшие практики, связанные с гигиеной переменных окружения.

Руководство по безопасности переменных среды

Когда речь заходит о безопасном управлении переменными окружения, мы должны помнить о нескольких лучших практиках.

Никогда не храните конфиденциальную информацию в коде

Прежде всего, никогда не храните конфиденциальную информацию, такую как пароли, ключи API или токены, непосредственно в вашем коде.

Может возникнуть соблазн просто жестко задать пароль от базы данных или ключ шифрования в исходном коде для быстрого доступа, но сопротивляйтесь этому порыву!

Если вы случайно добавите этот код в публичный репозиторий на GitHub, вы, по сути, передадите ваши данные всему миру. Представьте, что хакер получит доступ к данным вашей рабочей базы данных, потому что они были открыто указаны в тексте вашего кода. Страшная мысль, правда?

Вместо этого всегда используйте переменные среды для хранения любых конфиденциальных настроек. Храните свои секреты в безопасном месте, таком как файл .env или инструмент управления секретами, и ссылайтесь на них в своем коде через переменные среды. Например, вместо того чтобы делать что-то подобное в вашем коде Python:

db_password = "supers3cr3tpassw0rd"

Вы бы сохраняли этот пароль в переменной среды следующим образом:

# .env file
DB_PASSWORD=supers3cr3tpassw0rd

А затем используйте его в своем коде так:

import os
db_password = os.environ.get('DB_PASSWORD')

Таким образом, ваши секреты остаются в безопасности, даже если ваш исходный код был скомпрометирован. Переменные среды действуют как защищенный уровень абстракции.

Использование переменных, специфичных для окружения

Еще одна практика заключается в использовании различных переменных среды для каждой среды приложения, таких как разработка, временный сайт и производство.

Вы не хотите случайно подключаться к своей рабочей базе данных во время локальной разработки, только потому что забыли обновить переменную конфигурации! Используйте пространства имен для переменных среды для каждой среды:

# Dev
DEV_API_KEY=abc123
DEV_DB_URL=localhost

# Production
PROD_API_KEY=xyz789
PROD_DB_URL=proddb.amazonaws.com

Затем, ссылаемся на соответствующие переменные в вашем коде в зависимости от текущей среды. Многие фреймворки, такие как Rails, предоставляют файлы конфигурации, специфичные для каждой среды, для этой цели.

Не храните секреты в системе контроля версий

Также важно держать ваши .env и конфигурационные файлы, содержащие секреты, вне системы контроля версий. Добавьте .env в ваш .gitignore, чтобы случайно не закоммитить его в ваш репозиторий.

Вы можете использовать git-secrets для сканирования на наличие конфиденциальной информации перед каждым коммитом. Для дополнительной безопасности шифруйте файл с секретами перед его сохранением. Инструменты, такие как Ansible Vault и BlackBox, могут помочь в этом.

Безопасное хранение секретов на производственных серверах

При управлении переменными среды на ваших производственных серверах избегайте их установки с помощью аргументов командной строки, которые можно проверить через таблицу процессов.

Вместо этого используйте инструменты управления средой вашей операционной системы или платформы оркестровки контейнеров. Например, вы можете использовать Kubernetes Secrets для безопасного хранения и предоставления секретов вашим приложениям в pods.

Используйте надежные алгоритмы шифрования

Используйте надежные и современные алгоритмы шифрования при шифровании ваших секретов, независимо от того, передаются они или хранятся. Избегайте устаревших алгоритмов, таких как DES или MD5, которые имеют известные уязвимости. Вместо этого выбирайте алгоритмы стандарта отрасли, такие как AES-256 для симметричного шифрования и RSA-2048 или ECDSA для асимметричного шифрования.

Регулярно обновляйте секреты

Регулярно обновляйте свои секреты, особенно если вы подозреваете, что они могли быть скомпрометированы. Относитесь к секретам так же, как к паролям — обновляйте их каждые несколько месяцев. Инструмент управления секретами, такой как Hashicorp Vault или AWS Secrets Manager, может помочь автоматизировать этот процесс.

Будьте осторожны с ведением журналов и отчетностью об ошибках

Будьте осторожны с ведением журналов и отчетностью об ошибках. Убедитесь, что вы не записываете переменные среды, содержащие конфиденциальные значения. Если вы используете сторонний инструмент для отслеживания ошибок, настройте его на очистку конфиденциальных данных. Последнее, чего вы хотите, чтобы ваши секреты появились в трассировке стека на панели управления отчетами об исключениях!

Когда избегать использования переменных среды?

Существует несколько случаев, когда следует избегать использования переменных среды:

Управление сложной конфигурацией

Использование переменных среды для управления конфигурацией сложных программных систем может стать запутанным и подверженным ошибкам. По мере увеличения количества параметров конфигурации вы сталкиваетесь с длинными именами переменных среды, которые могут непреднамеренно пересекаться. Также нет простого способа организовать связанные значения конфигурации вместе.

Вместо использования переменных среды рассмотрите возможность использования файлов конфигурации в форматах JSON или YAML. Это позволяет вам:

• Группируйте связанные параметры конфигурации вместе во вложенных структурах.
• Избегайте конфликтов имён, инкапсулируя конфигурацию в области видимости и пространства имен.
• Определяйте пользовательские типы данных вместо простых строк.
• Быстро просматривайте и изменяйте конфигурации с помощью текстового редактора.

Хранение конфиденциальной информации

Хотя переменные среды кажутся простым способом внедрения внешних конфигураций, таких как ключи API, пароли баз данных и т. д., это может вызвать проблемы с безопасностью.

Проблема в том, что переменные среды доступны глобально в процессе. Таким образом, если в части вашего приложения существует уязвимость, это может поставить под угрозу секреты, хранящиеся в переменных среды.

Более безопасный подход заключается в использовании сервиса управления секретами, который обеспечивает шифрование и контроль доступа. Эти сервисы позволяют хранить чувствительные данные внешне и предоставляют SDK для получения значений приложений.

Таким образом, рассмотрите возможность использования специализированного решения для управления секретами вместо переменных среды для учетных данных и приватных ключей. Это снижает риск случайного раскрытия конфиденциальных данных через уязвимости или непреднамеренное ведение журнала.

Работа с несколькими средами

Управление переменными среды может стать утомительным по мере роста приложений и их развертывания в различных средах (dev, staging, staging, prod). У вас может быть фрагментированные данные конфигурации, распределенные по различным bash-скриптам, инструментам развертывания и т.д.

Решение для управления конфигурацией помогает объединить все специфические для среды настройки в одном централизованном месте. Это могут быть файлы в репозитории, специализированный сервер конфигураций или интеграция с вашими CI/CD пайплайнами.

Если цель заключается в том, чтобы избежать дублирования переменных окружения, то единый источник истины для конфигураций имеет больший смысл.

Конфигурация обмена между командами

Поскольку переменные среды загружаются локально для каждого процесса, обмен и синхронизация конфигурационных данных между различными командами, работающими над одним приложением или набором сервисов, становится очень сложной.

Каждая команда может хранить свои копии значений конфигурации в различных bash-скриптах, манифестах развертывания и т.д. Такая децентрализованная конфигурация приводит к следующему:

1. Дрейф конфигураций: Отсутствие единого источника истины приводит к тому, что конфигурация может стать несогласованной в разных средах, поскольку разные команды вносят изменения независимо друг от друга.
2. Отсутствие видимости: Нет централизованного способа просмотра, поиска и анализа состояния конфигурации по всем сервисам. Это существенно усложняет понимание конфигурации сервиса.
3. Проблемы с аудитом: Изменения переменных окружения не отслеживаются стандартным способом, что затрудняет аудит того, кто и когда вносил изменения в конфигурацию.
4. Трудности с тестированием: Отсутствие возможности легко создать снимок и поделиться конфигурацией делает обеспечение согласованности сред для разработки и тестирования крайне обременительным.

Вместо этого фрагментированного подхода, наличие централизованного решения для конфигурации позволяет командам управлять конфигурацией с одной платформы или репозитория.

Создайте свои приложения с переменными среды на долгосрочную перспективу

По мере роста вашего приложения подумайте о том, как вам может потребоваться более продвинутые способы управления его конфигурационными настройками.

То, что кажется простым сейчас, может стать более сложным позже. Вам, скорее всего, понадобятся более эффективные способы контроля доступа, общих настроек команды, четкой организации всего и плавного обновления конфигураций.

Не загоняйте себя в угол, используя только переменные среды с самого начала. Вам нужно спланировать, как управлять конфигурациями по мере расширения ваших потребностей.

Хотя переменные среды отлично подходят для управления данными, ориентированными на среду, такими как учетные данные для входа, названия баз данных, локальные IP-адреса и т.д., вы захотите создать систему, которая следует здравым принципам, таким как безопасность, возможность обмена, организация и способность быстро адаптироваться к изменениям.

Альтернативы, которые мы обсуждали, такие как использование выделенного конфигурационного файла или сервиса, обладают ценными особенностями, которые соответствуют этим принципам. Это поможет вам продолжать быстро двигаться вперед, не замедляясь.