diff --git a/openldap/Dockerfile b/openldap/Dockerfile
new file mode 100644
index 0000000..513db10
--- /dev/null
+++ b/openldap/Dockerfile
@@ -0,0 +1,47 @@
+#
+#   Licensed to the Apache Software Foundation (ASF) under one 
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing,
+#   software distributed under the License is distributed on an
+#   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
+#   KIND, either express or implied.  See the License for the 
+#   specific language governing permissions and limitations
+#   under the License.
+#
+
+FROM alpine
+
+RUN apk add --no-cache openldap openldap-back-hdb openldap-clients openssl
+
+ADD slapd-config.ldif slapd-data.ldif /tmp/
+
+# Generate a self-signed SSL certificate
+RUN openssl req -newkey rsa:4096 -sha512 -x509 -days 3650 -nodes \
+    -subj "/C=NA/ST=NA/L=NA/O=NA/CN=example.com" \
+    -out /etc/ssl/certs/ldap.pem -keyout /etc/ssl/private/ldap.pem && \
+    chown root:ldap /etc/ssl/private/ldap.pem && \
+    chmod 640 /etc/ssl/private/ldap.pem
+
+# Inject configuration
+RUN mkdir /etc/openldap/slapd.d && \
+    slapadd -d -1 -F /etc/openldap/slapd.d -n 0 -l /tmp/slapd-config.ldif
+
+# Inject data
+RUN slapadd -d 1 -F /etc/openldap/slapd.d -l /tmp/slapd-data.ldif
+
+# Fix permissions
+RUN chown -R ldap:ldap /var/lib/openldap && \
+    chown -R ldap:ldap /etc/openldap/slapd.d
+
+EXPOSE 389 636
+
+CMD /usr/sbin/slapd -d 256 -u ldap -g ldap -F /etc/openldap/slapd.d -h "ldap:/// ldaps:///"
+
diff --git a/openldap/README.md b/openldap/README.md
new file mode 100644
index 0000000..651dc7c
--- /dev/null
+++ b/openldap/README.md
@@ -0,0 +1,37 @@
+> Licensed to the Apache Software Foundation (ASF) under one
+> or more contributor license agreements.  See the NOTICE file
+> distributed with this work for additional information
+> regarding copyright ownership.  The ASF licenses this file
+> to you under the Apache License, Version 2.0 (the
+> "License"); you may not use this file except in compliance
+> with the License.  You may obtain a copy of the License at
+>
+>    http://www.apache.org/licenses/LICENSE-2.0
+>
+> Unless required by applicable law or agreed to in writing,
+> software distributed under the License is distributed on an
+> "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+> KIND, either express or implied.  See the License for the
+> specific language governing permissions and limitations
+> under the License.
+
+
+# About
+
+A docker image to run OpenLDAP.
+
+
+## Build image
+
+    docker build -t apachedirectory/openldap .
+
+
+## Publish image
+
+    docker push apachedirectory/openldap
+
+
+## Usage
+
+    docker run -d -p 389:389 -p 636:636 apachedirectory/openldap
+
diff --git a/openldap/slapd-config.ldif b/openldap/slapd-config.ldif
new file mode 100644
index 0000000..4e511b5
--- /dev/null
+++ b/openldap/slapd-config.ldif
@@ -0,0 +1,34 @@
+dn: cn=config
+objectClass: olcGlobal
+cn: config
+olcArgsFile: /var/lib/openldap/run/slapd.args
+olcPidFile: /var/lib/openldap/run/slapd.pid
+olcTLSCACertificateFile: /etc/ssl/certs/ldap.pem
+olcTLSCertificateFile: /etc/ssl/certs/ldap.pem
+olcTLSCertificateKeyFile: /etc/ssl/private/ldap.pem
+
+dn: cn=schema,cn=config
+objectClass: olcSchemaConfig
+cn: schema
+
+include: file:///etc/openldap/schema/core.ldif
+
+include: file:///etc/openldap/schema/cosine.ldif
+
+include: file:///etc/openldap/schema/inetorgperson.ldif
+
+dn: olcDatabase=frontend,cn=config
+objectClass: olcDatabaseConfig
+objectClass: olcFrontendConfig
+olcDatabase: frontend
+
+dn: olcDatabase=mdb,cn=config
+objectClass: olcDatabaseConfig
+objectClass: olcMdbConfig
+olcDatabase: mdb
+olcSuffix: dc=example,dc=com
+olcRootDN: cn=admin,dc=example,dc=com
+olcRootPW: secret
+olcDbDirectory: /var/lib/openldap/openldap-data
+olcDbIndex: objectClass eq
+
diff --git a/openldap/slapd-data.ldif b/openldap/slapd-data.ldif
new file mode 100644
index 0000000..7ca7d76
--- /dev/null
+++ b/openldap/slapd-data.ldif
@@ -0,0 +1,5 @@
+dn: dc=example,dc=com
+objectclass: domain
+objectclass: top
+dc: example
+
