Salesforce Limites du gouverneur expliquées

Les limites du gouverneur de Salesforce sont cruciales pour maintenir la stabilité et l'efficacité de Salesforce. Étant donné que Salesforce (et Apex) fonctionnent dans un environnement multitenant avec des ressources partagées, les limites du gouverneur servent à garantir qu'aucun utilisateur ne consomme toutes les ressources, ce qui permet à la plateforme de rester équitable et réactive pour tout le monde.

Cet article vous aidera à comprendre quelles sont ces limites et comment les respecter efficacement.

Définition :

Un gouverneur Salesforce est un mécanisme du système Salesforce qui impose des limites spécifiques à l'utilisation des ressources. Il s'agit d'un point de contrôle qui assure une distribution équitable des ressources du système.

Rôle :

Les gouverneurs empêchent tout locataire de monopoliser les ressources. L'environnement Salesforce reste ainsi stable et efficace pour tous les utilisateurs.

Les limites du gouverneur SFDC sont les restrictions spécifiques appliquées par Salesforce pour maintenir les performances et la sécurité du système.

Considérez les limites imposées par le gouverneur dans Salesforce comme les règles d'emprunt dans une bibliothèque. La bibliothèque vous permet d'emprunter un certain nombre de livres (ressources) à la fois afin de garantir l'accès de tous. Chaque opération dans Salesforce revient à emprunter un livre. Le nombre de livres (interrogations, Déclarations DML) que vous pouvez emprunter pour garantir une utilisation et une disponibilité équitables de son contenu.

 ➡️ Veuillez noter que les limites du gouverneur Salesforce n'incluent pas le stockage.
Pour plus d'informations sur les limites de données et de stockage du Salesforce, consultez nos autres articles
Salesforce Data : Réduire les coûts et renforcer la conformité et Salesforce Dépassement de la limite de stockage.

Les limites d'appels à l'API dépassent également le cadre de cet article, mais sachez qu'il existe une limite quotidienne d'appels à l'API. Cette limite varie en fonction du type d'organisation et de la licence. Vous pouvez vérifier les limites de l'API Salesforce (de manière programmatique) en utilisant la commande Classe OrgLimits. Plus d'informations sur le Limites et allocations des requêtes API article.

Limites des requêtes SOQL :

• L'erreur "Too Many SOQL Queries" (trop de requêtes SOQL) se produit lorsque le nombre maximum de requêtes SOQL exécutées dans une seule transaction est dépassé. Dans une requête SOQL avec sous-requêtes parent-enfantChaque relation parent-enfant compte pour une requête supplémentaire.
• Nombre maximum de requêtes : 100 (synchrone), 200 (asynchrone).

Limites des lignes de résultats :

• L'erreur "Too many Query rows" se produit lorsque les requêtes d'une même transaction renvoient un nombre de lignes supérieur au nombre autorisé.
• Nombre maximum de lignes de la requête : 50 000

Limites des instructions DML :

• L'erreur "Too many DML statements" se produit lorsque le nombre d'opérations DML exécutées au cours d'une même transaction est supérieur au nombre autorisé.
• Opérations DML maximales : 150 (synchrone), 300 (asynchrone).

Limites de taille du tas :

• L'erreur "Apex heap size too large" se produit lorsque trop de données sont stockées en mémoire pendant le traitement.
• Taille maximale du tas : 6 Mo (synchrone), 12 Mo (asynchrone).

Limites de temps de l'unité centrale :

• L'erreur "Apex CPU time limit exceeded" signifie que votre transaction a duré trop longtemps, dépassant le temps maximum de l'unité centrale.
• Temps maximum de l'unité centrale : 10 000 ms (synchrone), 60 000 ms (asynchrone).

Pour d'autres types de limites du gouverneur, consultez la rubrique Guide du développeur Apex.

Les développeurs sont souvent confrontés à l'exception "101 Too Many SOQL Queries" (101 trop de requêtes SOQL). Cette erreur se produit lorsque plus de 100 requêtes SOQL sont exécutées dans une seule transaction (en mode synchrone).

Exemple : Prenons l'exemple de l'extrait de code suivant qui tente de récupérer les détails d'un compte à l'intérieur d'une boucle :

public class AccountProcessor {

    public void processAccounts() {

        List comptes = [SELECT Id, Nom FROM Compte] ;

        for (Account acc : accounts) {

        // Cette requête à l'intérieur d'une boucle peut facilement dépasser la limite SOQL s'il y a beaucoup de comptes.

            List contacts = [SELECT Id, Name FROM Contact WHERE AccountId = :acc.Id] ;

            // Contacts de traitement

        }

    }

}

Ce code atteindra rapidement la limite de 101 requêtes SOQL si le nombre de comptes est supérieur à 100.

Solution : Une meilleure approche consisterait à regrouper les requêtes :

public class AccountProcessor {

    public void processAccounts() {

        List comptes = [SELECT Id, Nom FROM Compte] ;

        Set accountIds = new Set() ;

        for (Account acc : accounts) {

            accountIds.add(acc.Id) ;

        }

        List contacts = [SELECT Id, Nom, AccountId FROM Contact WHERE AccountId IN :accountIds] ;

        Map<Id, List> accountContactsMap = new Map<Id, List>() ;

        for (Contact con : contacts) {

            if (!accountContactsMap.containsKey(con.AccountId)) {

                accountContactsMap.put(con.AccountId, new List()) ;

            }

            accountContactsMap.get(con.AccountId).add(con) ;

        }


        for (Account acc : accounts) {

            List acctContacts = accountContactsMap.get(acc.Id) ;

            // Contacts de traitement

        }

    }

}

Ce code remanié est peut-être un peu plus long, mais il récupère tous les contacts liés en une seule requête, évitant ainsi la limite SOQL.

L'exception de la limite du gouverneur "101 Too Many SOQL Queries" est également fréquente lors du téléchargement de fichiers, lorsque vous utilisez une requête pour télécharger chaque fichier.

Il est essentiel de surveiller l'utilisation de vos ressources pour vous assurer que vous n'atteignez pas ces limites. Pour cela, vous devez utiliser la console de développement Salesforce.

Si vous constatez l'une des erreurs mentionnées précédemment, les journaux de débogage peuvent vous aider. Le Salesforce fournit également un Limites classe et des méthodes intégrées telles que

• getQueries() ;
• getDML() ;
  Renvoie le nombre d'enregistrements qui ont été traités à l'aide d'une instruction qui est prise en compte dans les limites DML.

Les causes les plus courantes des erreurs de limite du gouverneur sont les suivantes :

• Avoir des requêtes et des opérations dans les boucles : Évitez les opérations DML et les requêtes à l'intérieur des boucles.
• Mauvaise gestion des erreurs : Mettre en œuvre une gestion appropriée des exceptions afin d'éviter les erreurs de limite inattendues.

Pour rester dans les limites fixées, suivez ces bonnes pratiques :

Recherche efficace :

• Essayez de récupérer toutes les données nécessaires en une seule requête plutôt que dans une boucle. Si une boucle est nécessaire, utilisez les boucles for de SOQL. Si le problème vient du fait que le jeu de résultats contient trop de lignes, utilisez les fonctions Limiter et Filtrer dans vos requêtes.

Traitement en vrac :

• Utiliser des méthodes de traitement en masse et des modèles de conception. Combiner des enregistrements dans des collections et effectuer des opérations DML en masse.

Utilisation des collections :

• Réduire les opérations DML en utilisant des collections.

Optimisation du code :

• Écrire un code efficace et optimisé. Éviter les boucles inutiles et utiliser des algorithmes efficaces.

Transactions en vigueur :

• Optez pour un traitement asynchrone pour gérer les opérations à grande échelle.

La gestion de gros volumes de données nécessite des stratégies telles que le traitement asynchrone, le traitement par lots et la mise en file d'attente des tâches.

Utilisation Méthodes futures, Batch Apexet Apex en file d'attente pour effectuer des opérations de grande envergure sans dépasser les différentes limites.

Les limites du gouverneur garantissent une utilisation équitable des ressources dans l'architecture multilocataire de Salesforce. En comprenant ce que sont ces limites et comment elles fonctionnent, vous pouvez éviter les erreurs et optimiser les performances de votre application.

Nous avons abordé les principaux types de limites imposées par le gouverneur, comme les limites des requêtes SOQL, les limites des instructions DML, la taille du tas et les limites de temps de l'unité centrale. Nous avons également montré comment surveiller ces limites à l'aide de la console du développeur et de la classe OrgLimits. Il est important de suivre les meilleures pratiques telles que les requêtes efficaces, le traitement en masse et le traitement asynchrone pour ne pas dépasser ces limites.

Par exemple, la décomposition des transactions de données volumineuses à l'aide de Batch Apex ou de Queueable Apex peut aider à gérer et à optimiser l'utilisation des ressources. De même, la compréhension des pièges tels que l'exécution de requêtes ou d'opérations DML dans des boucles permet d'éviter les erreurs courantes.

N'oubliez pas qu'un code efficace et une bonne gestion des ressources permettent non seulement d'atténuer les risques de dépassement des limites, mais aussi de garantir le bon fonctionnement de tous les utilisateurs partageant l'environnement Salesforce.

1. Quelles sont les limites du gouverneur Salesforce ?
• Les limites du gouverneur sont des restrictions que le Salesforce applique pour gérer les ressources du système.
2. Pourquoi Salesforce applique-t-il les limites du gouverneur ?
• Ils garantissent une utilisation équitable des ressources et maintiennent les performances du système.
3. Comment puis-je vérifier si je m'approche des limites du gouverneur ?
• Utilisez la console de développement Salesforce et des outils tels que le logiciel Limites pour en contrôler l'utilisation.
4. Que se passe-t-il si je dépasse la limite fixée par le gouverneur ?
• Le dépassement d'une limite entraîne des erreurs et l'échec des transactions.
5. Puis-je contourner les limites du gouverneur du Salesforce ?
• Les limites sont strictement appliquées, mais vous pouvez modifier votre code pour travailler dans les limites existantes, comme le montre cet exemple. exemple.