F5 BIG-IP : licence, modules et provisionnement
Distinguer droits de licence, activation et allocation de ressources avant de provisionner un module BIG-IP ou préparer une mise à jour.
Distinguer droits de licence, activation et allocation de ressources avant de provisionner un module BIG-IP ou préparer une mise à jour.
Séparer l’administration F5OS du tenant BIG-IP, choisir une image compatible et préparer ressources, VLAN, sauvegardes et mise à jour.
Relier symptômes, chronologie, configuration et diagnostics iHealth pour préparer un dossier de support F5 exploitable.
Comprendre la configuration effective de NGINX, les contextes main, events et http, les includes et les limites de l’héritage.
Relier les identités des processus NGINX aux accès aux fichiers statiques, journaux, caches et clés privées, sans ouvrir les permissions inutilement.
Suivre la sélection d’un hôte et d’une location pour expliquer la publication de fichiers, les index et les erreurs 403 ou 404.
Comprendre proxy_pass, les en-têtes transmis ou retournés et la vérification TLS du serveur upstream dans un reverse proxy NGINX.
Choisir une méthode de répartition NGINX Open Source et comprendre les échecs passifs, retries, connexions keepalive et retrait d’un serveur.
Comprendre la clé de cache, la durée de validité et les exclusions pour éviter de partager une réponse personnalisée entre utilisateurs.
Distinguer limitation de requêtes, concurrence et débit, choisir la bonne clé et comprendre les zones mémoire partagées entre workers.
Choisir une restriction réseau ou une authentification HTTP et vérifier l’accès aux URI sans confondre identité et adresse IP.
Construire des traces utiles et distinguer erreur de sélection HTTP, refus local, réponse upstream et timeout dans NGINX.
Comprendre la terminaison TLS, les certificats, le SNI et les deux côtés d’un proxy HTTPS, avec une recette qui conserve la validation.
Distinguer fichier modifié, test syntaxique, rechargement et comportement effectivement servi par les workers NGINX.
Distinguer proxy de transport, copie HTTP en sous-requête et routage d’API dans NGINX Open Source, avec leurs limites.
Transformer un besoin métier en exigences applicatives vérifiables avant de choisir des services F5 et une architecture.
Définir hypothèses, scénario, baseline et critères de recette pour une démonstration technique compréhensible et reproductible.
Construire un inventaire de capacité et une nomenclature traçable : trafic, TLS, modules, disponibilité, licences et support.
Relier exigences techniques et métier aux choix F5, documenter les compromis et transmettre un dossier exploitable aux équipes.
Identifier les équipements, les flux et les menaces, puis choisir les protections et les tests adaptés.
Comprendre où une politique AFM s’applique, expliquer l’ordre des décisions et préparer une recette qui vérifie autorisations et refus.
Distinguer protection du dispositif et des objets, choisir des vecteurs et vérifier détection, mitigation et impact applicatif.
Interpréter un signal de réputation IP et préparer une politique contrôlée, sans confondre adresse source et identité d’utilisateur.
Comprendre terminaison TLS sortante, confiance, exclusions et insertion des services d’inspection dans une architecture SSL Orchestrator.
Décider quand centraliser la gestion et les observations avec BIG-IQ, en vérifiant compatibilité, rôles et cycle de changement.
Situer la fraude web dans le blueprint 401 et distinguer signal, alerte et décision de traitement dans les environnements FPS documentés.
Articuler traces BIG-IP, chronologie, hypothèses, mesures de confinement et retour de service dans une réponse à incident documentée.
Distinguer responsabilités cloud, identités humaines et techniques et permissions nécessaires à l’administration des services applicatifs.
Relier modules, version, plateforme supportée et besoins de reprise au dimensionnement et au placement d’une BIG-IP Virtual Edition.
Suivre routes, interfaces et permissions dans une architecture BIG-IP cloud et distinguer ConfigSync du déplacement effectif du trafic.
Positionner les services applicatifs dans plusieurs couches, gérer les dépendances et définir un contrat de provisioning exploitable.
Cartographier les dépendances, établir une recette et prévoir bascule, sessions et retour arrière lors d’une migration BIG-IP cloud.
Comprendre pourquoi ajouter de la capacité cloud exige aussi de traiter données, identité, routage et retrait des ressources.
Distinguer appels d’API, orchestration et état applicatif, avec une lecture iControl REST et une méthode de traitement des erreurs.
Distinguer préparation système et configuration applicative dans les modèles déclaratifs F5, avec un exemple AS3 pédagogique.
Construire un workflow de création, configuration, recette et retrait, avec des états explicites et une séparation des secrets.
Installation, data plane, configuration, exploitation et diagnostic : un parcours progressif pour les cinq examens F5-CA BIG-IP et le renouvellement F5CABR.
Comprendre NGINX OSS, lire sa configuration, publier les services, sécuriser les accès et diagnostiquer HTTP/TLS.
Qualifier le besoin, démontrer une solution, dimensionner, justifier les choix et organiser le passage à l’exploitation.
Analyse de risque, architecture des contrôles, exploitation et réponse à incident : une progression transverse vers F5-CSE Security.
Concevoir, migrer, déployer et orchestrer une solution cloud avec des exigences, des dépendances et des preuves de recette explicites.
Un parcours ciblé pour les candidats encore éligibles au 201 : connectivité, performance, système, services et support.
Comparer les topologies, distinguer management et TMM et vérifier VLANs, self IP, routes et chemin retour.
Destination, port, source, protocole et VLAN : analyser les VS candidats et comprendre la différence entre VIP et Virtual Server.
Choisir le niveau de contrôle, écrire la requête, comprendre Send/Receive et diagnostiquer un membre de pool marqué indisponible.
Comprendre les contrôles combinés, la destination aliasée et les moniteurs externes sans confondre état du serveur et état du service.
Cookie, source address, Universal et SSL : choisir une affinité, comprendre Disabled et Forced Offline et organiser le drainage.
Idle timeout, buffers, Nagle, keepalive et datagram load balancing : relier les réglages au comportement réel de l’application.
Distinguer passthrough, offload et ré-encryption ; identifier où le TLS se termine et quelles fonctions HTTP deviennent possibles.
Vérifier identité, chaîne de confiance, sélection SNI et certificat client ; distinguer les authentifications des deux côtés du proxy.
Comprendre le détachement côté serveur, les choix par requête et les effets du source mask, du SNAT et des limites de réutilisation.
Lire une iRule, choisir les profils nécessaires et distinguer chemin, URI, requête et événements de connexion.
Choisir entre réglage natif, Local Traffic Policy et iRule ; distinguer redirection, en-têtes et transformation du corps.
Distinguer contenu réutilisable et contenu compressible, relire Cache-Control et Vary et mesurer les effets sur CPU et mémoire.
Pourquoi un seul port ne décrit pas toujours l’application : transport DNS, canaux FTP, signalisation SIP et profils spécialisés.
Distinguer confiance, synchronisation, failover et mirroring ; diagnostiquer une paire qui n’est pas réellement prête à basculer.
Comprendre ce qui flotte, ce qui déclenche une bascule et ce qui conserve l’état des connexions ; examiner les oscillations HA.
Choisir une sauvegarde, comprendre les secrets chiffrés et préparer une restauration ou un changement de plateforme sans importer aveuglément.
Vérifier version cible, licence, volumes, capacité du standby et retour arrière ; comprendre les limites d’un ordre de mise à jour universel.
Distinguer management, self IP, port lockdown, rôles et authentification distante ; attribuer des droits selon le besoin réel.
Configurer les entités collectées, comparer les membres de pool et éviter les conclusions trompeuses sur des statistiques agrégées.
Choisir les bons journaux, distinguer collecte et notification et vérifier une horloge cohérente pour corréler les événements.
Choisir VLAN, filtre et limite de capture, comparer les deux côtés du proxy et comprendre les informations TMM et les limites PVA.
Comparer accès direct et accès VIP, conserver Host et SNI et séparer panne TCP, handshake TLS, réponse HTTP et persistance.
Distinguer ressources système et TMM, rechercher une saturation et simplifier les objets sans supprimer une dépendance cachée.
Comprendre Configured, Provisioned et Deployed, distinguer la configuration du host et du guest et préparer leurs changements de version.
Lire une application déployée par iApp, retrouver ses objets et comprendre pourquoi certaines modifications directes sont refusées.
Suivre une résolution DNS et distinguer délégation, réponse autoritaire, cache et délai de prise en compte d’un changement.
Comprendre comment une requête rejoint un listener BIG-IP DNS et pourquoi UDP 53 et TCP 53 doivent être examinés séparément.
Lire le modèle d’objets GSLB et retrouver les dépendances qui rendent une destination éligible.
Distinguer sélection d’un pool, sélection d’un membre et choix preferred, alternate et fallback.
Choisir une méthode GSLB en fonction de l’objectif et des métriques réellement disponibles.
Comprendre le rôle de l’adresse du résolveur et des scores dans une décision Topology.
Comprendre la collecte entre BIG-IP DNS et BIG-IP LTM, ses dépendances TLS et les modes de découverte.
Distinguer ce qui est sondé, l’appareil qui sonde et les états qui déterminent l’éligibilité GSLB.
Comprendre pourquoi une affinité DNS concerne souvent plusieurs utilisateurs derrière un même résolveur.
Séparer la copie autoritaire d’une zone, son alimentation par transfert et les réponses servies aux clients.
Comprendre la relation entre ZoneRunner, les fichiers BIND, les zones et les objets GSLB.
Choisir le bon rôle de cache DNS et comprendre les différences entre réutiliser, résoudre et valider.
Distinguer signature, validation et publication des clés DNSSEC avant de préparer un renouvellement.
Comprendre la synthèse d’une adresse IPv6 et le chemin réseau nécessaire pour atteindre un service IPv4.
Distinguer choix réseau de l’instance DNS, choix GSLB du service et retrait d’une annonce en cas de panne.
Isoler délégation, transport, autorité, cache et décision GSLB à partir d’une résolution reproductible.
Préparer une synchronisation DNS en distinguant configuration, données de zone et matériel cryptographique.
Préparer un changement DNS avec mesures de référence, compatibilité et recette sur les instances restantes.
Suivre une publication HTTPS et identifier où le WAF peut lire et contrôler la requête.
Relier connaissance de l’application, apprentissage et maintenance au choix d’une politique ASM.
Expliquer les conditions cumulatives d’un blocage et distinguer apprentissage, journalisation et enforcement.
Examiner les suggestions ASM sans assimiler trafic fréquent et trafic légitime.
Comprendre le cycle d’une signature et préparer son activation sans désactiver toute une famille de protection.
Construire une politique lisible en distinguant URL autorisée, motif générique et type de fichier.
Relier une valeur HTTP à son entité ASM et choisir une exception qui ne s’étend pas inutilement à toute l’application.
Distinguer traitement des en-têtes, cookies modifiables et cookies dont l’intégrité doit être contrôlée.
Comprendre pourquoi l’inspection d’une API commence par un parsing adapté à sa route et à son contenu.
Définir une connexion réussie avant de construire une détection d’échecs de login.
Distinguer une session valide d’une requête légitimement initiée sur une route sensible.
Séparer détection dans les réponses, masquage et confidentialité des journaux ASM.
Retrouver une requête bloquée et limiter une correction à sa cause réelle.
Comparer tendances et événements pour vérifier une correction WAF sans assimiler absence d’alerte et absence d’attaque.
Définir une signature ciblée, son périmètre et les tests qui justifient son enforcement.
Choisir des protections adaptées à la surcharge, aux automatismes et au type de client.
Relier une vulnérabilité identifiée à une mitigation WAF tout en vérifiant le format d’import et son périmètre.
Préparer un changement de politique avec une version récupérable et une comparaison lisible.
Séparer cohérence des politiques, reprise du trafic et disponibilité des dépendances après bascule.
Relier ressources ASM, coût de collecte et permissions au maintien d’une protection exploitable.
Relier le virtual server, la politique d’accès et la session qui porte les droits d’un utilisateur.
Lire un Visual Policy Editor comme un ensemble de décisions et justifier chaque sortie.
Séparer preuve d’identité, récupération d’attributs et décision de droit dans une politique APM.
Identifier les dépendances réseau et d’identité qui conditionnent une action AAA.
Composer des facteurs d’authentification en conservant des branches de refus explicites.
Comprendre où une variable est produite et pourquoi son nom, sa valeur et son contexte comptent.
Organiser un parcours APM autour de fonctions dont les entrées et sorties sont explicites.
Choisir un mode d’accès selon les protocoles, les clients et le périmètre de ressources à exposer.
Suivre un paquet VPN depuis l’adresse louée jusqu’au retour du serveur interne.
Comprendre comment le navigateur accède à une application interne et où une réécriture peut échouer.
Séparer ressources affectées, compatibilité client et autorisation de la destination interne.
Comprendre pourquoi affichage, affectation et droit de trafic sont trois vérifications séparées.
Construire des permissions compréhensibles en vérifiant ordre, affectation et comportement final.
Distinguer connexion à APM et authentification de la requête vers le backend.
Suivre une fédération par le navigateur et distinguer confiance, assertion et session locale.
Comprendre pourquoi une session APM se partage, expire ou provoque une nouvelle authentification.
Relier compatibilité du poste, bibliothèques de détection et branches d’accès à une décision fiable.
Suivre le même identifiant de session entre client, actions VPE, AAA et backend.
Distinguer partage de configuration APM et continuité de l’expérience utilisateur lors d’une bascule.
Séparer activation du module, limite de sessions d’accès et capacité de connectivité.
Adapter l’expérience APM tout en conservant les objets et mécanismes nécessaires au parcours.
Séparer reverse proxy applicatif, forward proxy et décisions par catégorie d’URL.
Round Robin, Ratio, Least Connections, méthodes dynamiques et priorités : choisir une répartition adaptée et comprendre les variantes member et node.
Suivre le chemin retour, choisir une traduction de source et comprendre les effets sur l’adresse client, les ports et la haute disponibilité.
Suffixe %ID, adresses qui se chevauchent, partitions, parent et strict isolation : comprendre et inspecter les contextes de routage BIG-IP.
Ressources, poids, seuils et active bonus : calculer un score HA et comprendre la décision de bascule d’un traffic group.
Standard, Performance L4, Forwarding IP et types spécialisés : comprendre le traitement du trafic, les profils et les limites de chaque VS.