Ich habe in drei Teilen zusammengefasst, wie LDAP mit Python betrieben wird. Bei der Entwicklung mit mehreren Personen muss jeder die ldap3-Bibliothek und LDAP verstehen, dies erfordert jedoch Zeit und Mühe. Deshalb habe ich eine Klasse für alle erstellt, die nur wissen, dass LDAP baumstrukturierte Daten sind.
Zunächst werde ich beschreiben, wie LDAP bei Verwendung dieser Klasse betrieben wird. Wenn Sie es verwenden, ist es einfacher zu verstehen, ob Sie den Klassennamen ändern. Wenn Sie also in der folgenden Erläuterung die Domänenklasse in Adresse, Organisation in Eigentümer und Allgemein in Haustier ändern, können Sie die Hierarchie von Adresse-> Eigentümer-> Haustier ändern. Sie können sich dessen bewusst sein.
main.py
from ldap_obj.Address import Address
#Ort hinzufügen
address = Address('localhost', 'LdapPass', 'admin', 'sample-ldap')
address.set_item('tokyo')
address.save()
#Leute hinzufügen
owner = address.create_owner()
owner.set_item('sato')
owner.save()
#Haustier(Marmor)Hinzufügen
pet_tama = owner.create_pet()
pet_tama.set_item('tama')
pet_tama.save({'sn': 'sato', 'st': 'tama', 'title': 'cat'})
#Haustier(Pochi)Hinzufügen
pet_pocho = owner.create_pet()
pet_pocho.set_item('pochi')
pet_pocho.save({'sn': 'sato', 'st': 'pochi', 'title': 'dog'})
#Rufen Sie den Wert von cn von der Domänenebene ab, indem Sie title als Suchbedingung verwenden
address.set_filter('title')
print(address.get_common())
print('***********************')
#Adresse generieren
address_get = Address('localhost', 'LdapPass', 'admin', 'sample-ldap')
address_get.set_item('tokyo')
# Address ->Besitzer Generation
owner_get = address_get.create_owner()
owner_get.set_item('sato')
# Address -> Owner ->Haustiergeneration
pet_get = owner_get.create_pet()
pet_get.set_item('tama')
print(pet_get.get_common())
Die LDAP-Klasse erstellt für jede Hierarchie eine Klasse.
\--
|--ldap_obj\
| |--BaseClass.py (Kriterienklasse)
| |--CommonClass.py (Klasse von cn)
| |--DomainClass.py (Gleichstromklasse)
| |--OrganizationClass.py (Du Klasse)
|
|--main.py
Die Basisklasse ist im Grunde ein Wrapper für ldap3. Ich mache nichts besonders kompliziertes. Der Auftragnehmer generiert die für die Verbindung erforderliche Klasse, und get_xxx () übergibt die Objektklasse an _read_ldap (), um die Informationen von LDAP abzurufen. Diese Funktion nimmt mit zunehmender Anzahl von Objektklassen zu.
BaseClass.py
from ldap3 import Server, Connection, ObjectDef, Reader
class BaseClass(object):
def __init__(self, host, passwd, user, top_domain, dn=None):
self.passwd = passwd
self.user = user
self.host = host
self.top_domain = top_domain
self.filter = None
if (dn):
self.dn = dn
else:
self.dn = 'dc=' + top_domain
self.server = Server(self.host)
self.conn = Connection(self.host, 'cn={},dc={}'.format(user, top_domain), password=passwd)
def set_filter(self, filter):
self.filter = filter
def get_domain(self):
return self._read_ldap('domain', self.filter)
def get_organizational(self):
return self._read_ldap('organizationalUnit', self.filter)
def get_common(self):
return self._read_ldap('inetOrgPerson', self.filter)
def get_domain_dict(self):
return self._read_ldap_dict('domain', self.filter)
def get_organizational_dict(self):
return self._read_ldap_dict('organizationalUnit', self.filter)
def get_common_dict(self):
return self._read_ldap_dict('inetOrgPerson', self.filter)
def _read_ldap(self, object_type, search_attr = None):
data_list = []
self.conn.bind()
obj_dn = ObjectDef(object_type, self.conn)
data_reader = Reader(self.conn, obj_dn, self.dn)
data_reader.search(search_attr)
for data in data_reader:
data_list.append(data)
data_reader.reset()
self.conn.unbind()
return data_list
def _read_ldap_dict(self, object_type, search_attr = None):
data_list = []
self.conn.bind()
obj_dn = ObjectDef(object_type, self.conn)
data_reader = Reader(self.conn, obj_dn, self.dn)
data_reader.search(search_attr)
for data in data_reader:
data_list.append(data.entry_attributes_as_dict)
data_reader.reset()
self.conn.unbind()
return data_list
Erstellen Sie eine Klasse, die die obige Standardklasse für jede Hierarchie erbt.
Da der Wert von dc erforderlich ist, wird der Wert von dc mit `set_item ()` zur Zeichenkette von dn addiert. Verwenden Sie diese Datei self.dn, um Informationen mit der Basisklasse `get_xxx ()` abzurufen, oder fügen Sie sie mit save ()`` hinzu. ``create_organization ()` `` erstellt und gibt eine Klasse für Sie zurück. In diesem Beispiel möchten wir dc = xxx, ou = yyy, also gibt es nur eine Generierungsfunktion für ou. Wenn Sie jedoch dc = xxx, dc = yyy möchten, können Sie auf die gleiche Weise eine Generierungsfunktion für dc erstellen.
DomainClass.py
from ldap_obj.BaseClass import BaseClass
from ldap_obj.OrganizationClass import OrganizationClass
class DomainClass(BaseClass):
def set_item(self, item):
self.dn = 'dc=' + item + ',' + self.dn
def create_organization(self):
return OrganizationClass(self.host, self.passwd, self.user, self.top_domain, self.dn)
def save(self):
self.conn.bind()
result = self.conn.add(self.dn, 'domain')
self.conn.unbind()
return result
Da die aus der Domain-Klasse generierte Organisationsklasse den Pfad zu cn in self.dn enthält, wird der Wert von ou mit `set_item ()` hinzugefügt. Verwenden Sie diese Datei self.dn, um Informationen mit der Basisklasse `get_xxx ()` abzurufen, oder fügen Sie sie mit save ()`` hinzu. ``create_common ()` `` erstellt und gibt eine Klasse für cn zurück. In diesem Beispiel möchte ich dc = xxx, ou = yyy, cn = zzzz, daher gibt es nur eine Generierungsfunktion für cn. Wenn Sie jedoch eine andere Konfiguration wünschen, erstellen Sie eine Generierungsfunktion dafür.
OrganizationClass.py
from ldap_obj.BaseClass import BaseClass
from ldap_obj.CommonClass import CommonClass
class OrganizationClass(BaseClass):
def set_item(self, item):
self.dn = 'ou=' + item + ',' + self.dn
def create_common(self):
return CommonClass(self.host, self.passwd, self.user, self.top_domain, self.dn)
def save(self):
self.conn.bind()
result = self.conn.add(self.dn, 'organizationalUnit')
self.conn.unbind()
return result
Da die aus der Organization-Klasse generierte Common-Klasse den Pfad zu ou in self.dn enthält, wird der Wert von cn mit `set_item ()` hinzugefügt. Verwenden Sie diese Datei self.dn, um Informationen mit der Basisklasse `get_xxx ()` abzurufen, oder fügen Sie sie mit save ()` `` hinzu. Da dieses Beispiel das letzte in diesem cn ist, gibt es keine Generierungsfunktion. Wenn die Hierarchie jedoch tiefer ist, erstellen Sie eine Generierungsfunktion dafür.
CommonClass.py
from ldap_obj.BaseClass import BaseClass
class CommonClass(BaseClass):
def set_item(self, item):
self.dn = 'cn=' + item + ',' + self.dn
def save(self, attr_dict):
self.conn.bind()
result = self.conn.add(self.dn, 'inetOrgPerson', attr_dict)
self.conn.unbind()
return result
Um diese Klassen zu verwenden, generieren Sie zuerst eine DomainClass und geben Sie dann den Wert von dc ein. Verwenden Sie dann die generierte DomainClass `create_organization ()`, um eine Organisationsklasse und den Wert von ou zu erstellen. Einstellen. Verwenden Sie zum Erstellen von common die generierte Organisationsklasse `create_common ()` und geben Sie den Wert von cn ein. Verwenden Sie die Funktion get und zusätzliche Funktionen in jeder Generierungsklasse, um LDAP zu betreiben.
main.py
from ldap_obj.DomainClass import DomainClass
domain = DomainClass('localhost', 'LdapPass', 'admin', 'sample-ldap')
domain.set_item('sample-component')
domain_item_list = domain.get_domain()
for domain_item in domain_item_list:
print(domain_item)
print("=====================")
domain.set_filter('st')
domain_item_list = domain.get_common()
for domain_item in domain_item_list:
print(domain_item)
print("=====================")
organization = domain.create_organization()
organization.set_item('sample-unit')
organization_list = organization.get_organizational()
for organization_item in organization_list:
print(organization_item)
print("=====================")
common = organization.create_common()
common.set_item('sample-name')
common_list = common.get_common()
for common_item in common_list:
print(common_item)
print("***********************************")
new_domain = DomainClass('localhost', 'LdapPass', 'admin', 'sample-ldap')
new_domain.set_item('new-component')
print(new_domain.save())
print("=====================")
new_organization = new_domain.create_organization()
new_organization.set_item('new-organization')
print(new_organization.save())
print("=====================")
new_common = new_organization.create_common()
new_common.set_item('new-common')
print(new_common.save({'st':'new-st', 'sn': 'new-sn'}))
print("=====================")
new_common_list = new_common.get_common()
for common_item in new_common_list:
print(common_item)
Ich habe versucht, eine Klasse zu erstellen, die betrieben werden kann, indem LDAP-Elemente so weit wie möglich entfernt werden. Wenn Sie die Bibliothek von ldap3 kennen, scheint die Operation über die Klasse problematisch zu sein, aber wenn Sie sich die Quelle tatsächlich ansehen, wird es auf einen Blick einfacher zu verstehen, was Sie tun. Dieses Mal habe ich die Funktionen get und add hinzugefügt, aber ich denke, dass Löschen, Verschieben und Aktualisieren der Standardklasse eine Funktion hinzufügen sollte, die ldap3 verwendet. Wenn es bisher leicht zu verstehen ist, denke ich, dass es kein Zögern geben wird, es als Kandidaten für die Datenspeicherung zu verwenden.
Recommended Posts