Exemple Python LDAP

LDAP est un protocole d'accès au répertoire léger. Il s'agit d'un protocole Internet qui fonctionne sur TCP / IP, et il est utilisé pour accéder / récupérer les informations des répertoires. Tous les répertoires ne sont pas préférables; il est généralement utilisé pour accéder aux répertoires actifs.

Caractéristiques / caractéristiques de LDAP

LDAP est connu pour être un modèle fonctionnel; Il est simple et unique en raison de sa capacité à éviter la duplication des données pour garder le contenu en sécurité et cohérent. Certaines des principales caractéristiques du LDAP sont les suivantes.

• LDAP est connu pour être un protocole d'implémentation open-source et peut être téléchargé gratuitement à partir d'Internet.
• Il a une fonctionnalité importante traitant de la sécurité des données. Comme il prend en charge la sécurité de la couche de transport (TLS), les données sensibles peuvent être facilement fixées à partir des snatchers.
• LDAP est également bénéfique pour soutenir les systèmes de base de données. Car il stocke les répertoires et permet à l'utilisateur de choisir la base de données en fonction des informations du serveur.

LDAP a de nombreuses fonctions concernant les services qu'il fournit. Nous en soulignerons certains ici.

Pour l'authentification du client

Comme LDAP est facilement accessible et constitue de nombreuses opérations pour se connecter / se déconnecter d'un serveur LDAP, il provoque les droits sur l'accès et protège les informations privées. Il authentifie les clients qui réussissent la demande de connectivité afin que seul l'utilisateur authentique et valide puisse être connecté. Pour le processus d'authentification, une session client est créée et terminée en utilisant les fonctions. Comme lier / délier, abandonner.

Pour la requête de l'information

Il comprend des fonctions de comparaison et de recherche qui sont utilisées pour récupérer les informations du répertoire. Dans cette situation, un serveur joue un rôle important, car il exécute de nombreuses actions en suivant les fonctions comme la recherche, comparer l'entrée.

Modification des données

La modification des données comprend l'addition, la suppression et la modification des données stockées dans le répertoire spécifié. Les fonctions principales incluent.

1. Ajouter une entrée.

2. Supprimer l'entrée des données.

3. Modification des données.

Cette modification est aux deux extrémités. Par exemple, le client établit une session avec le serveur en utilisant le nom d'hôte et le numéro de port du côté client. À des fins de sécurité, l'utilisateur utilise les ID et les mots de passe pour l'authentification. Tandis que au côté du serveur, le serveur est capable de lire, de mettre à jour et de rechercher les données.

Interaction LDAP entre le client et le serveur

Il est similaire à l'une des interactions clients-serveur simples. Dans ce cas, le client utilise les fonctions de protocole contre le serveur. Les points ci-dessous expliquent brièvement cette interaction.

1. Un client envoie une demande de protocole au serveur.
2. Le serveur effectue différentes opérations sur le répertoire comme la recherche, etc.
3. La réponse du serveur est renvoyée au client.

Plusieurs logiciels peuvent facilement créer une connexion et créer un serveur LDAP. Mais tous nécessitent des répertoires. Si l'utilisateur ne veut pas installer le serveur d'annuaire sur le système mais souhaite utiliser LDAP, l'utilisateur peut utiliser Four11, Bigfoot, etc. La création du client LDAP est simple car il y a SDK dans de nombreuses autres langues comme C ++, Java, etc. Pour être un client LDAP, l'utilisateur doit effectuer certaines tâches.

• Pour votre langage de programmation, allez chercher un SDK.
• Utilisez la fonction du SDK pour la création de LDAP.
• Après ces étapes, effectuez maintenant des opérations sur LDAP.

Création de l'utilisateur LDAP

Maintenant, nous allons créer un utilisateur LDAP en utilisant le script en langue Python. Un fichier CSV est utilisé. Après la création, le script peut être encore modifié en fonction des exigences, comme l'ajout d'une bibliothèque de clics qui crée des utilisateurs individuels.

Étape 1: Installez les exigences

La première étape consiste à installer les conditions préalables à la création des utilisateurs. Cela implique l'installation de «python-ldap».

# Pip install python-ldap

Étape 2: Utilisation de Python Formez une connexion avec LDAP

Cette étape consiste à établir une connexion avec le LDAP. Tout d'abord, importez les modules LDAP, SYS et LDAP_ADMIN_DN de la bibliothèque Python. Ensuite, nous définirons une fonction qui transporte l'hôte et le mot de passe comme argument d'une fonction.

La fonction principale est écrite à l'intérieur du corps de la partie «essayez» de la manipulation exceptionnelle. Cela éliminera l'occurrence de tout gros problème, et si une erreur de minute se produit, une demande d'exception est lancée, qui est résolue par la méthode Catch (). Ce n'est pas décrit ici.

Revenant vers le code, la connexion est construite en utilisant la ligne sous-écrite.

# Ldap_conn = ldap.Initialiser (LDAP_HOST) Importer LDAP
importer sys
importer ldap_admin_dn
def try_ldap_bind (ldap_host, admin_pass):
essayer:
ldap_conn = ldap.initialiser (ldap_host)
sauf LDAP.SERVEUR HORS-SERVICE:
print ("Impossible de contacter le serveur LDAP")
sortie (4)
essayer:
ldap_conn.Simple_bind_s (ldap_admin_dn, admin_pass)
Sauf (LDAP.LES INFORMATIONS D'IDENTIFICATION INVALIDES):
Imprimer ("Ce mot de passe est incorrect!")
système.sortie (3)
Imprimer ("Authentinisation réussi")

Si le mot de passe ou le nom d'hôte n'est pas correct, un message affiche que le mot de passe n'est pas correct. Sinon, il montre un message que l'authentification réussit dans le cas des informations d'identification correctes.

Étape 3: chargement de fichiers CSV

Après avoir importé le module CSV, nous prendrons un tableau vide. Pour ouvrir le fichier CSV déjà créé, la commande de fonction ouvrir () est utilisée. Le fichier est ouvert en utilisant un objet. Cet objet et les deux fichiers sont passés sous forme de paramètres de la fonction ouverte (). Chaque ligne du code est considérée comme ligne par ligne via la fonction du lecteur.

#vusers_reader = csv.lecteur (users_csv_file)

Toutes les valeurs sont entrées dans le tableau en utilisant une boucle pour une boucle. Chaque mot est placé à chaque index d'un tableau. Par exemple, le premier mot est le nom d'utilisateur; il est placé aux indices zéro de ce tableau. Un processus similaire est utilisé pour tous les index. Ces mots sont présents dans la variable «utilisateur». Maintenant, ceux-ci sont annexés avec le tableau 'Users_To_Import' via la fonction d'ajout.

# users_to_import.Ajouter (utilisateur)

C'est ainsi que les données présentes dans le fichier CSV sont chargées maintenant.

Importer CSV
users_to_import = []
avec Open ('Fichier.csv ',' rb ') as users_csv_file:
Users_Reader = CSV.lecteur (users_csv_file)
Pour Row dans Users_Reader:
user =
«Nom d'utilisateur»: ligne [0],
'Mot de passe': ligne [1],
«FirstName»: Row [2],
'LastName': Row [3],
«Groupe»: ligne [4],
'shell': ligne [5],
'hôtes': ligne [6],

users_to_import.Ajouter (utilisateur)

Étape 4: Création d'utilisateurs sur le serveur LDAP

À partir du fichier CSV, nous créerons un utilisateur à l'aide d'une fonction. La première étape traite de la définition d'une fonction nommée 'create_user'. Par exemple, le cas du groupe que nous avons:

# Gid = find_gid (utilisateur ['groupe']) def create_user (utilisateur, admin_pass):
dn = 'uid =' + utilisateur ['nom d'utilisateur'] + ',' + ldap_base_dn
fullName = user ['FirstName'] + + User ['LastName']
home_dir = home_base + '/' + user ['username']
gid = find_gid (utilisateur ['groupe'])
LastChange = int (mathématiques.plancher (time () / 86400))

Il prend le nom d'utilisateur et le mot de passe de l'administrateur. À l'intérieur du corps de la fonction, chaque champ du formulaire de création d'utilisateurs est rempli de l'information qu'il obtient. Ces informations sont stockées dans les variables. Ces variables sont utilisées lors de l'attribution des valeurs dans le tableau. En fin de compte, nous utilisons la fonction d'ajout pour lier les valeurs. Ici, une instruction if est utilisée. Cela vérifiera la longueur du tableau «utilisateur» via le Len ().

# if (len (user ['hosts'])):
# Entrée.ajout (('host', utilisateur ['hosts'])) entrée = []
entrée.étendre([
('ObjectClass', ["Person", "OrganizationalSerson",
"Inetorgperson", "posixAccount", "top", "shadowaccount", "hostoBject"]), ('uid', utilisateur ['username'])),
('CN', FullName),
('Girename', utilisateur ['FirstName']),
('sn', utilisateur ['LastName']),
(«courrier», utilisateur [«e-mail»]),
('uidnumber', str (utilisateur ['uid'])),
('gidnumber', str (gid)),
('Loginshell', utilisateur ['shell']),
('homeDirectory', home_dir),
('Shadowmax', "99999"),
('Shadowwarning', "7"),
('shadowlastchange', str (lastchange)), ('userpassword', utilisateur ['mot de passe'])
])
if (Len (user ['hosts'])):
entrée.ajout (('host', utilisateur ['hosts']))

Le même processus de déclaration de tableau est utilisé ici. Chaque index du tableau contient la valeur du contenu présent dans le fichier CSV. Cette fois, chaque numéro d'index est également donné le nom de variable que nous avons utilisé dans la fonction ci-dessus.

En passant maintenant vers la dernière phase de la création de l'utilisateur, nous allons ici créer une connexion lorsque l'utilisateur sera créé en attribuant chaque valeur du tableau. Utilisez à nouveau un corps d'essai pour ignorer les erreurs. En fin de compte, nous utiliserons la fonction Unbind pour fermer la connexion.

# ldap_conn.unstind_s () ldap_conn = ldap.initialiser (ldap_host)
ldap_conn.Simple_bind_s (ldap_admin_dn, admin_pass)
essayer:
ldap_conn.add_s (dn, entrée)
enfin:
ldap_conn.unstind_s ()

Conclusion

`` Python LDAP Exemple '' vise à fournir les fonctionnalités, les fonctions et la fonction de création de l'utilisateur du protocole LDAP. Nous avons brièvement expliqué les aspects importants de ce protocole en mettant en évidence l'interaction entre le serveur et le client. Nous espérons que ce tutoriel sera bénéfique pour l'utilisateur concernant l'implémentation LDAP dans la langue Python.