Setting Up a Git Repository for 1C-Bitrix: Workflow, CI, .gitignore

Imagine this: you're updating an online store's catalog with 50,000 products via FTP. You make changes to a template, upload it—and get a 500 error because a colleague was editing the same file simultaneously. Sound familiar? We had a client like that: every other release broke functionality, recovery took 3 hours. Switching to Git solved it—recovery time dropped to 15 minutes, incidents decreased 5 times. Proper Git repository setup for 1C-Bitrix is not just "committing a folder" but building a workflow that eliminates human error and accelerates releases by 3x. Our engineers with 10+ years of experience have completed over 50 migrations to Git for projects of varying complexity.

Why can't you just add /bitrix/ to the repository?

The Bitrix core is hundreds of megabytes of binary files and frequent updates. If you dump it into Git, every push will pull gigabytes, and the commit history will drown in changes to standard modules. Our goal is to store only what the team creates. Ignoring /bitrix/ and /upload/ is the first rule. Compare: Git deployment is 5 times faster than FTP upload, and rollback takes minutes instead of hours.

What to store in Git and what to exclude?

How to configure .gitignore – a proven template?

# Bitrix core
/bitrix/

# User content
/upload/

# Configuration with secrets
/.env
/bitrix/php_interface/dbconn.php

# Cache
/bitrix/cache/
/bitrix/managed_cache/
/bitrix/stack_cache/

# IDE
/.idea/
/.vscode/
*.swp

# Node.js (if used in local/)
/local/node_modules/
/local/.npm/

# OS
.DS_Store
Thumbs.db

This template will save you hours of debugging. Add it before the first git add. Optionally, you can exclude /local/vendor/ if using Composer and /bitrix/tmp/.

Initializing an existing project: step by step

If the project is already on the server, proceed as follows:

cd /var/www/myshop
git init
git remote add origin [email protected]:projects/myshop.git
nano .gitignore   # paste the content above

git add local/ .gitignore deploy/ nginx.conf.example .env.example
git commit -m "Initial commit: local customizations"
git push -u origin main

If you accidentally added /bitrix/ to the index, remove it:

git rm -r --cached bitrix/ upload/
git commit -m "Remove bitrix/ and upload/ from tracking"

How to organize branches and workflow?

For Bitrix projects, we recommend a simplified GitFlow. Compare with FTP deployment: Git reduces recovery time after a failure by 3x and eliminates human error. Automation with Git cuts deployment time from 2 hours to 10 minutes.

main        – production (only via CI)
develop     – main branch (auto-deploy to staging)
feature/*   – tasks (feature/JIRA-123-new-filter)
hotfix/*    – urgent production fixes

Write commits following Conventional Commits: feat(catalog): add ajax filter, fix(checkout): null reference, refactor(helpers): move functions.

How to set up CI/CD for a Bitrix project?

After setting up the repository, we connect CI. For example, GitLab CI: on every push to develop, a build, test, and deploy to staging runs. On main — deploy to production after verification. This saves up to 40% of debugging time and eliminates manual deployment errors. Example of a simple .gitlab-ci.yml:

stages:
  - deploy

deploy_staging:
  stage: deploy
  script:
    - rsync -avz --exclude-from='.gitignore' . user@staging:/var/www/
  only:
    - develop

What to do about merge conflicts?

Conflicts occur when two developers modify the same file. Solution: before merging, frequently do git pull --rebase and communicate with the team. If a conflict occurs, resolve it manually by removing the markers <<<<<<<, =======, >>>>>>>. For Bitrix, typical conflicts are in dbconn.php (but it's not in the repository) and in templates. Our experience: with proper workflow, conflicts occur no more than once a month, and resolution takes 10–15 minutes.

How to work with configuration files?

Secrets go only in .env. The dbconn.php file is not committed; on the server it is created by the deployment script. Example content:

<?php
$DBHost = getenv('DB_HOST') ?: 'localhost';
$DBLogin = getenv('DB_USER') ?: 'bitrix';
$DBPassword = getenv('DB_PASSWORD') ?: '';
$DBName = getenv('DB_NAME') ?: 'bitrix_db';
?>

And .env.example is committed with empty keys:

DB_HOST=
DB_USER=
DB_PASSWORD=
DB_NAME=
SMTP_HOST=

What you get as a result

We set up a Git repository turnkey:

• correct .gitignore tailored to your Bitrix version;
• initialization and first commit with the right files;
• branch setup, merge rules, and CI (GitLab CI / GitHub Actions);
• workflow documentation for the team;
• training developers on Git basics for Bitrix.

After Git setup, you cut debugging costs by 40% — the team spends time on features, not resolving conflicts. Contact us — we'll evaluate your project within one business day. Our engineers have over 10 years of experience and have completed 50+ successful Git migrations. We are certified 1C-Bitrix specialists.

Git — distributed version control system (wikipedia.org)

Estimated timelines

Total time – from 2 days. Order the setup — get a clean history and worry-free releases.

Problems We Solve

rsync -avz to production on Friday evening, restart php-fpm, and the site returns 502 — local database settings remain in .settings.php. Classic “deployment the old way” turns into a lottery. Another scenario: a module update from the admin panel breaks a custom component template — changes aren’t tracked in version control, recovery takes hours. Without a DevOps culture, every release is a gamble.

We design a predictable DevOps cycle for 1C-Bitrix: from Docker environment to Telegram alerts. Each deployment becomes routine, each incident triggers a context‑rich alert. Below is how we solve real Bitrix team problems — with numbers, tools, and proven configurations.

Why DevOps Is Critical for Bitrix Projects?

Bitrix projects carry specific infrastructure requirements: heavy e‑commerce catalogs, 1C exchange via CommerceML, dozens of agents and events. Without CI/CD and monitoring, every change introduces risk. A single stuck agent can silently break a 1C sync for hours; a manual deployment mistake can cost a client lost orders. We’ve seen teams spend 12 hours per month just on manual deployments and crash recovery — after our CI/CD pipeline, that drops to zero.

CI/CD Pipeline: From Commit to Production Without Hands

Git migration – we move the project from FTP to Git (GitLab, GitHub, Bitbucket). Branch structure: main (production), staging, develop, feature branches. A proper .gitignore for Bitrix is non‑trivial:

/bitrix/cache/
/bitrix/managed_cache/
/bitrix/stack_cache/
/upload/
/bitrix/php_interface/dbconn.php
/bitrix/.settings.php
/bitrix/license_key.php

Miss managed_cache/ → the repository bloats to gigabytes. Forget license_key.php → the key leaks.

CI pipeline – automatically runs PHPStan level 5+, PHP_CodeSniffer with Bitrix standard, PHPUnit for business logic, composer audit, frontend build.

CD pipeline – deploys without human intervention. Merge to staging → deploy to staging. Merge to main → deploy to production (with optional manual confirmation). Zero‑downtime via symlink strategy: new version in a separate folder, current → symlink switches in milliseconds. upload/ lives outside release directories. Healthcheck fails → symlink rolls back automatically. Tools: GitLab CI/CD, GitHub Actions, Deployer (PHP). Deployer’s built‑in recipes for Bitrix handle shared directories and symlink deployment out‑of‑the‑box.

Docker Environment: How We Eliminate “It Works on My Machine”

The Docker environment fixes versions of all components: nginx, PHP, MySQL, Redis. Configuration mirrors production — same PHP modules, same php.ini.

Local development – docker-compose.yml includes nginx + php‑fpm 8.1/8.2 + MySQL 8.0 (or MariaDB 10.6) + Redis + Memcached. New developer: git clone + docker-compose up -d → writes code within 5 minutes. Parallel work on different PHP versions via separate compose files.

Bitrix specifics in Docker:

• /upload/ mounted as a named volume (not bind mount — permission and speed issues on Windows/Mac).
• Cron jobs (/bitrix/modules/main/tools/cron_events.php) run via a separate container with supervisord.
• “Proactive Protection” module (security) blocks requests through reverse proxy — need set_real_ip_from and realip_module.
• Database config (dbconn.php, .settings.php) set via environment variables, never through a volume with production configs.

Production – multi‑stage Dockerfile (build stage for assets, production stage with lightweight image), Docker Registry for tagged images, orchestration via Docker Swarm or Kubernetes for large projects.

Nginx and PHP‑FPM Configuration for Bitrix Performance

The difference between “site is slow” and 200 ms TTFB lies in configuration. nginx:

• location blocks for Bitrix handle urlrewrite.php for friendly URLs.
• /bitrix/admin/ IP‑restricted via allow/deny.
• expires 30d for static files — CSS, JS, images cached by the browser.
• Brotli compression (15‑20% better than gzip): brotli on; brotli_comp_level 6;.
• Rate limiting on /bitrix/tools/ protects against brute force.
• HTTP/2 push for critical resources.

php‑fpm: pm = dynamic. Calculate pm.max_children: (RAM - RAM_other_services) / avg_memory_per_process. For Bitrix, avg is 40–80 MB. OPcache: opcache.memory_consumption=256 (default 128 is insufficient — Bitrix loads thousands of files), opcache.max_accelerated_files=20000, opcache.validate_timestamps=0 in production (reset via cachetool opcache:reset on deployment). php.ini: memory_limit=256M (up to 512M for heavy imports), max_execution_time=60, upload_max_filesize=100M. Slowlog with request_slowlog_timeout=5s catches bottlenecks before users complain.

Monitoring and Logging: What We Track

Infrastructure – Prometheus + Grafana: metrics for CPU, RAM, disk, network, service status. Alerts: CPU > 80% for 5 minutes, free RAM < 500 MB, disk > 85%, php‑fpm queue > 0 (worker shortage). Node Exporter, MySQL Exporter, PHP‑FPM Exporter collect data.

Application – Uptime check every 60 seconds → Telegram alert within a minute of downtime. Response time of key URLs: /, /catalog/, /personal/order/make/. Sentry for PHP errors — structured errors with context. Bitrix agents (b_agent): we check NEXT_EXEC < NOW() - INTERVAL 1 HOUR — a stuck agent silently breaks 1C exchange.

Logging – ELK Stack or Loki + Grafana: nginx access/error, php‑fpm slow log, MySQL slow query log, Bitrix errors. Rotation via logrotate — without it, access.log takes 50 GB after six months.

Backup Strategy and Disaster Recovery

Geographic distribution — S3‑compatible storage + separate server in another datacenter. Test restoration monthly — a backup never restored is just an illusion of security. Cron with notifications: if backup fails, alert immediately.

What’s Included in the Service

Our team brings 5+ years of Bitrix DevOps experience (over 50 successful projects) and certified engineers. The service provides:

• DevOps process documentation (deployment scheme, branch policy, infrastructure description)
• Configured CI/CD pipelines (GitLab CI / GitHub Actions) with working triggers
• Docker environment (docker-compose.yml, Dockerfile, configs)
• Ansible playbooks for server reproduction
• Monitoring (Grafana dashboards, alerts in Telegram / Slack)
• Secured access with role‑based model
• Team training: two sessions on CI/CD, Docker, and deployment
• Support during implementation (two weeks after launch)

Infrastructure‑as‑code with Ansible is 5× faster than manual server configuration and eliminates human errors.

Implementation Process and Timelines

1. Audit of current state – assess infrastructure, software, processes (2–3 days).
2. Architecture design – choose stack (Docker / K8s / Ansible), agree on CI/CD policies, set up repository.
3. Environment setup – Docker for local development, staging, production servers.
4. CI/CD implementation – write pipelines, test deployment, integrate with monitoring.
5. Monitoring and alerting – install Prometheus + Grafana, configure dashboards and notifications.
6. Team training – two sessions on tool usage.

DevOps is not a project with an end date — it’s a transition from “upload via FTP and pray” to predictable processes. Each deployment is routine, each incident carries context, each new developer does docker-compose up instead of a three‑day environment setup.

Get a consultation – we’ll prepare a tailored implementation plan within 2–3 days. Order a turnkey DevOps implementation – gain stability and full control over your infrastructure.