Une procédure plus approfondie des applications de suralimentation avec Blackfire

Blackfire.io: une plongée profonde dans le profilage des performances pour les applications PHP plus rapides

Personne ne bénéficie des applications lentes et lourdes, en particulier lorsqu'il s'agit de bases de données en expansion rapide et de millions de demandes quotidiennes. Le profilage offre une solution, fournissant des informations sur la consommation de ressources d'un programme (temps et mémoire). Cela permet l'identification et la résolution des goulots d'étranglement de performance. Il existe de nombreux outils de profilage, chacun utilisant différentes méthodologies.

Deux approches de profilage primaires sont l'échantillonnage et l'instrumentation. L'échantillonnage capture périodiquement des instantanés de la pile d'appels ou de la mémoire, un impact minimal sur les performances mais potentiellement des détails manquants. L'instrumentation, inversement, insère des instructions de profilage directement dans le code (manuellement ou automatiquement au niveau du bytecode), offrant des détails précis mais avec une plus grande surcharge de performances.

Blackfire.io se distingue. Ce profileur Web de nouvelle génération utilise une instrumentation automatique sans sacrifier les performances de l'application. Développé par Sensiolabs (créateurs du cadre Symfony), BlackFire permet des tests de performances continues sans nécessiter de modifications de code.

ACCESSIBLE via une interface Chrome Extension ou de ligne de commande, BlackFire est facilement intégré dans divers environnements, y compris Homestead. Ce tutoriel démontre l'utilisation de BlackFire dans la construction d'applications plus rapides dans une configuration améliorée de propriété.

Caractéristiques de clé:

• Instrumentation à impact zéro: Contrairement aux profileurs traditionnels, le feu noir ne ralentit pas votre application.
• Double interface: Profile Scripts PHP via l'extension Chrome ou l'outil de ligne de commande.
• Compatibilité large: Intégration transparente avec de nombreux fournisseurs de cloud et machines virtuelles, y compris Homestead.
• Architecture modulaire: comprend une sonde (extension PHP), un agent (démon côté serveur), une compagnie (extension chrome), un client (CLI) et une interface Web.
• Test continu: Gestion des performances proactives sans modifications de code.
• Visualisation détaillée: représente graphiquement les flux d'exécution et les métriques de performance pour une analyse effective du goulot d'étranglement.

PRENDRE:

Après avoir accédé à votre boîte Vagrant via vagrant ssh, créez un compte BlackFire (si vous n'en avez pas déjà). Récupérez vos informations d'identification (client et serveur) à partir de vos paramètres de profil de feu noir. Mettez à jour votre fichier homestead.yaml (situé dans le répertoire racine de votre boîte de vagabond) avec ces informations d'identification:

<code class="language-yaml">blackfire:
    - id: "Server Id here"
      token: "Server token here"
      client-id: "Client Id here"
      client-token: "Client token here"</code>

Architecture de feu noir:

Le feu noir comprend cinq composants centraux:

• sonde: Une extension PHP instrumentant l'application et la collecte de données de performances (Linux et macOS).
• Agent: Un démon d'agrégation et de transmission des informations sur le côté serveur à Blackfire.
• Companion: L'extension Google Chrome pour le profilage basé sur le navigateur.
• Client: L'équivalent en ligne de commande du compagnon.
• Interface Web: Un tableau de bord basé sur le Web pour visualiser et comparer les données de profil.

(la sonde, l'agent et le client sont préinstallés dans la propriété familiale améliorée.)

Terminologie essentielle:

• Profil de référence: Une mesure de base des performances de base pour la comparaison.
• Temps exclusif: Temps passé à exécuter une fonction, à l'exclusion des appels externes.
• Temps inclusif: Temps d'exécution total, y compris les appels externes.
• chemins chauds: les parties les plus actives de votre application pendant le profilage.

Profilage d'un script PHP:

Profitons un script impliquant des interactions de base de données. Pour des résultats réalistes, nous utiliserons Faker pour générer des données factices, en évitant d'inclure les frais généraux du Faker dans notre analyse principale.

1. Génération de données factices (userProviderjson.php):

<code class="language-php"><?php
require_once('vendor/autoload.php');

$num = isset($_GET['num']) ? $_GET['num'] : 1000;
$data = [];

$faker = Faker\Factory::create();

if(!file_exists('data')) {
    mkdir('data');
}

for ($i = 0; $i < $num; $i++) {
    $data[] = ['name' => $faker->name, 'email' => $faker->email, 'city' => $faker->city,];
}

file_put_contents('data/users.json', json_encode($data));

echo 'JSON file generated.';</code>

Exécutez ce script en utilisant php UserProviderJSON.php. Cela crée data/users.json.

2. Configuration de la base de données:

Créez une base de données MySQL (blackfire_tutorial) et la table (sample_users) avec des colonnes appropriées.

3. Script principal (benchmark-before.php):

<code class="language-php"><?php
$db = new PDO('mysql:host=localhost;dbname=blackfire_tutorial;charset=utf8', 'homestead', 'secret');

function SaveCustomers($db) {
    $users = json_decode(file_get_contents('data/users.json'), true);
    foreach ($users as $user) {
        $stmt = $db->prepare("INSERT INTO sample_users (name, email, city) VALUES (?, ?, ?)");
        $stmt->execute([$user['name'], $user['email'], $user['city']]);
    }
}

SaveCustomers($db);
echo 'Users imported successfully.';</code>

Accédez à ce script via son URL pour remplir la base de données.

4. Profil initial:

à l'aide de l'extension Chrome BlackFire, profil benchmark-before.php, créant un nouveau profil de référence.

L'interface Web BlackFire fournit une analyse détaillée: une barre d'outils résumant les mesures clés, un graphique d'appel visualisant le flux d'exécution, les listes de fonctions avec des informations de synchronisation détaillées et diverses mesures (requêtes SQL, utilisation de la mémoire, etc.).

5. Optimisation et reprofilage:

Optimiser le script pour réduire les appels de base de données (par exemple, en utilisant une seule instruction d'insertion avec plusieurs valeurs). Créez benchmark-after.php avec le code optimisé. Reprofile, comparant le profil de référence.

La comparaison met en évidence les améliorations des performances.

Interface de ligne de commande:

CLI de Blackfire (blackfire) permet le profilage via le terminal:

• Profilage de demandes HTTP: blackfire curl http://your-url
• Profil des scripts CLI: blackfire run php your-script.php
• Création d'un profil de référence: blackfire --new-reference curl http://your-url
• en comparant une référence: blackfire --reference=profile-id curl http://your-url

Tests de performance:

BlackFire (utilisateurs premium) permet de créer des tests de performances dans un fichier .blackfire.yml, définissant des affirmations sur diverses mesures.

Conclusion:

Blackfire.io est un outil puissant pour optimiser les performances de l'application PHP. Sa facilité d'utilisation, son analyse détaillée et ses capacités de test continu le rendent inestimable pour les développeurs qui cherchent des applications très performantes. Les FAQ fournies clarifient en outre ses capacités et ses avantages. N'oubliez pas de remplacer les valeurs d'espace réservé dans des exemples de code par votre ID de serveur, vos informations d'identification de la base de données réelles.

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!