731 lines
18 KiB
Markdown
731 lines
18 KiB
Markdown
# Symfony Performance Optimization Guide
|
|
|
|
## Profiling & Monitoring
|
|
|
|
### Symfony Profiler Configuration
|
|
|
|
```yaml
|
|
# config/packages/dev/web_profiler.yaml
|
|
web_profiler:
|
|
toolbar: true
|
|
intercept_redirects: false
|
|
|
|
framework:
|
|
profiler:
|
|
only_exceptions: false
|
|
collect: true
|
|
only_master_requests: true
|
|
```
|
|
|
|
### Blackfire Integration
|
|
|
|
```php
|
|
// Install Blackfire
|
|
// composer require blackfire/php-sdk
|
|
|
|
use Blackfire\Client;
|
|
|
|
class PerformanceService
|
|
{
|
|
private Client $blackfire;
|
|
|
|
public function profileOperation(string $name, callable $operation)
|
|
{
|
|
$config = new \Blackfire\Profile\Configuration();
|
|
$config->setTitle($name);
|
|
$config->setSamples(10);
|
|
|
|
$probe = $this->blackfire->createProbe($config);
|
|
|
|
$result = $operation();
|
|
|
|
$profile = $this->blackfire->endProbe($probe);
|
|
|
|
return $result;
|
|
}
|
|
}
|
|
```
|
|
|
|
## Database Optimization
|
|
|
|
### Query Optimization
|
|
|
|
```php
|
|
namespace App\Repository;
|
|
|
|
use Doctrine\ORM\QueryBuilder;
|
|
use Doctrine\ORM\Query;
|
|
|
|
class ProductRepository extends ServiceEntityRepository
|
|
{
|
|
/**
|
|
* Optimized query with proper indexing and eager loading
|
|
*/
|
|
public function findActiveProductsOptimized(): array
|
|
{
|
|
return $this->createQueryBuilder('p', 'p.id') // Index by ID
|
|
->select('p', 'c', 'i', 't') // Select all at once
|
|
->leftJoin('p.category', 'c')
|
|
->leftJoin('p.images', 'i')
|
|
->leftJoin('p.tags', 't')
|
|
->where('p.active = :active')
|
|
->andWhere('p.stock > :stock')
|
|
->setParameter('active', true)
|
|
->setParameter('stock', 0)
|
|
->orderBy('p.createdAt', 'DESC')
|
|
->setMaxResults(100) // Limit results
|
|
->getQuery()
|
|
->setHint(Query::HINT_FORCE_PARTIAL_LOAD, true) // Force partial loading
|
|
->useQueryCache(true) // Use query cache
|
|
->useResultCache(true, 3600) // Cache for 1 hour
|
|
->getResult();
|
|
}
|
|
|
|
/**
|
|
* Use raw SQL for complex queries
|
|
*/
|
|
public function findProductsWithComplexCalculation(): array
|
|
{
|
|
$sql = "
|
|
SELECT
|
|
p.id,
|
|
p.name,
|
|
p.price,
|
|
COUNT(DISTINCT o.id) as order_count,
|
|
SUM(oi.quantity) as total_sold,
|
|
AVG(r.rating) as avg_rating
|
|
FROM product p
|
|
LEFT JOIN order_item oi ON oi.product_id = p.id
|
|
LEFT JOIN `order` o ON o.id = oi.order_id
|
|
LEFT JOIN review r ON r.product_id = p.id
|
|
WHERE p.active = 1
|
|
GROUP BY p.id
|
|
HAVING order_count > 10
|
|
ORDER BY total_sold DESC
|
|
LIMIT 50
|
|
";
|
|
|
|
$stmt = $this->getEntityManager()->getConnection()->prepare($sql);
|
|
return $stmt->executeQuery()->fetchAllAssociative();
|
|
}
|
|
|
|
/**
|
|
* Batch processing for large datasets
|
|
*/
|
|
public function processLargeDataset(\Closure $processor): void
|
|
{
|
|
$batchSize = 100;
|
|
$offset = 0;
|
|
|
|
while (true) {
|
|
$products = $this->createQueryBuilder('p')
|
|
->setFirstResult($offset)
|
|
->setMaxResults($batchSize)
|
|
->getQuery()
|
|
->getResult();
|
|
|
|
if (empty($products)) {
|
|
break;
|
|
}
|
|
|
|
foreach ($products as $product) {
|
|
$processor($product);
|
|
}
|
|
|
|
$this->getEntityManager()->flush();
|
|
$this->getEntityManager()->clear(); // Clear to free memory
|
|
|
|
$offset += $batchSize;
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
### Database Indexes
|
|
|
|
```php
|
|
namespace App\Entity;
|
|
|
|
use Doctrine\ORM\Mapping as ORM;
|
|
|
|
#[ORM\Entity]
|
|
#[ORM\Table(name: 'product')]
|
|
#[ORM\Index(name: 'idx_active_stock', columns: ['active', 'stock'])]
|
|
#[ORM\Index(name: 'idx_category_active', columns: ['category_id', 'active'])]
|
|
#[ORM\Index(name: 'idx_created_at', columns: ['created_at'])]
|
|
#[ORM\UniqueConstraint(name: 'uniq_sku', columns: ['sku'])]
|
|
class Product
|
|
{
|
|
#[ORM\Column(length: 100)]
|
|
#[ORM\Index] // Single column index
|
|
private ?string $sku = null;
|
|
|
|
// Other properties...
|
|
}
|
|
```
|
|
|
|
### Connection Pooling
|
|
|
|
```yaml
|
|
# config/packages/doctrine.yaml
|
|
doctrine:
|
|
dbal:
|
|
connections:
|
|
default:
|
|
url: '%env(resolve:DATABASE_URL)%'
|
|
# Connection pooling
|
|
options:
|
|
persistent: true
|
|
# Maximum lifetime of a connection
|
|
connect_timeout: 10
|
|
# Server settings
|
|
1002: 'SET sql_mode = TRADITIONAL'
|
|
pool:
|
|
min_connections: 2
|
|
max_connections: 10
|
|
max_idle_time: 600
|
|
|
|
read_replica:
|
|
url: '%env(resolve:DATABASE_REPLICA_URL)%'
|
|
options:
|
|
persistent: true
|
|
```
|
|
|
|
## Caching Strategies
|
|
|
|
### Multi-level Caching
|
|
|
|
```php
|
|
namespace App\Service;
|
|
|
|
use Psr\Cache\CacheItemPoolInterface;
|
|
use Symfony\Contracts\Cache\ItemInterface;
|
|
use Symfony\Contracts\Cache\TagAwareCacheInterface;
|
|
|
|
class CacheService
|
|
{
|
|
public function __construct(
|
|
private TagAwareCacheInterface $cache,
|
|
private CacheItemPoolInterface $redisCache,
|
|
private CacheItemPoolInterface $apcu
|
|
) {}
|
|
|
|
/**
|
|
* Multi-level cache with fallback
|
|
*/
|
|
public function getWithFallback(string $key, callable $callback, int $ttl = 3600): mixed
|
|
{
|
|
// Level 1: APCu (fastest, local)
|
|
$apcuItem = $this->apcu->getItem($key);
|
|
if ($apcuItem->isHit()) {
|
|
return $apcuItem->get();
|
|
}
|
|
|
|
// Level 2: Redis (fast, shared)
|
|
$redisItem = $this->redisCache->getItem($key);
|
|
if ($redisItem->isHit()) {
|
|
$value = $redisItem->get();
|
|
|
|
// Store in APCu for next time
|
|
$apcuItem->set($value);
|
|
$apcuItem->expiresAfter(300); // 5 minutes in APCu
|
|
$this->apcu->save($apcuItem);
|
|
|
|
return $value;
|
|
}
|
|
|
|
// Level 3: Generate and store in both caches
|
|
$value = $callback();
|
|
|
|
// Store in Redis
|
|
$redisItem->set($value);
|
|
$redisItem->expiresAfter($ttl);
|
|
$this->redisCache->save($redisItem);
|
|
|
|
// Store in APCu
|
|
$apcuItem->set($value);
|
|
$apcuItem->expiresAfter(300);
|
|
$this->apcu->save($apcuItem);
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Cache with tags for invalidation
|
|
*/
|
|
public function getWithTags(string $key, array $tags, callable $callback, int $ttl = 3600): mixed
|
|
{
|
|
return $this->cache->get($key, function (ItemInterface $item) use ($callback, $tags, $ttl) {
|
|
$item->expiresAfter($ttl);
|
|
$item->tag($tags);
|
|
|
|
return $callback();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Invalidate by tags
|
|
*/
|
|
public function invalidateTags(array $tags): void
|
|
{
|
|
$this->cache->invalidateTags($tags);
|
|
}
|
|
|
|
/**
|
|
* Warm cache
|
|
*/
|
|
public function warmCache(array $keys, callable $generator): void
|
|
{
|
|
foreach ($keys as $key => $params) {
|
|
$this->cache->get($key, function () use ($generator, $params) {
|
|
return $generator($params);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
### HTTP Caching
|
|
|
|
```php
|
|
namespace App\Controller;
|
|
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
use Symfony\Component\HttpFoundation\Response;
|
|
use Symfony\Component\HttpKernel\Attribute\Cache;
|
|
|
|
class ProductController extends AbstractController
|
|
{
|
|
#[Route('/products', name: 'product_list')]
|
|
#[Cache(maxage: 3600, public: true, mustRevalidate: true)]
|
|
public function index(): Response
|
|
{
|
|
$response = $this->render('product/index.html.twig');
|
|
|
|
// Set cache headers
|
|
$response->setPublic();
|
|
$response->setMaxAge(3600);
|
|
$response->setSharedMaxAge(3600);
|
|
$response->headers->addCacheControlDirective('must-revalidate', true);
|
|
|
|
// ETag for validation
|
|
$response->setEtag(md5($response->getContent()));
|
|
|
|
return $response;
|
|
}
|
|
|
|
#[Route('/products/{id}', name: 'product_show')]
|
|
public function show(Product $product, Request $request): Response
|
|
{
|
|
$response = new Response();
|
|
|
|
// Set ETag
|
|
$etag = md5($product->getUpdatedAt()->format('c'));
|
|
$response->setEtag($etag);
|
|
|
|
// Set Last-Modified
|
|
$response->setLastModified($product->getUpdatedAt());
|
|
|
|
// Check if not modified
|
|
$response->setNotModified();
|
|
if ($response->isNotModified($request)) {
|
|
return $response;
|
|
}
|
|
|
|
// Generate content
|
|
return $this->render('product/show.html.twig', [
|
|
'product' => $product
|
|
], $response);
|
|
}
|
|
}
|
|
```
|
|
|
|
### ESI (Edge Side Includes)
|
|
|
|
```twig
|
|
{# templates/base.html.twig #}
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<body>
|
|
<header>
|
|
{{ render_esi(controller('App\\Controller\\HeaderController::index')) }}
|
|
</header>
|
|
|
|
<main>
|
|
{% block body %}{% endblock %}
|
|
</main>
|
|
|
|
<aside>
|
|
{{ render_esi(controller('App\\Controller\\SidebarController::popularProducts', {
|
|
'max': 5,
|
|
'_cache': 3600
|
|
})) }}
|
|
</aside>
|
|
</body>
|
|
</html>
|
|
```
|
|
|
|
## Asset Optimization
|
|
|
|
### Webpack Encore Configuration
|
|
|
|
```javascript
|
|
// webpack.config.js
|
|
const Encore = require('@symfony/webpack-encore');
|
|
|
|
Encore
|
|
.setOutputPath('public/build/')
|
|
.setPublicPath('/build')
|
|
|
|
// Enable production optimizations
|
|
.enableSingleRuntimeChunk()
|
|
.enableIntegrityHashes(Encore.isProduction())
|
|
.enableBuildNotifications()
|
|
|
|
// Split vendor code
|
|
.splitEntryChunks()
|
|
|
|
// Configure optimization
|
|
.configureOptimizationSplitChunks((config) => {
|
|
config.chunks = 'all';
|
|
config.cacheGroups = {
|
|
vendors: {
|
|
test: /[\\/]node_modules[\\/]/,
|
|
priority: 20,
|
|
name: 'vendors',
|
|
enforce: true
|
|
},
|
|
commons: {
|
|
minChunks: 2,
|
|
priority: 10,
|
|
reuseExistingChunk: true
|
|
}
|
|
};
|
|
})
|
|
|
|
// Enable compression
|
|
.configureCompressionPlugin((options) => {
|
|
options.algorithm = 'gzip';
|
|
options.test = /\.(js|css|html|svg)$/;
|
|
options.threshold = 10240;
|
|
options.minRatio = 0.8;
|
|
})
|
|
|
|
// Image optimization
|
|
.configureImageRule({
|
|
type: 'asset',
|
|
maxSize: 4 * 1024 // 4 kb
|
|
})
|
|
|
|
// Enable versioning
|
|
.enableVersioning(Encore.isProduction())
|
|
|
|
// CDN support
|
|
.setManifestKeyPrefix('build/')
|
|
.configureCdn('https://cdn.example.com')
|
|
;
|
|
|
|
module.exports = Encore.getWebpackConfig();
|
|
```
|
|
|
|
### Lazy Loading Assets
|
|
|
|
```twig
|
|
{# Lazy load images #}
|
|
<img
|
|
src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 1 1'%3E%3C/svg%3E"
|
|
data-src="{{ asset('images/product.jpg') }}"
|
|
loading="lazy"
|
|
alt="Product"
|
|
class="lazyload"
|
|
/>
|
|
|
|
{# Lazy load scripts #}
|
|
<script>
|
|
// Dynamic import for code splitting
|
|
document.getElementById('load-feature').addEventListener('click', async () => {
|
|
const { FeatureModule } = await import('./features/heavy-feature.js');
|
|
FeatureModule.init();
|
|
});
|
|
</script>
|
|
|
|
{# Preload critical assets #}
|
|
<link rel="preload" href="{{ asset('build/app.css') }}" as="style">
|
|
<link rel="preload" href="{{ asset('build/app.js') }}" as="script">
|
|
<link rel="preload" href="{{ asset('fonts/main.woff2') }}" as="font" type="font/woff2" crossorigin>
|
|
```
|
|
|
|
## PHP Optimization
|
|
|
|
### OPcache Configuration
|
|
|
|
```ini
|
|
; php.ini or opcache.ini
|
|
opcache.enable=1
|
|
opcache.enable_cli=0
|
|
opcache.memory_consumption=256
|
|
opcache.interned_strings_buffer=16
|
|
opcache.max_accelerated_files=20000
|
|
opcache.max_wasted_percentage=10
|
|
opcache.validate_timestamps=0
|
|
opcache.revalidate_freq=0
|
|
opcache.fast_shutdown=1
|
|
opcache.enable_file_override=1
|
|
opcache.max_file_size=0
|
|
opcache.file_cache=/var/cache/opcache
|
|
opcache.file_cache_only=0
|
|
opcache.file_cache_consistency_checks=0
|
|
|
|
; Preload Symfony application
|
|
opcache.preload=/var/www/config/preload.php
|
|
opcache.preload_user=www-data
|
|
```
|
|
|
|
### Preloading Script
|
|
|
|
```php
|
|
// config/preload.php
|
|
if (file_exists(dirname(__DIR__).'/var/cache/prod/App_KernelProdContainer.preload.php')) {
|
|
require dirname(__DIR__).'/var/cache/prod/App_KernelProdContainer.preload.php';
|
|
}
|
|
|
|
// Additional files to preload
|
|
$files = [
|
|
__DIR__ . '/../src/Entity/',
|
|
__DIR__ . '/../src/Repository/',
|
|
__DIR__ . '/../src/Service/',
|
|
];
|
|
|
|
foreach ($files as $file) {
|
|
if (is_dir($file)) {
|
|
foreach (glob($file . '*.php') as $filename) {
|
|
opcache_compile_file($filename);
|
|
}
|
|
} elseif (is_file($file)) {
|
|
opcache_compile_file($file);
|
|
}
|
|
}
|
|
```
|
|
|
|
## Async Processing
|
|
|
|
### Symfony Messenger Optimization
|
|
|
|
```yaml
|
|
# config/packages/messenger.yaml
|
|
framework:
|
|
messenger:
|
|
transports:
|
|
async_priority_high:
|
|
dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
|
|
options:
|
|
queue_name: high_priority
|
|
exchange:
|
|
name: high_priority
|
|
type: direct
|
|
retry_strategy:
|
|
max_retries: 3
|
|
delay: 1000
|
|
|
|
async_priority_normal:
|
|
dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
|
|
options:
|
|
queue_name: normal_priority
|
|
|
|
async_priority_low:
|
|
dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
|
|
options:
|
|
queue_name: low_priority
|
|
|
|
routing:
|
|
'App\Message\EmailMessage': async_priority_high
|
|
'App\Message\ProcessImage': async_priority_normal
|
|
'App\Message\GenerateReport': async_priority_low
|
|
|
|
buses:
|
|
messenger.bus.default:
|
|
middleware:
|
|
- doctrine_ping_connection
|
|
- doctrine_clear_entity_manager
|
|
```
|
|
|
|
### Batch Message Processing
|
|
|
|
```php
|
|
namespace App\MessageHandler;
|
|
|
|
use App\Message\ProcessOrder;
|
|
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
|
|
|
|
#[AsMessageHandler]
|
|
class ProcessOrderHandler
|
|
{
|
|
private array $batch = [];
|
|
private const BATCH_SIZE = 100;
|
|
|
|
public function __invoke(ProcessOrder $message): void
|
|
{
|
|
$this->batch[] = $message;
|
|
|
|
if (count($this->batch) >= self::BATCH_SIZE) {
|
|
$this->processBatch();
|
|
}
|
|
}
|
|
|
|
private function processBatch(): void
|
|
{
|
|
// Process entire batch at once
|
|
$orderIds = array_map(fn($msg) => $msg->getOrderId(), $this->batch);
|
|
|
|
$orders = $this->orderRepository->findByIds($orderIds);
|
|
|
|
foreach ($orders as $order) {
|
|
$this->processOrder($order);
|
|
}
|
|
|
|
$this->entityManager->flush();
|
|
$this->batch = [];
|
|
}
|
|
|
|
public function __destruct()
|
|
{
|
|
if (!empty($this->batch)) {
|
|
$this->processBatch();
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
## Server Optimization
|
|
|
|
### PHP-FPM Configuration
|
|
|
|
```ini
|
|
; /etc/php/8.1/fpm/pool.d/www.conf
|
|
[www]
|
|
pm = dynamic
|
|
pm.max_children = 50
|
|
pm.start_servers = 10
|
|
pm.min_spare_servers = 5
|
|
pm.max_spare_servers = 20
|
|
pm.max_requests = 500
|
|
pm.process_idle_timeout = 10s
|
|
|
|
; Performance tuning
|
|
request_terminate_timeout = 30
|
|
request_slowlog_timeout = 10s
|
|
slowlog = /var/log/php-fpm/slow.log
|
|
|
|
; Resource limits
|
|
rlimit_files = 65536
|
|
rlimit_core = unlimited
|
|
```
|
|
|
|
### Nginx Configuration
|
|
|
|
```nginx
|
|
# /etc/nginx/sites-available/symfony
|
|
server {
|
|
server_name example.com;
|
|
root /var/www/symfony/public;
|
|
|
|
# Gzip compression
|
|
gzip on;
|
|
gzip_vary on;
|
|
gzip_min_length 1024;
|
|
gzip_types text/plain text/css text/xml text/javascript application/json application/javascript application/xml+rss application/rss+xml application/atom+xml image/svg+xml text/javascript application/vnd.ms-fontobject application/x-font-ttf font/opentype;
|
|
|
|
# Browser caching
|
|
location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff|woff2)$ {
|
|
expires 1y;
|
|
add_header Cache-Control "public, immutable";
|
|
}
|
|
|
|
# PHP-FPM
|
|
location ~ ^/index\.php(/|$) {
|
|
fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
|
|
fastcgi_split_path_info ^(.+\.php)(/.*)$;
|
|
include fastcgi_params;
|
|
|
|
# Performance
|
|
fastcgi_buffer_size 128k;
|
|
fastcgi_buffers 4 256k;
|
|
fastcgi_busy_buffers_size 256k;
|
|
fastcgi_temp_file_write_size 256k;
|
|
|
|
# Cache
|
|
fastcgi_cache_bypass $http_pragma $http_authorization;
|
|
fastcgi_no_cache $http_pragma $http_authorization;
|
|
|
|
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
|
|
fastcgi_param DOCUMENT_ROOT $realpath_root;
|
|
|
|
internal;
|
|
}
|
|
|
|
location / {
|
|
try_files $uri /index.php$is_args$args;
|
|
}
|
|
}
|
|
```
|
|
|
|
## Monitoring & Metrics
|
|
|
|
```php
|
|
namespace App\Service;
|
|
|
|
use Prometheus\CollectorRegistry;
|
|
use Prometheus\Storage\Redis;
|
|
|
|
class MetricsService
|
|
{
|
|
private CollectorRegistry $registry;
|
|
|
|
public function __construct()
|
|
{
|
|
Redis::setDefaultOptions([
|
|
'host' => '127.0.0.1',
|
|
'port' => 6379,
|
|
]);
|
|
|
|
$this->registry = new CollectorRegistry(new Redis());
|
|
}
|
|
|
|
public function recordRequestDuration(string $route, float $duration): void
|
|
{
|
|
$histogram = $this->registry->getOrRegisterHistogram(
|
|
'symfony',
|
|
'request_duration_seconds',
|
|
'Request duration in seconds',
|
|
['route']
|
|
);
|
|
|
|
$histogram->observe($duration, [$route]);
|
|
}
|
|
|
|
public function incrementCounter(string $name, array $labels = []): void
|
|
{
|
|
$counter = $this->registry->getOrRegisterCounter(
|
|
'symfony',
|
|
$name,
|
|
'Counter for ' . $name,
|
|
array_keys($labels)
|
|
);
|
|
|
|
$counter->inc(array_values($labels));
|
|
}
|
|
}
|
|
```
|
|
|
|
## Performance Checklist
|
|
|
|
1. **Enable OPcache with preloading**
|
|
2. **Use HTTP caching headers**
|
|
3. **Implement database query caching**
|
|
4. **Optimize database indexes**
|
|
5. **Use CDN for static assets**
|
|
6. **Enable Gzip compression**
|
|
7. **Minimize and combine assets**
|
|
8. **Use async processing for heavy tasks**
|
|
9. **Implement lazy loading**
|
|
10. **Monitor and profile regularly** |