{"id":15906,"date":"2025-12-08T18:23:46","date_gmt":"2025-12-08T17:23:46","guid":{"rendered":"https:\/\/webhosting.de\/php-opcache-konfiguration-performance-optimierung-cacheboost\/"},"modified":"2025-12-08T18:23:46","modified_gmt":"2025-12-08T17:23:46","slug":"php-opcache-configurazione-ottimizzazione-delle-prestazioni-cacheboost","status":"publish","type":"post","link":"https:\/\/webhosting.de\/it\/php-opcache-konfiguration-performance-optimierung-cacheboost\/","title":{"rendered":"PHP OPcache spiegato in dettaglio: come ottenere il massimo dalla cache"},"content":{"rendered":"<p>PHP OPcache accelera i miei script perch\u00e9 PHP compila il <strong>bytecode<\/strong> nella memoria, evitando cos\u00ec una nuova analisi. In questa guida vi mostrer\u00f2 come utilizzo OPcache. <strong>configurare<\/strong>, monitoro e ottimizzo affinch\u00e9 la vostra applicazione reagisca in modo sensibilmente pi\u00f9 rapido e assorba con facilit\u00e0 i picchi di carico.<\/p>\n\n<h2>Punti centrali<\/h2>\n\n<ul>\n  <li><strong>Cache bytecode<\/strong> riduce il carico della CPU e l'I\/O<\/li>\n  <li><strong>Parametri<\/strong> Come selezionare in modo mirato memory_consumption e max_accelerated_files<\/li>\n  <li><strong>Ambienti<\/strong> Impostazioni differenziate: Dev, Staging, Produzione<\/li>\n  <li><strong>Monitoraggio<\/strong> Utilizzare per Hitrate, occupazione, Evictions<\/li>\n  <li><strong>Distribuzione<\/strong> e cache flush perfettamente integrati<\/li>\n<\/ul>\n\n<h2>Ecco come funziona OPcache: bytecode invece di ricompilazione<\/h2>\n\n<p>Per ogni richiesta, PHP legge normalmente i file, analizza il codice e crea <strong>bytecode<\/strong>, eseguito dal motore Zend. OPcache interviene proprio qui e memorizza questo bytecode nella memoria condivisa, in modo che le richieste successive possano essere avviate direttamente dalla memoria. Ci\u00f2 riduce i cicli della CPU e gli accessi ai file, abbreviando notevolmente i tempi di risposta. In configurazioni tipiche, ottengo guadagni compresi tra il 30 e il 70 percento, a seconda del codice di base e del profilo di traffico. \u00c8 fondamentale che la cache rimanga sufficientemente grande e che gli script pi\u00f9 importanti rimangano permanentemente nella <strong>Memoria<\/strong> rimanere.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2025\/12\/php-opcache-workspace-7164.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Verificare e attivare OPcache su Linux, Windows e hosting condiviso<\/h2>\n\n<p>Comincio sempre dando un'occhiata a phpinfo() e cercando \u201eZend\". <strong>OPcache<\/strong>\u201c e chiavi come opcache.enable o opcache.memory_consumption. Su Linux attivo il modulo tramite il pacchetto php-opcache e un opcache.ini nella directory conf.d. Su Windows \u00e8 sufficiente inserire zend_extension=opcache nel file php.ini e riavviare il server web. Nell'hosting condiviso attivo spesso OPcache tramite un file php.ini personalizzato o tramite il menu clienti. In caso di colli di bottiglia controllo anche il <a href=\"https:\/\/webhosting.de\/it\/php-aumento-del-limite-di-memoria-evitare-errori-performante\/\">Aumentare il limite di memoria PHP<\/a>, affinch\u00e9 OPcache e PHP-FPM abbiano abbastanza <strong>Risorse<\/strong> ricevuto.<\/p>\n\n<h2>I pulsanti pi\u00f9 importanti spiegati in modo chiaro<\/h2>\n\n<p>Con opcache.enable attivo la cache per le richieste web, mentre opcache.enable_cli controlla l'utilizzo per i lavori CLI, il che \u00e8 utile per le code di lavoro. Il nucleo \u00e8 costituito da opcache.memory_consumption, che specifica la memoria condivisa disponibile in megabyte; una dimensione troppo ridotta porta a espulsioni e nuovi <strong>compilazioni<\/strong>. opcache.max_accelerated_files definisce quanti file possono essere memorizzati nella cache; questo valore dovrebbe superare in modo ragionevole il numero di file del progetto. Con opcache.validate_timestamps e opcache.revalidate_freq determino quanto rigorosamente OPcache controlla le modifiche ai file, da molto dinamico (sviluppo) a molto parsimonioso (produzione con flush manuale). Salvo i commenti con opcache.save_comments=1, perch\u00e9 molti strumenti su <strong>DocBlocks<\/strong> dipendono.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2025\/12\/php_opcache_meeting_7093.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Valori iniziali e profili a confronto<\/h2>\n\n<p>Per un avvio senza intoppi, mi affido a profili chiari per lo sviluppo, lo staging e la produzione. In questo modo ottengo da un lato cicli di feedback rapidi durante la codifica e dall'altro prestazioni affidabili durante il funzionamento live. \u00c8 importante verificare regolarmente questi valori iniziali confrontandoli con metriche reali e perfezionarli. Per le installazioni WordPress pi\u00f9 grandi, pianifico memoria e voci in modo generoso, perch\u00e9 i plugin e i temi occupano molto spazio. <strong>File<\/strong> . La tabella seguente riassume i valori iniziali significativi, che ho poi ottimizzato in base al tasso di successo e alle evictions.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th>Impostazione<\/th>\n      <th>Sviluppo<\/th>\n      <th>Staging\/Test<\/th>\n      <th>Produzione<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td>opcache.enable<\/td>\n      <td>1<\/td>\n      <td>1<\/td>\n      <td>1<\/td>\n    <\/tr>\n    <tr>\n      <td>opcache.enable_cli<\/td>\n      <td>0<\/td>\n      <td>0\u20131<\/td>\n      <td>1 (per lavori CLI)<\/td>\n    <\/tr>\n    <tr>\n      <td>opcache.memory_consumption<\/td>\n      <td>128\u2013256 MB<\/td>\n      <td>256\u2013512 MB<\/td>\n      <td>256\u2013512+ MB<\/td>\n    <\/tr>\n    <tr>\n      <td>opcache.interned_strings_buffer<\/td>\n      <td>16\u201332 MB<\/td>\n      <td>32\u201364 MB<\/td>\n      <td>16\u201364 MB<\/td>\n    <\/tr>\n    <tr>\n      <td>opcache.max_accelerated_files<\/td>\n      <td>8.000\u201310.000<\/td>\n      <td>10.000\u201320.000<\/td>\n      <td>10.000\u201320.000+<\/td>\n    <\/tr>\n    <tr>\n      <td>opcache.validate_timestamps<\/td>\n      <td>1<\/td>\n      <td>1<\/td>\n      <td>0\u20131 (a seconda della distribuzione)<\/td>\n    <\/tr>\n    <tr>\n      <td>opcache.revalidate_freq<\/td>\n      <td>0\u20132 s<\/td>\n      <td>60\u2013300 s<\/td>\n      <td>300+ s o 0 (con controllo manuale)<\/td>\n    <\/tr>\n    <tr>\n      <td>opcache.save_comments<\/td>\n      <td>1<\/td>\n      <td>1<\/td>\n      <td>1<\/td>\n    <\/tr>\n    <tr>\n      <td>opcache.fast_shutdown<\/td>\n      <td>1<\/td>\n      <td>1<\/td>\n      <td>1<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n<p>Questa matrice \u00e8 volutamente pragmatica, perch\u00e9 i progetti reali crescono in modo molto diverso. Parto da questi valori e poi osservo il tasso di successo, la quota occupata nella memoria condivisa e il verificarsi di evictions. Se noto segni di pressione, aumento prima opcache.memory_consumption con incrementi moderati. Successivamente, modifico opcache.max_accelerated_files fino a quando il numero di file non rientra comodamente. In questo modo, il <strong>Cache<\/strong> efficace e le richieste rimangono costanti.<\/p>\n\n<h2>Impostazioni in base all'ambiente: sviluppo, staging, produzione<\/h2>\n\n<p>Nello sviluppo \u00e8 importante ottenere un feedback rapido sulle modifiche al codice, quindi imposto validate_timestamps=1 e revalidate_freq su un valore molto basso o addirittura 0. Nella fase di staging verifico il carico realistico e imposto una memoria generosa, in modo che i risultati siano vicini al successivo funzionamento live. In produzione, aumento la frequenza di controllo o disattivo completamente i timestamp se il mio deployment svuota la cache in modo mirato. Per i worker basati su CLI, attivo enable_cli=1 in modo che anche i lavori ricorrenti possano essere eseguiti dal <strong>Cache bytecode<\/strong> . In questo modo, ogni ambiente genera esattamente il comportamento di cui ho bisogno, senza sorprese nei tempi di reazione.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2025\/12\/php-opcache-visualisierung-cache-9281.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Impostazioni avanzate che spesso fanno la differenza<\/h2>\n\n<p>Oltre ai parametri di base, ci sono interruttori che mi consentono di aumentare la stabilit\u00e0 e la sicurezza e ridurre al minimo gli effetti collaterali:<\/p>\n\n<ul>\n  <li>opcache.max_wasted_percentage: definisce a partire da quale grado di frammentazione OPcache avvia una ricostruzione interna della memoria. In caso di codici base molto variabili, riduco leggermente il valore per avere meno memoria \u201eframmentata\u201c.<\/li>\n  <li>opcache.force_restart_timeout: intervallo di tempo in secondi dopo il quale OPcache esegue un riavvio forzato quando \u00e8 necessario un riavvio ma i processi sono ancora attivi. Ci\u00f2 impedisce lunghi periodi di stallo.<\/li>\n  <li>opcache.file_update_protection: finestra di protezione in secondi durante la quale i file appena modificati non vengono immediatamente memorizzati nella cache. Questo aiuta a evitare file scritti solo a met\u00e0 durante le distribuzioni o sulle unit\u00e0 di rete.<\/li>\n  <li>opcache.restrict_api: limita quali script possono richiamare opcache_reset() e le funzioni di stato. In produzione lo imposto in modo rigoroso, in modo che solo gli endpoint di amministrazione abbiano accesso.<\/li>\n  <li>opcache.blacklist_filename: file in cui gestisco i modelli esclusi dalla cache (ad es. generatori altamente dinamici). Ci\u00f2 consente di risparmiare spazio per script pi\u00f9 critici.<\/li>\n  <li>opcache.validate_permission e opcache.validate_root: attivi quando sono presenti pi\u00f9 utenti\/chroot. In questo modo PHP impedisce che il codice memorizzato nella cache di un contesto venga utilizzato senza autorizzazione in un altro contesto.<\/li>\n  <li>opcache.use_cwd e opcache.revalidate_path: controllo del modo in cui OPcache identifica gli script quando i percorsi vengono integrati tramite diverse directory di lavoro\/collegamenti simbolici. Nel caso dei collegamenti simbolici di rilascio, testo questi valori in modo mirato per evitare doppie cache.<\/li>\n  <li>opcache.cache_id: se pi\u00f9 host virtuali condividono lo stesso SHM (raro), separo le cache in modo netto tramite un ID univoco.<\/li>\n  <li>opcache.optimization_level: di solito lo lascio su Standard. Solo nei casi limite di debug riduco temporaneamente i passaggi di ottimizzazione.<\/li>\n<\/ul>\n\n<h2>Precaricamento: mantenere il codice permanentemente in memoria<\/h2>\n\n<p>Con PHP 7.4+ posso caricare e collegare file centrali del framework o del progetto all'avvio del server tramite opcache.preload e opcache.preload_user. Il vantaggio: le classi sono disponibili senza autoload hit e gli hot path sono immediatamente disponibili. Alcune regole pratiche:<\/p>\n\n<ul>\n  <li>Il precaricamento \u00e8 particolarmente utile per codici di base grandi e stabili (ad esempio Symfony, librerie core proprietarie). Con WordPress lo utilizzo con cautela, perch\u00e9 il core e i plugin vengono aggiornati pi\u00f9 frequentemente.<\/li>\n  <li>Un file di precaricamento contiene chiamate mirate a opcache_compile_file() o integra un autoloader che carica le classi definite. <em>in anticipo<\/em> carica.<\/li>\n  <li>Ogni modifica al codice dei file rilevanti per il precaricamento richiede un riavvio di PHP-FPM affinch\u00e9 il precaricamento venga ricostruito. Lo integro nei deploy.<\/li>\n  <li>Misuro l'effetto separatamente: non tutti i codici ne traggono vantaggio; il precaricamento consuma memoria condivisa aggiuntiva.<\/li>\n<\/ul>\n\n<h2>JIT e OPcache: vantaggi, limiti, requisiti di memoria<\/h2>\n\n<p>Da PHP 8 esiste il compilatore Just-In-Time (JIT), controllato tramite OPcache (opcache.jit, opcache.jit_buffer_size). Per i tipici carichi di lavoro web con carico I\/O e database, il JIT spesso non apporta grandi vantaggi. In caso di codice con carico CPU elevato (ad es. elaborazione di immagini\/dati), pu\u00f2 essere di notevole aiuto. Io procedo in questo modo:<\/p>\n\n<ul>\n  <li>Attivo JIT in modo conservativo e misuro le metriche degli utenti reali e i profili della CPU. L'attivazione cieca aumenta il fabbisogno di memoria e pu\u00f2 causare casi limite.<\/li>\n  <li>Dimensiono il buffer JIT in base ai percorsi che richiedono un carico elevato della CPU. I buffer troppo piccoli non apportano alcun valore aggiunto, quelli troppo grandi sostituiscono il bytecode.<\/li>\n  <li>Se il tasso di hit o l'occupazione SHM ne risentono, do la priorit\u00e0 a OPcache rispetto a JIT. La cache bytecode \u00e8 lo strumento pi\u00f9 importante per la maggior parte dei siti.<\/li>\n<\/ul>\n\n<h2>Percorsi dei file, collegamenti simbolici e strategie di distribuzione sicure<\/h2>\n\n<p>OPcache \u00e8 basato sul percorso. Per questo motivo mi concentro sulla strategia di implementazione:<\/p>\n\n<ul>\n  <li>Rilasci atomici tramite symlink (ad es. \/releases\/123 -&gt; \/current): pulito, ma attenzione a opcache.use_cwd e al comportamento di realpath. Evito le cache duplicate facendo in modo che tutti i worker vedano lo stesso percorso reale in modo coerente.<\/li>\n  <li>Con validate_timestamps=0, la cache deve <em>ovunque<\/em> Svuotare: dopo la commutazione, eseguo il flush di OPcache in modo mirato su tutti gli host\/pod e riavvio PHP-FPM in modo controllato.<\/li>\n  <li>realpath_cache_size e realpath_cache_ttl li coordino con OPcache, in modo che le ricerche dei file rimangano veloci e stabili.<\/li>\n  <li>Sulle unit\u00e0 di rete (NFS\/SMB) aumento file_update_protection e configuro le distribuzioni in modo che i file vengano sostituiti in modo atomico.<\/li>\n<\/ul>\n\n<p>Per riavvii molto rapidi, utilizzo spesso una procedura in due fasi: prima il riscaldamento in background, poi un breve ricaricamento coordinato di tutti i worker, in modo che il primo traffico live trovi gi\u00e0 una cache calda.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2025\/12\/php-opcache-workspace-5931.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Cache dei file, riscaldamento e priming<\/h2>\n\n<p>Oltre alla memoria condivisa, OPcache pu\u00f2 scrivere il bytecode sul disco (opcache.file_cache). Ci\u00f2 \u00e8 utile in scenari particolari:<\/p>\n\n<ul>\n  <li>Negli ambienti container, \u00e8 possibile utilizzare una cache di file <em>tra<\/em> I riavvii FPM riducono i tempi di ricompilazione, a condizione che lo storage sia veloce.<\/li>\n  <li>Utilizzo opcache.file_cache con cautela: su file system lenti o distribuiti \u00e8 poco utile e aumenta la complessit\u00e0.<\/li>\n  <li>opcache.file_cache_only \u00e8 un caso speciale per ambienti senza SHM, poco utilizzato nelle configurazioni orientate alle prestazioni.<\/li>\n<\/ul>\n\n<p>Per il riscaldamento mi preparo dei piccoli \u201eprimer\u201c:<\/p>\n\n<ul>\n  <li>Uno script CLI chiama opcache_compile_file() per i file caldi, ad esempio autoloader, classi framework centrali, helper di grandi dimensioni.<\/li>\n  <li>Un crawler visita i percorsi principali (homepage, login, checkout) in modo che il bytecode e le cache a valle siano pronti in tempo.<\/li>\n  <li>Programmo i warmup in modo che siano pronti poco prima del passaggio alla nuova versione.<\/li>\n<\/ul>\n\n<h2>OPcache nello stack: PHP-FPM, cache oggetti e cache pagine<\/h2>\n\n<p>OPcache mostra tutta la sua potenza soprattutto in combinazione con PHP-FPM, una configurazione di processo pulita e livelli di cache aggiuntivi. Con WordPress lo combino con una cache di oggetti (ad esempio Redis) e una cache di pagine, in modo da alleggerire il carico sul database e sul rendering. A tal fine prendo in considerazione la <a href=\"https:\/\/webhosting.de\/it\/php-single-thread-performance-wordpress-hosting-velocity\/\">Prestazioni single-thread<\/a>, perch\u00e9 le richieste PHP dipendono fortemente dai singoli core della CPU. Se tuttavia si verifica un sovraccarico, distribuisco il carico tramite PHP-FPM-Worker, senza selezionare una memoria condivisa di OPcache troppo piccola. In questo modo utilizzo il <strong>Pila<\/strong> completa, invece di limitarsi a regolare una sola vite.<\/p>\n\n<h2>Errori frequenti e controlli rapidi<\/h2>\n\n<p>Una cache troppo piccola causa eviction, che posso riconoscere nello stato OPcache o phpinfo(). Se ci\u00f2 si verifica, aumento gradualmente opcache.memory_consumption e controllo l'effetto tramite il tasso di successo. Se i file rimangono non accelerati, imposto opcache.max_accelerated_files su un valore superiore alla quantit\u00e0 effettiva di file nel progetto. In caso di problemi di distribuzione, controllo validate_timestamps: con 0, il vecchio bytecode rimane attivo fino a quando non svuoto esplicitamente la cache. Strumenti come Doctrine richiedono DocBlocks, quindi lascio save_comments=1 per <strong>Errore<\/strong> evitando l'assenza di annotazioni.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2025\/12\/php_opcache_nachtarbeit_4382.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Monitorare e interpretare OPcache<\/h2>\n\n<p>Misuro il tasso di successo e cerco di mantenere valori vicini al 100%, in modo che le richieste partano quasi sempre dalla cache. Inoltre, osservo l'utilizzo della memoria e il numero di evictions per individuare tempestivamente eventuali colli di bottiglia. Con opcache_get_status() creo piccoli dashboard o alimenti soluzioni di monitoraggio esistenti. In questo modo posso vedere immediatamente le tendenze dei cambiamenti dopo il rilascio di nuove versioni o aggiornamenti dei plugin. Con queste metriche posso prendere decisioni informate. <strong>Decisioni<\/strong> e adatto solo ci\u00f2 che \u00e8 veramente necessario.<\/p>\n\n<p>Linee guida concrete che hanno dato buoni risultati:<\/p>\n\n<ul>\n  <li>Tasso di successo &gt; 99 % sotto carico normale e di picco; al di sotto di questo valore controllo la distribuzione dei file e il riscaldamento.<\/li>\n  <li>Percentuale SHM libera costante &gt; 5\u201310 %; altrimenti ridimensiono la memoria.<\/li>\n  <li>Evictions nel tempo: picchi occasionali dopo il deploy sono accettabili; evictions continui indicano un sottodimensionamento o una forte frammentazione.<\/li>\n  <li>Tenere d'occhio la memoria sprecata: se raggiunge il limite, pianificare una ricostruzione controllata dell'OPcache (ad esempio durante le finestre di manutenzione).<\/li>\n<\/ul>\n\n<h2>Esempio: configurazione WordPress con traffico elevato<\/h2>\n\n<p>Per i siti WordPress di grandi dimensioni, seleziono opcache.enable=1 e opcache.enable_cli=1, in modo che anche i CLI worker possano trarne vantaggio. Impostiamo la memoria condivisa su 384 MB o pi\u00f9 se sono coinvolti molti plugin e un tema ricco di funzionalit\u00e0. Aumento opcache.interned_strings_buffer a 64 MB, perch\u00e9 molti nomi di classi e funzioni ricorrono in tutte le richieste. Per ambienti estremamente performanti, imposto validate_timestamps=0 e revalidate_freq=0, ma svuoto la cache subito dopo ogni rilascio. \u00c8 importante progettare le implementazioni in modo che non rimangano vecchi <strong>bytecode<\/strong> rimane in circolazione.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2025\/12\/php_opcache_schreibtisch_4827.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Flusso di lavoro pratico per la messa a punto e le implementazioni<\/h2>\n\n<p>Lavoro secondo cicli fissi: misurare, modificare, controllare. Per prima cosa salvo i valori di stato come hit rate, occupazione ed eviction, poi regolo un parametro e misuro nuovamente. Prima di un rilascio, con i timestamp disattivati, cancello in modo mirato l'OPcache, tramite il riavvio di PHP-FPM o un piccolo script. Successivamente controllo i picchi di carico con traffico reale o benchmark rappresentativi. Se si verifica un comportamento anomalo, controllo anche <a href=\"https:\/\/webhosting.de\/it\/frammentazione-della-memoria-web-hosting-php-mysql-ottimizzazione-flusso-di-byte\/\">Frammentazione della memoria<\/a>, perch\u00e9 riducono lo spazio utilizzabile <strong>Condiviso<\/strong> La memoria diminuisce.<\/p>\n\n<p>Alcune routine aggiuntive che hanno dato buoni risultati nei team:<\/p>\n\n<ul>\n  <li>Versioni delle modifiche ai parametri: opcache.ini nel repository, modifiche tramite pull request e changelog.<\/li>\n  <li>Canary Deploy: solo una parte dei worker\/pod carica le nuove versioni e crea la cache, quindi il rollout viene eseguito su tutte le istanze.<\/li>\n  <li>Pulsante di emergenza: un endpoint amministrativo interno con accesso sicuro che consente opcache_reset() e chiamate opcache_invalidate() mirate, in combinazione con opcache.restrict_api.<\/li>\n  <li>Stimare l'ordine di grandezza: come regola empirica approssimativa, calcolo inizialmente 1-2 MB di OPcache per ogni 100-200 file PHP e poi lo adeguo in base alle metriche reali. Per WordPress con molti plugin aggiungo un buffer.<\/li>\n<\/ul>\n\n<h2>Riassumendo brevemente<\/h2>\n\n<p>OPcache velocizza le applicazioni PHP compilando il codice PHP. <strong>bytecode<\/strong> nella RAM. Con impostazioni adeguate per la memoria, il numero di file e la strategia di timestamp, \u00e8 possibile ottenere tempi di risposta costantemente brevi. Assicuratevi che sia coordinato con PHP-FPM e altri livelli di cache, in modo che l'intero stack funzioni correttamente. Monitorate il tasso di successo, l'occupazione e le espulsioni, in modo da poter apportare modifiche mirate. In questo modo vi assicurate prestazioni elevate e affidabilit\u00e0. <strong>Piattaforma<\/strong> per carichi elevati e crescita.<\/p>","protected":false},"excerpt":{"rendered":"<p>Impara a configurare correttamente PHP OPcache e ad aumentare significativamente le prestazioni delle tue applicazioni con un'ottimizzazione mirata di php opcache.<\/p>","protected":false},"author":1,"featured_media":15899,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[780],"tags":[],"class_list":["post-15906","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-administration-anleitungen"],"acf":[],"_wp_attached_file":null,"_wp_attachment_metadata":null,"litespeed-optimize-size":null,"litespeed-optimize-set":null,"_elementor_source_image_hash":null,"_wp_attachment_image_alt":null,"stockpack_author_name":null,"stockpack_author_url":null,"stockpack_provider":null,"stockpack_image_url":null,"stockpack_license":null,"stockpack_license_url":null,"stockpack_modification":null,"color":null,"original_id":null,"original_url":null,"original_link":null,"unsplash_location":null,"unsplash_sponsor":null,"unsplash_exif":null,"unsplash_attachment_metadata":null,"_elementor_is_screenshot":null,"surfer_file_name":null,"surfer_file_original_url":null,"envato_tk_source_kit":null,"envato_tk_source_index":null,"envato_tk_manifest":null,"envato_tk_folder_name":null,"envato_tk_builder":null,"envato_elements_download_event":null,"_menu_item_type":null,"_menu_item_menu_item_parent":null,"_menu_item_object_id":null,"_menu_item_object":null,"_menu_item_target":null,"_menu_item_classes":null,"_menu_item_xfn":null,"_menu_item_url":null,"_trp_menu_languages":null,"rank_math_primary_category":null,"rank_math_title":null,"inline_featured_image":null,"_yoast_wpseo_primary_category":null,"rank_math_schema_blogposting":null,"rank_math_schema_videoobject":null,"_oembed_049c719bc4a9f89deaead66a7da9fddc":null,"_oembed_time_049c719bc4a9f89deaead66a7da9fddc":null,"_yoast_wpseo_focuskw":null,"_yoast_wpseo_linkdex":null,"_oembed_27e3473bf8bec795fbeb3a9d38489348":null,"_oembed_c3b0f6959478faf92a1f343d8f96b19e":null,"_trp_translated_slug_en_us":null,"_wp_desired_post_slug":null,"_yoast_wpseo_title":null,"tldname":null,"tldpreis":null,"tldrubrik":null,"tldpolicylink":null,"tldsize":null,"tldregistrierungsdauer":null,"tldtransfer":null,"tldwhoisprivacy":null,"tldregistrarchange":null,"tldregistrantchange":null,"tldwhoisupdate":null,"tldnameserverupdate":null,"tlddeletesofort":null,"tlddeleteexpire":null,"tldumlaute":null,"tldrestore":null,"tldsubcategory":null,"tldbildname":null,"tldbildurl":null,"tldclean":null,"tldcategory":null,"tldpolicy":null,"tldbesonderheiten":null,"tld_bedeutung":null,"_oembed_d167040d816d8f94c072940c8009f5f8":null,"_oembed_b0a0fa59ef14f8870da2c63f2027d064":null,"_oembed_4792fa4dfb2a8f09ab950a73b7f313ba":null,"_oembed_33ceb1fe54a8ab775d9410abf699878d":null,"_oembed_fd7014d14d919b45ec004937c0db9335":null,"_oembed_21a029d076783ec3e8042698c351bd7e":null,"_oembed_be5ea8a0c7b18e658f08cc571a909452":null,"_oembed_a9ca7a298b19f9b48ec5914e010294d2":null,"_oembed_f8db6b27d08a2bb1f920e7647808899a":null,"_oembed_168ebde5096e77d8a89326519af9e022":null,"_oembed_cdb76f1b345b42743edfe25481b6f98f":null,"_oembed_87b0613611ae54e86e8864265404b0a1":null,"_oembed_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_oembed_time_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_tldname":null,"_tldclean":null,"_tldpreis":null,"_tldcategory":null,"_tldsubcategory":null,"_tldpolicy":null,"_tldpolicylink":null,"_tldsize":null,"_tldregistrierungsdauer":null,"_tldtransfer":null,"_tldwhoisprivacy":null,"_tldregistrarchange":null,"_tldregistrantchange":null,"_tldwhoisupdate":null,"_tldnameserverupdate":null,"_tlddeletesofort":null,"_tlddeleteexpire":null,"_tldumlaute":null,"_tldrestore":null,"_tldbildname":null,"_tldbildurl":null,"_tld_bedeutung":null,"_tldbesonderheiten":null,"_oembed_ad96e4112edb9f8ffa35731d4098bc6b":null,"_oembed_8357e2b8a2575c74ed5978f262a10126":null,"_oembed_3d5fea5103dd0d22ec5d6a33eff7f863":null,"_eael_widget_elements":null,"_oembed_0d8a206f09633e3d62b95a15a4dd0487":null,"_oembed_time_0d8a206f09633e3d62b95a15a4dd0487":null,"_aioseo_description":null,"_eb_attr":null,"_eb_data_table":null,"_oembed_819a879e7da16dd629cfd15a97334c8a":null,"_oembed_time_819a879e7da16dd629cfd15a97334c8a":null,"_acf_changed":null,"_wpcode_auto_insert":null,"_edit_last":null,"_edit_lock":null,"_oembed_e7b913c6c84084ed9702cb4feb012ddd":null,"_oembed_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_time_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_03514b67990db061d7c4672de26dc514":null,"_oembed_time_03514b67990db061d7c4672de26dc514":null,"rank_math_news_sitemap_robots":null,"rank_math_robots":null,"_eael_post_view_count":"2860","_trp_automatically_translated_slug_ru_ru":null,"_trp_automatically_translated_slug_et":null,"_trp_automatically_translated_slug_lv":null,"_trp_automatically_translated_slug_fr_fr":null,"_trp_automatically_translated_slug_en_us":null,"_wp_old_slug":null,"_trp_automatically_translated_slug_da_dk":null,"_trp_automatically_translated_slug_pl_pl":null,"_trp_automatically_translated_slug_es_es":null,"_trp_automatically_translated_slug_hu_hu":null,"_trp_automatically_translated_slug_fi":null,"_trp_automatically_translated_slug_ja":null,"_trp_automatically_translated_slug_lt_lt":null,"_elementor_edit_mode":null,"_elementor_template_type":null,"_elementor_version":null,"_elementor_pro_version":null,"_wp_page_template":null,"_elementor_page_settings":null,"_elementor_data":null,"_elementor_css":null,"_elementor_conditions":null,"_happyaddons_elements_cache":null,"_oembed_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_time_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_time_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_59808117857ddf57e478a31d79f76e4d":null,"_oembed_time_59808117857ddf57e478a31d79f76e4d":null,"_oembed_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_time_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_81002f7ee3604f645db4ebcfd1912acf":null,"_oembed_time_81002f7ee3604f645db4ebcfd1912acf":null,"_elementor_screenshot":null,"_oembed_7ea3429961cf98fa85da9747683af827":null,"_oembed_time_7ea3429961cf98fa85da9747683af827":null,"_elementor_controls_usage":null,"_elementor_page_assets":null,"_elementor_screenshot_failed":null,"theplus_transient_widgets":null,"_eael_custom_js":null,"_wp_old_date":null,"_trp_automatically_translated_slug_it_it":null,"_trp_automatically_translated_slug_pt_pt":null,"_trp_automatically_translated_slug_zh_cn":null,"_trp_automatically_translated_slug_nl_nl":null,"_trp_automatically_translated_slug_pt_br":null,"_trp_automatically_translated_slug_sv_se":null,"rank_math_analytic_object_id":null,"rank_math_internal_links_processed":"1","_trp_automatically_translated_slug_ro_ro":null,"_trp_automatically_translated_slug_sk_sk":null,"_trp_automatically_translated_slug_bg_bg":null,"_trp_automatically_translated_slug_sl_si":null,"litespeed_vpi_list":null,"litespeed_vpi_list_mobile":null,"rank_math_seo_score":null,"rank_math_contentai_score":null,"ilj_limitincominglinks":null,"ilj_maxincominglinks":null,"ilj_limitoutgoinglinks":null,"ilj_maxoutgoinglinks":null,"ilj_limitlinksperparagraph":null,"ilj_linksperparagraph":null,"ilj_blacklistdefinition":null,"ilj_linkdefinition":null,"_eb_reusable_block_ids":null,"rank_math_focus_keyword":"PHP OPcache","rank_math_og_content_image":null,"_yoast_wpseo_metadesc":null,"_yoast_wpseo_content_score":null,"_yoast_wpseo_focuskeywords":null,"_yoast_wpseo_keywordsynonyms":null,"_yoast_wpseo_estimated-reading-time-minutes":null,"rank_math_description":null,"surfer_last_post_update":null,"surfer_last_post_update_direction":null,"surfer_keywords":null,"surfer_location":null,"surfer_draft_id":null,"surfer_permalink_hash":null,"surfer_scrape_ready":null,"_thumbnail_id":"15899","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/posts\/15906","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/comments?post=15906"}],"version-history":[{"count":0,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/posts\/15906\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/media\/15899"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/media?parent=15906"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/categories?post=15906"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/tags?post=15906"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}