This is page 16 of 22. Use http://codebase.md/id/docs/get_started/create/basic_markup.html?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .ci
│ ├── check-markdownfmt.sh
│ ├── check-metadata.sh
│ ├── check-pr-no-readme.sh
│ ├── check-required-files.sh
│ ├── check-short.sh
│ ├── check-ymlfmt.sh
│ └── get-markdownfmt.sh
├── .common-templates
│ ├── maintainer-community.md
│ ├── maintainer-docker.md
│ ├── maintainer-hashicorp.md
│ └── maintainer-influxdata.md
├── .dockerignore
├── .github
│ └── workflows
│ └── ci.yml
├── .template-helpers
│ ├── arches.sh
│ ├── autogenerated-warning.md
│ ├── compose.md
│ ├── generate-dockerfile-links-partial.sh
│ ├── generate-dockerfile-links-partial.tmpl
│ ├── get-help.md
│ ├── issues.md
│ ├── license-common.md
│ ├── template.md
│ ├── variant-alpine.md
│ ├── variant-default-buildpack-deps.md
│ ├── variant-default-debian.md
│ ├── variant-default-ubuntu.md
│ ├── variant-onbuild.md
│ ├── variant-slim.md
│ ├── variant-windowsservercore.md
│ ├── variant.md
│ └── variant.sh
├── adminer
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── aerospike
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── almalinux
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── alpine
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── alt
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── amazoncorretto
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── amazonlinux
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── api-firewall
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── arangodb
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── archlinux
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── backdrop
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── bash
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── bonita
│ ├── compose.yaml
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── buildpack-deps
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── busybox
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-glibc.md
│ ├── variant-musl.md
│ ├── variant-uclibc.md
│ └── variant.md
├── caddy
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo-120.png
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── cassandra
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── chronograf
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── cirros
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── clearlinux
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── clefos
│ ├── content.md
│ ├── deprecated.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── clickhouse
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── clojure
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── composer
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── convertigo
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── couchbase
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── couchdb
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── crate
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── dart
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── debian
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-slim.md
│ └── variant.md
├── docker
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-rootless.md
│ └── variant-windowsservercore.md
├── Dockerfile
├── drupal
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-fpm.md
├── eclipse-mosquitto
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── eclipse-temurin
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── eggdrop
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── elasticsearch
│ ├── compose.yaml
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-alpine.md
├── elixir
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── emqx
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── erlang
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── fedora
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── flink
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── fluentd
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── friendica
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── gazebo
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── gcc
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── generate-repo-stub-readme.sh
├── geonetwork
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-postgres.md
│ └── variant.md
├── get-categories.sh
├── ghost
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── golang
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-alpine.md
│ └── variant-tip.md
├── gradle
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── groovy
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── haproxy
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── haskell
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-slim.md
├── haxe
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── hello-world
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── update.sh
├── hitch
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── httpd
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── hylang
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── ibm-semeru-runtimes
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── ibmjava
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── influxdb
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-data.md
│ └── variant-meta.md
├── irssi
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── jetty
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── joomla
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── jruby
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── julia
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── kapacitor
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── kibana
│ ├── compose.yaml
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── kong
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── krakend
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo-120.png
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── LICENSE
├── lightstreamer
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── liquibase
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── logstash
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-alpine.md
├── mageia
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── mariadb
│ ├── compose.yaml
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── markdownfmt.sh
├── matomo
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── maven
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── mediawiki
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── memcached
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── metadata.json
├── metadata.sh
├── mongo
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── mongo-express
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── monica
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── mono
│ ├── content.md
│ ├── deprecated.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── mysql
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── nats
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── neo4j
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── neurodebian
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── nextcloud
│ ├── content.md
│ ├── deprecated.md
│ ├── github-repo
│ ├── license.md
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── nginx
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-perl.md
├── node
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── notary
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── odoo
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── open-liberty
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── openjdk
│ ├── content.md
│ ├── deprecated.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-alpine.md
│ ├── variant-oracle.md
│ └── variant-slim.md
├── oraclelinux
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-slim.md
├── orientdb
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── parallel-update.sh
├── percona
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── perl
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── photon
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── php
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-apache.md
│ ├── variant-cli.md
│ ├── variant-fpm.md
│ └── variant.md
├── php-zendserver
│ ├── content.md
│ ├── deprecated.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── phpmyadmin
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── plone
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── postfixadmin
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-apache.md
│ ├── variant-fpm-alpine.md
│ └── variant-fpm.md
├── postgres
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── push.pl
├── push.sh
├── pypy
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── python
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-slim.md
├── r-base
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── rabbitmq
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── rakudo-star
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── README.md
├── redis
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── redmine
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── registry
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── rethinkdb
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── rocket.chat
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── rockylinux
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── ros
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── ruby
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── rust
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── sapmachine
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── satosa
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── scratch
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── silverpeas
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── solr
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── sonarqube
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── spark
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── spiped
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── storm
│ ├── compose.yaml
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── swift
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── swipl
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── teamspeak
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── telegraf
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── tomcat
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── tomee
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── traefik
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-alpine.md
├── ubuntu
│ ├── content.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── unit
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── update.sh
├── varnish
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── websphere-liberty
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── wordpress
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ ├── variant-cli.md
│ └── variant-fpm.md
├── xwiki
│ ├── content.md
│ ├── get-help.md
│ ├── github-repo
│ ├── issues.md
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ └── README.md
├── ymlfmt.sh
├── yourls
│ ├── compose.yaml
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.svg
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-fpm.md
├── znc
│ ├── content.md
│ ├── github-repo
│ ├── license.md
│ ├── logo.png
│ ├── maintainer.md
│ ├── metadata.json
│ ├── README-short.txt
│ ├── README.md
│ └── variant-slim.md
└── zookeeper
├── compose.yaml
├── content.md
├── github-repo
├── license.md
├── logo.png
├── maintainer.md
├── metadata.json
├── README-short.txt
└── README.md
```
# Files
--------------------------------------------------------------------------------
/dart/logo.svg:
--------------------------------------------------------------------------------
```
<?xml version="1.0" encoding="utf-8"?>
<!-- Generator: Adobe Illustrator 22.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
width="192px" height="192px" viewBox="0 0 192 192" enable-background="new 0 0 192 192" xml:space="preserve">
<g>
<rect x="0" fill="none" width="192" height="192"/>
<path fill="#01579B" d="M51,141l-26-26c-3.08-3.17-5-7.63-5-12c0-2.02,1.14-5.18,2-7l24-50L51,141z"/>
<path fill="#40C4FF" d="M140,51l-26-26c-2.27-2.28-7-5-11-5c-3.44,0-6.81,0.69-9,2L46,46L140,51z"/>
<polygon fill="#40C4FF" points="82,172 145,172 145,145 98,130 55,145 "/>
<path fill="#29B6F6" d="M46,127c0,8.02,1.01,9.99,5,14l4,4h90l-44-50L46,46V127z"/>
<path fill="#01579B" d="M126,46H46l99,99h27V83l-32-32C135.51,46.49,131.51,46,126,46z"/>
<path opacity="0.2" fill="#FFFFFF" d="M52,142c-4-4.02-5-7.97-5-15V47l-1-1v81C46,134.03,46,135.98,52,142l3,3l0,0L52,142z"/>
<polygon opacity="0.2" fill="#263238" points="171,82 171,144 144,144 145,145 172,145 172,83 "/>
<path opacity="0.2" fill="#FFFFFF" d="M140,51c-4.96-4.96-9.02-5-15-5H46l1,1h78C127.99,47,135.52,46.5,140,51L140,51z"/>
<radialGradient id="SVGID_1_" cx="96" cy="96" r="76" gradientUnits="userSpaceOnUse">
<stop offset="0" style="stop-color:#FFFFFF;stop-opacity:0.1"/>
<stop offset="1" style="stop-color:#FFFFFF;stop-opacity:0"/>
</radialGradient>
<path opacity="0.2" fill="url(#SVGID_1_)" d="M171,82l-31-31l-26-26c-2.27-2.28-7-5-11-5c-3.44,0-6.81,0.69-9,2L46,46L22,96
c-0.86,1.82-2,4.98-2,7c0,4.37,1.92,8.83,5,12l23.96,23.79c0.57,0.7,1.25,1.42,2.04,2.21l1,1l3,3l26,26l1,1h62h1v-27h27v-0.07V83
L171,82z"/>
</g>
</svg>
```
--------------------------------------------------------------------------------
/buildpack-deps/content.md:
--------------------------------------------------------------------------------
```markdown
# What is `buildpack-deps`?
In spirit, `buildpack-deps` is similar to [Heroku's stack images](https://github.com/heroku/stack-images/blob/master/bin/cedar.sh). It includes a large number of "development header" packages needed by various things like Ruby Gems, PyPI modules, etc. For example, `buildpack-deps` would let you do a `bundle install` in an arbitrary application directory without knowing beforehand that `ssl.h` is required to build a dependent module.
%%LOGO%%
# How to use this image
This stack is designed to be the foundation of a language-stack image.
## What's included?
The main tags of this image are the full batteries-included approach. With them, a majority of arbitrary `gem install` / `npm install` / `pip install` should be successful without additional header/development packages.
For some language stacks, that doesn't make sense, particularly if linking to arbitrary external C libraries is much less common (as in Go and Java, for example), which is where these other smaller variants can come in handy.
### `curl`
This variant includes just the `curl`, `wget`, and `ca-certificates` packages. This is perfect for cases like the Java JRE, where downloading JARs is very common and necessary, but checking out code isn't.
### `scm`
This variant is based on `curl`, but also adds various source control management tools. As of this writing, the current list of included tools is `bzr`, `git`, `hg`, and `svn`. Intentionally missing is `cvs` due to the dwindling relevance it has (sorry CVS). This image is perfect for cases like the Java JDK, where downloading JARs is very common (hence the `curl` base still), but checking out code also becomes more common as well (compared to the JRE).
```
--------------------------------------------------------------------------------
/ibm-semeru-runtimes/logo.svg:
--------------------------------------------------------------------------------
```
<svg id="SemeruRuntimes" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><defs><linearGradient id="mowig1tk4a" x1="-66.645" y1="-182.5" x2="-58.418" y2="-182.5" gradientTransform="translate(79.458 204.458)" gradientUnits="userSpaceOnUse"><stop offset=".071"/><stop offset=".964" stop-opacity="0"/></linearGradient><linearGradient id="ahawze7n2b" x1="2057.037" y1="-1935.038" x2="2062.733" y2="-1935.038" gradientTransform="matrix(1.978 0 0 .583 -4065.838 1144.613)" gradientUnits="userSpaceOnUse"><stop offset=".096"/><stop offset=".964" stop-opacity="0"/></linearGradient><linearGradient id="y76v2m5qld" x1=".098" y1="31.902" x2="31.702" y2=".298" gradientUnits="userSpaceOnUse"><stop offset=".1" stop-color="#ee5396"/><stop offset=".9" stop-color="#8a3ffc"/></linearGradient><mask id="ozj5xxp58c" x="0" y="0" width="32" height="32" maskUnits="userSpaceOnUse"><path d="M25.5 28h-8a4.491 4.491 0 0 1-1.326-8.784 5.472 5.472 0 0 1 10.652 0A4.491 4.491 0 0 1 25.5 28zm-4-11a3.477 3.477 0 0 0-3.459 3.146l-.08.789-.785.1A2.492 2.492 0 0 0 17.5 26h8a2.492 2.492 0 0 0 .324-4.963l-.785-.1-.08-.789A3.477 3.477 0 0 0 21.5 17z" style="fill:#fff"/><path transform="rotate(-90 17 21.958)" style="fill:url(#mowig1tk4a)" d="M12.666 16.958h8.667v10h-8.667z" id="Gradients_black_" data-name="Gradients (black)"/><path d="M23 28H3a1 1 0 0 1-.861-1.509l8.864-15 1.722 1.018L4.752 26H23z" style="fill:#fff"/><path transform="rotate(121.2 9.061 17)" style="fill:url(#ahawze7n2b)" d="M3.127 14.96h11.869v4.079H3.127z" id="Gradients_black_2" data-name="Gradients (black)"/></mask></defs><g style="mask:url(#ozj5xxp58c)"><path style="fill:url(#y76v2m5qld)" d="M0 0h32v32H0z"/></g><path style="fill:#001d6c" d="M13.025 12 16 6.966 18.975 12h2.323L16 3.034 10.702 12h2.323z"/></svg>
```
--------------------------------------------------------------------------------
/almalinux/content.md:
--------------------------------------------------------------------------------
```markdown
# AlmaLinux OS
[AlmaLinux OS](https://almalinux.org/) is an Open Source and forever-free enterprise Linux distribution, governed and driven by the community, focused on long-term stability and a robust production-grade platform. AlmaLinux OS is binary compatible with RHEL®, and it was founded by the team behind the well-established [CloudLinux OS](https://www.cloudlinux.com/all-products/product-overview/cloudlinuxos). Today, the AlmaLinux OS Foundation, run by a community-elected board of directors, owns and manages the operating system.
%%LOGO%%
# About this image
## Platform image
The default (platform) image is a general-purpose image with a full DNF stack and basic tools like find, tar, vi, etc.
The `%%IMAGE%%:latest` tag will always point to the latest stable release of the default image. Major releases and minor releases are also tagged with their version (e.g. `%%IMAGE%%:8` or `%%IMAGE%%:8.4`).
## Minimal image
The minimal image is a stripped-down image that uses the microdnf package manager and contains a very limited package set. It is designed for applications that come with their own dependencies bundled (e.g. NodeJS, Python).
The `%%IMAGE%%:minimal` tag always points to the most recent version of the minimal image. Tags for major (e.g. `%%IMAGE%%:8-minimal`) and minor (e.g. `%%IMAGE%%:8.4-minimal`) releases are also available.
### Upgrade policy
All images for supported releases will be updated monthly or as needed for security fixes.
## How It's Made
The rootfs tarballs for this image are built using the [livemedia-creator tool](http://weldr.io/lorax/livemedia-creator.html). The build script and kickstart files are available in the [AlmaLinux/docker-images](https://github.com/AlmaLinux/docker-images) git repository.
```
--------------------------------------------------------------------------------
/spark/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Apache Spark™?
Apache Spark™ is a multi-language engine for executing data engineering, data science, and machine learning on single-node machines or clusters. It provides high-level APIs in Scala, Java, Python, and R, and an optimized engine that supports general computation graphs for data analysis. It also supports a rich set of higher-level tools including Spark SQL for SQL and DataFrames, pandas API on Spark for pandas workloads, MLlib for machine learning, GraphX for graph processing, and Structured Streaming for stream processing.
%%LOGO%%
## Online Documentation
You can find the latest Spark documentation, including a programming guide, on the [project web page](https://spark.apache.org/documentation.html). This README file only contains basic setup instructions.
## Interactive Scala Shell
The easiest way to start using Spark is through the Scala shell:
```console
docker run -it %%IMAGE%% /opt/spark/bin/spark-shell
```
Try the following command, which should return 1,000,000,000:
```scala
scala> spark.range(1000 * 1000 * 1000).count()
```
## Interactive Python Shell
The easiest way to start using PySpark is through the Python shell:
```console
docker run -it %%IMAGE%%:python3 /opt/spark/bin/pyspark
```
And run the following command, which should also return 1,000,000,000:
```python
>>> spark.range(1000 * 1000 * 1000).count()
```
## Interactive R Shell
The easiest way to start using R on Spark is through the R shell:
```console
docker run -it %%IMAGE%%:r /opt/spark/bin/sparkR
```
## Running Spark on Kubernetes
https://spark.apache.org/docs/latest/running-on-kubernetes.html
## Configuration and environment variables
See more in https://github.com/apache/spark-docker/blob/master/OVERVIEW.md#environment-variable
```
--------------------------------------------------------------------------------
/logstash/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Logstash?
Logstash is an open source data collection engine with real-time pipelining capabilities. Logstash can dynamically unify data from disparate sources and normalize the data into destinations of your choice.
Collection is accomplished via a number of configurable input plugins including raw socket/packet communication, file tailing and several message bus clients. Once an input plugin has collected data it can be processed by any number of filters which modify and annotate the event data. Finally, events are routed to output plugins which can forward the events to a variety of external programs including Elasticsearch, local files and several message bus implementations.
> For more information about Logstash, please visit [www.elastic.co/products/logstash](https://www.elastic.co/products/logstash)
%%LOGO%%
# About This Image
This default distribution is governed by the Elastic License and includes the [full set of free features](https://www.elastic.co/subscriptions).
View the detailed release notes [here](https://www.elastic.co/guide/en/logstash/current/releasenotes.html).
Not the version you're looking for? View all supported [past releases](https://www.docker.elastic.co).
# How to use this image
**Note:** Pulling an image requires using a specific version number tag. The `latest` tag is not supported.
For Logstash versions prior to 6.4.0, a full list of images, tags, and documentation can be found at [docker.elastic.co](https://www.docker.elastic.co/).
For full Logstash documentation see [here](https://www.elastic.co/guide/en/logstash/current/index.html).
For instructions specifically related to running the Docker image, see [this section](https://www.elastic.co/guide/en/logstash/current/docker-config.html) of the Logstash documentation.
```
--------------------------------------------------------------------------------
/rocket.chat/content.md:
--------------------------------------------------------------------------------
```markdown
# Rocket.Chat
Rocket.Chat is a Web Chat Server, developed in JavaScript, using the Meteor fullstack framework.
It is a great solution for communities and companies wanting to privately host their own chat service or for developers looking forward to build and evolve their own chat platforms.
%%LOGO%%
# How to use this image
First, start an instance of mongo and initiate replicaSet:
```console
$ docker run --name db -d mongo:4.0 --smallfiles --replSet rs0 --oplogSize 128
```
```console
$ docker exec -ti db mongo --eval "printjson(rs.initiate())"
```
Then start Rocket.Chat linked to this mongo instance:
```console
$ docker run --name rocketchat --link db --env MONGO_OPLOG_URL=mongodb://db:27017/local -d %%IMAGE%%
```
This will start a Rocket.Chat instance listening on the default Meteor port of 3000 on the container.
If you'd like to be able to access the instance directly at standard port on the host machine:
```console
$ docker run --name rocketchat -p 80:3000 --link db --env ROOT_URL=http://localhost --env MONGO_OPLOG_URL=mongodb://db:27017/local -d %%IMAGE%%
```
Then, access it via `http://localhost` in a browser. Replace `localhost` in `ROOT_URL` with your own domain name if you are hosting at your own domain.
If you're using a third party Mongo provider, or working with Kubernetes, you need to override the `MONGO_URL` environment variable:
```console
$ docker run --name rocketchat -p 80:3000 --env ROOT_URL=http://localhost --env MONGO_URL=mongodb://mymongourl/mydb --env MONGO_OPLOG_URL=mongodb://mymongourl:27017/local -d %%IMAGE%%
```
### Check our docs
For full documentation on production deployment best practices, please visit https://rocket.chat/docs/installation/docker-containers/
Need some help? Join our community forums https://forums.rocket.chat
```
--------------------------------------------------------------------------------
/gcc/content.md:
--------------------------------------------------------------------------------
```markdown
# What is GCC?
The GNU Compiler Collection (GCC) is a compiler system produced by the GNU Project that supports various programming languages. GCC is a key component of the GNU toolchain. The Free Software Foundation (FSF) distributes GCC under the GNU General Public License (GNU GPL). GCC has played an important role in the growth of free software, as both a tool and an example.
> [wikipedia.org/wiki/GNU_Compiler_Collection](https://en.wikipedia.org/wiki/GNU_Compiler_Collection)
%%LOGO%%
# How to use this image
## Start a GCC instance running your app
The most straightforward way to use this image is to use a gcc container as both the build and runtime environment. In your `Dockerfile`, writing something along the lines of the following will compile and run your project:
```dockerfile
FROM %%IMAGE%%:4.9
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
RUN gcc -o myapp main.c
CMD ["./myapp"]
```
Then, build and run the Docker image:
```console
$ docker build -t my-gcc-app .
$ docker run -it --rm --name my-running-app my-gcc-app
```
## Compile your app inside the Docker container
There may be occasions where it is not appropriate to run your app inside a container. To compile, but not run your app inside the Docker instance, you can write something like:
```console
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:4.9 gcc -o myapp myapp.c
```
This will add your current directory, as a volume, to the container, set the working directory to the volume, and run the command `gcc -o myapp myapp.c.` This tells gcc to compile the code in `myapp.c` and output the executable to myapp. Alternatively, if you have a `Makefile`, you can instead run the `make` command inside your container:
```console
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:4.9 make
```
```
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
FROM perl:5.39-bookworm
RUN set -eux; \
apt-get update; \
apt-get install -y --no-install-recommends \
vim \
# https://bugs.debian.org/763056 - SVG rendering in ImageMagick looks awful unless it can use inkscape to render (or RSVG, which is explicitly not compiled into the Debian package??)
inkscape \
; \
rm -rf /var/lib/apt/lists/*
# secure by default ♥ (thanks to sri!)
ENV PERL_CPANM_OPT --verbose --mirror https://cpan.metacpan.org
# TODO find a way to make --mirror-only / SSL work with backpan too :(
RUN cpanm Digest::SHA Module::Signature
# TODO find a way to make --verify work with backpan as well :'(
#ENV PERL_CPANM_OPT $PERL_CPANM_OPT --verify
# reinstall cpanm itself, for good measure
RUN cpanm App::cpanminus
RUN cpanm [email protected]
RUN cpanm EV
RUN cpanm IO::Socket::IP
RUN cpanm --notest IO::Socket::SSL
# the tests for IO::Socket::SSL like to hang... :(
RUN cpanm Term::UI
ENV LANG C.UTF-8
RUN mkdir ~/.vim ~/.vim/bundle ~/.vim/autoload
RUN set -x \
&& git clone https://github.com/tpope/vim-pathogen.git ~/.vim/bundle/pathogen \
&& ln -s ../bundle/pathogen/autoload/pathogen.vim ~/.vim/autoload/
RUN git clone https://github.com/jtratner/vim-flavored-markdown.git ~/.vim/bundle/ghmarkdown
RUN git clone https://github.com/nanotech/jellybeans.vim.git ~/.vim/bundle/jellybeans
RUN { \
echo 'scriptencoding utf-8'; \
\
echo 'execute pathogen#infect()'; \
\
echo 'syntax on'; \
echo 'filetype plugin indent on'; \
echo 'set list listchars=tab:»·,nbsp:_,extends:¬ noet ts=4 sw=4 nobackup noswapfile'; \
\
echo 'set background=dark'; \
echo 'colorscheme jellybeans'; \
\
echo 'au FilterWritePre * if &diff | setlocal wrap< | endif'; \
\
echo 'au BufNewFile,BufRead *.md,*.markdown setlocal filetype=ghmarkdown'; \
} > ~/.vimrc
COPY . /usr/src/docker-library-docs
WORKDIR /usr/src/docker-library-docs
CMD ["./push.pl"]
```
--------------------------------------------------------------------------------
/haxe/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Haxe?
[Haxe](https://haxe.org) is an open source toolkit based on a modern, high level, strictly typed programming language, a cross-compiler, a complete cross-platform standard library and ways to access each platform's native capabilities.
The Haxe compiler can output a number of source and binary files. As of Haxe 3.4.0-rc.1, the Haxe compiler can target JavaScript, Java, C#, C++, Python, PHP, Flash SWF, ActionScript 3, Lua, and Neko.
%%LOGO%%
# About this image
This image ships a minimal Haxe toolkit:
- the `haxe` compiler with its standard library
- the `haxelib` library manager
- the `neko` virtual machine
# How to use this image
The most straightforward way to use this image is to use a Haxe container as both the build and runtime environment. In your `Dockerfile`, writing something along the lines of the following will compile and run your project:
```dockerfile
FROM %%IMAGE%%:3.4
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
# install dependencies
COPY *.hxml /usr/src/app/
RUN yes | haxelib install all
# compile the project
COPY . /usr/src/app
RUN haxe build.hxml
# run the output when the container starts
CMD ["neko", "Main.n"]
```
Then, build and run the Docker image:
```console
$ docker build -t my-haxe-app .
$ docker run -it --rm --name my-running-app my-haxe-app
```
## Using the onbuild variants
There are `onbuild` variants that include multiple `ONBUILD` triggers to perform all of the steps in the above Dockerfile, except there is no `CMD` instruction for running the compilation output.
Rewriting the above Dockerfile with `%%IMAGE%%:3.4-onbuild`, we will get:
```dockerfile
FROM %%IMAGE%%:3.4-onbuild
# run the output when the container starts
CMD ["neko", "Main.n"]
```
The `onbuild` variants assume the main compilation hxml file is named `build.hxml`. To use another hxml file, set the `BUILD_HXML` build argument during build:
```console
$ docker build -t my-haxe-app --build-arg BUILD_HXML=compile.hxml .
```
```
--------------------------------------------------------------------------------
/elasticsearch/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Elasticsearch?
Elasticsearch is a distributed, RESTful search and analytics engine capable of solving a growing number of use cases. As the heart of the Elastic Stack, it centrally stores your data so you can discover the expected and uncover the unexpected.
> For more information about Elasticsearch, please visit [www.elastic.co/products/elasticsearch](https://www.elastic.co/products/elasticsearch)
%%LOGO%%
# About This Image
This default distribution is governed by the Elastic License, and includes the [full set of free features](https://www.elastic.co/subscriptions).
View the detailed release notes [here](https://www.elastic.co/guide/en/elasticsearch/reference/current/es-release-notes.html).
Not the version you're looking for? View all supported [past releases](https://www.docker.elastic.co).
# How to use this image
**Note:** Pulling an images requires using a specific version number tag. The `latest` tag is not supported.
For Elasticsearch versions prior to 6.4.0 a full list of images, tags, and documentation can be found at [docker.elastic.co](https://www.docker.elastic.co/).
For full Elasticsearch documentation see [here](https://www.elastic.co/guide/en/elasticsearch/reference/index.html).
**The commands below are intended for deploying in a development context only. For production installation and configuration, see [Install Elasticsearch with Docker](https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docker.html).**
## Running in Development Mode
Create user defined network (useful for connecting to other services attached to the same network (e.g. Kibana)):
```console
$ docker network create somenetwork
```
Run Elasticsearch:
```console
$ docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag
```
## Running in Production Mode
See [Install Elasticsearch with Docker](https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docker.html)
```
--------------------------------------------------------------------------------
/api-firewall/logo.svg:
--------------------------------------------------------------------------------
```
<?xml version="1.0" encoding="utf-8"?>
<!-- Generator: Adobe Illustrator 19.2.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
<svg version="1.1" id="layer" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
viewBox="0 0 652 652" style="enable-background:new 0 0 652 652;" xml:space="preserve" width="250" height="168">
<style type="text/css">
.st0{fill:#FF5D18;}
</style>
<path class="st0" d="M572.5,257.4v-57L458.2,251v-72.9l-115.6,51.3v115.4l114.3-50.7v33.4l114.2-50.6v20.3l54.9-24.4v-39.1
L572.5,257.4"/>
<path d="M124,444.8l18.6-62.1h20.9L133.7,474H115l-20.4-62l-20.5,62H55.5L26,382.6h21.4l18.3,62.1l20.2-62.5h17.8L124,444.8
M263.5,474h20.8V344.8h-20.8V474z M296.8,474h20.8V344.8h-20.8L296.8,474z M447.3,474H426V384h21.3v20.3
c5.8-13.5,16.5-22.7,32.9-22v21.8h-1.2c-18.6,0-31.7,11.8-31.7,35.6V474z M594.3,382.3c19.7,0,31.7,12.4,31.7,34.4V474h-20.7v-51
c0-14.3-6.7-21.9-18.3-21.9c-11.3,0-19.3,7.8-19.3,22.3V474h-20.7v-51.2c0-14-6.8-21.8-18.3-21.8c-11.5,0-19.4,8.5-19.4,22.4V474
h-20.7v-89.8h20.7v13.6c5.8-8,13.7-15.5,27.6-15.5c13,0,22.1,6.3,26.9,15.8C571,388.6,580.6,382.3,594.3,382.3 M393.1,440.1
c0,11.1-10.4,18.6-24.4,18.6c-9.9,0-17.7-4.7-17.7-13.1v-0.3c0-9,7.8-14.2,21-14.2c8.2,0,15.7,1.5,21.1,3.5L393.1,440.1z
M373.1,382.3c-11.3,0-19.7,1.7-27.4,4.4v18.5c7.7-2.9,15-4.8,24.5-4.8c14.6,0,22.6,6.7,22.6,18.9v2.2c-7.1-2.2-14.3-3.7-25.4-3.7
c-21.4,0-37.2,9.4-37.2,28.5v0.3c0,17.8,15.3,27.3,32.7,27.3c13.9,0,23.5-5.5,29.8-12.7v10.9h20.9v-52.5
C413.5,396,400.3,382.3,373.1,382.3L373.1,382.3z M226.5,440.1c0,11.1-10.4,18.6-24.4,18.6c-9.9,0-17.7-4.7-17.7-13.1v-0.3
c0-9,7.8-14.2,21.1-14.2c8.2,0,15.7,1.5,21.1,3.5V440.1z M206.5,382.3c-11.9,0-20.6,1.9-28.7,4.9v18.5c8.2-3.2,15.7-5.3,25.8-5.3
c14.6,0,22.6,6.7,22.6,18.9v2.2c-7.1-2.2-14.3-3.7-25.4-3.7c-21.4,0-37.2,9.4-37.2,28.5v0.3c0,17.8,15.3,27.3,32.7,27.3
c13.9,0,23.5-5.5,29.8-12.7v10.9h20.9v-52.5C246.8,396,233.6,382.3,206.5,382.3L206.5,382.3z"/>
</svg>
```
--------------------------------------------------------------------------------
/postfixadmin/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Postfix Admin?
Postfix Admin is a web based interface to configure and manage a Postfix based email server for many users. Features include support for virtual domains and aliases, quotas, and vacation/out-of-the-office messages. It requires PHP, Postfix and one of MySQL, PostgreSQL or SQLite.
%%LOGO%%
# How to use this image
## No config.local.php / no existing setup
If you do not have a config.local.php, then we fall back to look for environment variables to generate one.
```console
$ docker run -e POSTFIXADMIN_DB_TYPE=mysqli \
-e POSTFIXADMIN_DB_HOST=whatever \
-e POSTFIXADMIN_DB_USER=user \
-e POSTFIXADMIN_DB_PASSWORD=topsecret \
-e POSTFIXADMIN_DB_NAME=postfixadmin \
--name some-%%REPO%% \
%%IMAGE%%
```
`POSTFIXADMIN_DB_TYPE` can be one of :
- mysqli
- pgsql
- sqlite
Note: An SQLite database is not recommend but used as a fallback if you do not have a config.local.php and do not specify the above variables. Do not forget to add a volume for the SQLite path.
You can also specify a `POSTFIXADMIN_SETUP_PASSWORD` environment variable.
If you'd like to be able to access the instance from the host without the container's IP, standard port mappings can be used:
```console
$ docker run -e POSTFIXADMIN_DB_TYPE=mysqli \
-e POSTFIXADMIN_DB_HOST=whatever \
-e POSTFIXADMIN_DB_USER=user \
-e POSTFIXADMIN_DB_PASSWORD=topsecret \
-e POSTFIXADMIN_DB_NAME=postfixadmin \
--name some-%%REPO%% \
-p 8080:80
%%IMAGE%%
```
Then, access it via `http://localhost:8080` or `http://host-ip:8080` in a browser.
## Existing config.local.php
```console
$ docker run -v /local/path/to/config.local.php:/var/www/html/config.local.php \
--name some-%%REPO%% \
-p 8080:80 \
%%IMAGE%%
```
%%COMPOSE%%
Run `docker compose up`, wait for it to initialize completely, and visit `http://localhost:8080` or `http://host-ip:8080` (as appropriate).
```
--------------------------------------------------------------------------------
/kibana/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Kibana?
Kibana is an open source analytics and visualization platform designed to work with Elasticsearch. You use Kibana to search, view, and interact with data stored in Elasticsearch indices. You can easily perform advanced data analysis and visualize your data in a variety of charts, tables, and maps.
> For more information about Kibana, please visit [www.elastic.co/products/kibana](https://www.elastic.co/products/kibana)
%%LOGO%%
# About This Image
This default distribution is governed by the Elastic License, and includes the [full set of free features](https://www.elastic.co/subscriptions).
View the detailed release notes [here](https://www.elastic.co/guide/en/kibana/current/release-notes.html).
Not the version you're looking for? View all supported [past releases](https://www.docker.elastic.co).
# How to use this image
**Note:** Pulling an images requires using a specific version number tag. The `latest` tag is not supported.
For Kibana versions prior to 6.4.0 a full list of images, tags, and documentation can be found at [docker.elastic.co](https://www.docker.elastic.co/).
For full Kibana documentation see [here](https://www.elastic.co/guide/en/kibana/index.html).
## Running in Development Mode
In the given example, Kibana will a attach to a user defined network (useful for connecting to other services (e.g. Elasticsearch)). If network has not yet been created, this can be done with the following command:
```console
$ docker network create somenetwork
```
*Note: In this example, Kibana is using the default configuration and expects to connect to a running Elasticsearch instance at http://localhost:9200*
Run Kibana
```console
$ docker run -d --name kibana --net somenetwork -p 5601:5601 kibana:tag
```
Kibana can be accessed by browser via `http://localhost:5601` or `http://host-ip:5601`
## Running in Production Mode
For additional information on running and configuring Kibana on Docker, see [Running Kibana on Docker](https://www.elastic.co/guide/en/kibana/current/docker.html)
```
--------------------------------------------------------------------------------
/jruby/content.md:
--------------------------------------------------------------------------------
```markdown
# What is JRuby?
JRuby (http://www.jruby.org) is an implementation of Ruby (http://www.ruby-lang.org) on the JVM.
Ruby is a dynamic, reflective, object-oriented, general-purpose, open-source programming language. According to its authors, Ruby was influenced by Perl, Smalltalk, Eiffel, Ada, and Lisp. It supports multiple programming paradigms, including functional, object-oriented, and imperative. It also has a dynamic type system and automatic memory management.
> [wikipedia.org/wiki/Ruby_(programming_language)](https://en.wikipedia.org/wiki/Ruby_%28programming_language%29)
JRuby leverages the robustness and speed of the JVM while providing the same Ruby that you already know and love. With JRuby you are able to take advantage of real native threads, enhanced garbage collection, and even import and use java libraries.
%%LOGO%%
# How to use this image
## Create a `Dockerfile` in your Ruby app project
```dockerfile
FROM %%IMAGE%%:9
# throw errors if Gemfile has been modified since Gemfile.lock
RUN bundle config --global frozen 1
WORKDIR /usr/src/app
COPY Gemfile Gemfile.lock ./
RUN bundle install
COPY . .
CMD ["./your-daemon-or-script.rb"]
```
Put this file in the root of your app, next to the `Gemfile`.
You can then build and run the Ruby image:
```console
$ docker build -t my-ruby-app .
$ docker run -it --name my-running-script my-ruby-app
```
### Generate a `Gemfile.lock`
The above example `Dockerfile` expects a `Gemfile.lock` in your app directory. This `docker run` will help you generate one. Run it in the root of your app, next to the `Gemfile`:
```console
$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%%:9 bundle install --system
```
## Run a single Ruby script
For many simple, single file projects, you may find it inconvenient to write a complete `Dockerfile`. In such cases, you can run a Ruby script by using the Ruby Docker image directly:
```console
$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:9 jruby your-daemon-or-script.rb
```
```
--------------------------------------------------------------------------------
/eclipse-mosquitto/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Eclipse Mosquitto?
Eclipse Mosquitto is an open source implementation of a server for versions 5, 3.1.1, and 3.1 of the MQTT protocol. Main homepage: http://mosquitto.org/
%%LOGO%%
# Eclipse Mosquitto and Cedalo
[Cedalo](https://cedalo.com/?utm_source=docker-mosquitto&utm_medium=text&utm_campaign=cedalo-name) provides commercial support, enterprise MQTT products, professional services and training for Eclipse Mosquitto.
# How to use this image
## Directories
Three directories have been created in the image to be used for configuration, persistent storage and logs.
/mosquitto/config
/mosquitto/data
/mosquitto/log
It is suggested to mirror this structure for your local configuration.
## Configuration
When running the image, the default configuration values are used. To use a custom configuration file, create your mosquitto.conf in `$PWD/mosquitto/config/mosquitto.conf`, then mount the config directory to `/mosquitto/config`.
```console
$ docker run -it -p 1883:1883 -v "$PWD/mosquitto/config:/mosquitto/config" %%IMAGE%%
```
Configuration can be changed to:
- persist data to `/mosquitto/data`
- log to `/mosquitto/log/mosquitto.log`
i.e. add the following to `mosquitto.conf`:
persistence true
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log
**Note**: If a volume is used, the data will persist between containers.
## Run
Run a container using the new image:
```console
$ docker run -it -p 1883:1883 -v "$PWD/mosquitto/config:/mosquitto/config" -v /mosquitto/data -v /mosquitto/log %%IMAGE%%
```
or:
```console
$ docker run -it -p 1883:1883 -v "$PWD/mosquitto/config:/mosquitto/config" -v "$PWD/mosquitto/data:/mosquitto/data" -v "$PWD/mosquitto/log:/mosquitto/log" %%IMAGE%%
```
**Note**: if the mosquitto configuration (mosquitto.conf) was modified to use non-default ports, the docker run command will need to be updated to expose the ports that have been configured.
For example, if you use port 1883 and port 8080:
```console
$ docker run -it -p 1883:1883 -p 8080:8080 -v "$PWD/mosquitto/config:/mosquitto/config" %%IMAGE%%
```
```
--------------------------------------------------------------------------------
/tomcat/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Tomcat?
Apache Tomcat (or simply Tomcat) is an open source web server and servlet container developed by the Apache Software Foundation (ASF). Tomcat implements the Java Servlet and the JavaServer Pages (JSP) specifications from Oracle, and provides a "pure Java" HTTP web server environment for Java code to run in. In the simplest config Tomcat runs in a single operating system process. The process runs a Java virtual machine (JVM). Every single HTTP request from a browser to Tomcat is processed in the Tomcat process in a separate thread.
> [wikipedia.org/wiki/Apache_Tomcat](https://en.wikipedia.org/wiki/Apache_Tomcat)
%%LOGO%% Logo © Apache Software Fountation
# How to use this image.
**Note:** as of [docker-library/tomcat#181](https://github.com/docker-library/tomcat/pull/181), the upstream-provided (example) webapps are *not* enabled by default, per [upstream's security recommendations](https://tomcat.apache.org/tomcat-9.0-doc/security-howto.html#Default_web_applications), but are still available under the `webapps.dist` folder within the image to make them easier to re-enable.
Run the default Tomcat server (`CMD ["catalina.sh", "run"]`):
```console
$ docker run -it --rm %%IMAGE%%:9.0
```
You can test it by visiting `http://container-ip:8080` in a browser or, if you need access outside the host, on port 8888:
```console
$ docker run -it --rm -p 8888:8080 %%IMAGE%%:9.0
```
You can then go to `http://localhost:8888` or `http://host-ip:8888` in a browser (noting that it will return a 404 since there are no webapps loaded by default).
The default Tomcat environment in the image is:
CATALINA_BASE: /usr/local/tomcat
CATALINA_HOME: /usr/local/tomcat
CATALINA_TMPDIR: /usr/local/tomcat/temp
JRE_HOME: /usr
CLASSPATH: /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
The configuration files are available in `/usr/local/tomcat/conf/`. By default, no user is included in the "manager-gui" role required to operate the "/manager/html" web application. If you wish to use this app, you must define such a user in `tomcat-users.xml`.
```
--------------------------------------------------------------------------------
/chronograf/content.md:
--------------------------------------------------------------------------------
```markdown
# Chronograf
Chronograf is InfluxData's open source web application. Use Chronograf with the other components of the [TICK](https://www.influxdata.com/products/) stack for infrastructure monitoring, alert management, data visualization, and database management.
%%LOGO%%
## Using this image
### Running the container
Chronograf runs on port 8888. It can be run and accessed by exposing that port:
```console
$ docker run -p 8888:8888 %%IMAGE%%
```
### Mounting a volume
The Chronograf image exposes a shared volume under `/var/lib/chronograf`, so you can mount a host directory to that point to access persisted container data. A typical invocation of the container might be:
```console
$ docker run -p 8888:8888 \
-v $PWD:/var/lib/chronograf \
%%IMAGE%%
```
Modify `$PWD` to the directory where you want to store data associated with the InfluxDB container.
You can also have Docker control the volume mountpoint by using a named volume.
```console
$ docker run -p 8888:8888 \
-v chronograf:/var/lib/chronograf \
%%IMAGE%%
```
### Using the container with InfluxDB
The instructions here are very similar to the instructions when using `telegraf` with `influxdb`. These examples assume you are using Docker's built-in service discovery capability. In order to do so, we'll first create a new network:
```console
$ docker network create influxdb
```
Next, we'll start our InfluxDB container named `influxdb`:
```console
$ docker run -d --name=influxdb \
--net=influxdb \
influxdb
```
We can now start a Chronograf container that references this database.
```console
$ docker run -p 8888:8888 \
--net=influxdb \
%%IMAGE%% --influxdb-url=http://influxdb:8086
```
Try combining this with Telegraf to get dashboards for your infrastructure within minutes!
#### Running as root
Starting in v1.10.5, Chronograf no longer run as the root user by default. If a user wants to revert this change they can set `CHRONOGRAF_AS_ROOT=true` as an environment variable.
## Official Documentation
See the [official docs](https://docs.influxdata.com/chronograf/latest/) for information on creating visualizations.
```
--------------------------------------------------------------------------------
/alt/content.md:
--------------------------------------------------------------------------------
```markdown
# ALT Linux
This image serves as the `official ALT image` for the [ALT Linux](https://altlinux.org/).
%%LOGO%%
# ALT Linux Team
[ALT Linux Team](http://www.altlinux.org/ALT_Linux_Team) is an international community numbering over 200 free software developers.
# Sisyphus
[Sisyphus](https://packages.altlinux.org/ru/Sisyphus/home) is a daily updated repository which serves as a basis for all ALT distributions. Sisyphus integrity supported by the ALT Linux Team, the original software packaging technology, and apt-get (apt-rpm) utility allows users to easily update the system and be aware of any news on the free software. This daily updated repository contains the latest software with all its benefits and pitfalls (latent sometimes).
The name Sisyphus comes from the Greek mythology. Uninterrupted efforts on improvement of technologies set in the repository make ALT Linux Team similar to tireless Sisyphus continuously rolling stones up the hill.
# About Platform 9
As said above, Sisyphus is a frequently updated repository mainly designed for developers. Stable distributions by ALT are the best solution for those users preferring stability and predictability of the system to its functionality (primarily new and corporate users). Such stable distributions are based on stable Sisyphus repository slices called platforms. Platform 9 (p9) was created in June, 2019, and will be supported till December, 2022.
# About this image
The `%%IMAGE%%:latest` tag will always point the latest stable release (which is, at the time of this writing, `%%IMAGE%%:p9`).
## How It's Made
This image was created with the help of mkimage and hasher tools.
[Mkimage](https://en.altlinux.org/Mkimage) is a tool used to create images with Linux kernel from the set Sisyphus-like repository. Mkimage uses a set of Makefiles and shell hooks.
[Hasher](https://en.altlinux.org/Hasher) is a tool used for safe and repeatable packaging in clean and controllable environment. This is achieved through creation of a minimum build environment in chroot, installation of all necessary packaging dependencies there, and packet assembly in the new environment. Every package requires a new build environment.
```
--------------------------------------------------------------------------------
/spiped/content.md:
--------------------------------------------------------------------------------
```markdown
# spiped
## What is spiped?
Spiped (pronounced "ess-pipe-dee") is a utility for creating symmetrically encrypted and authenticated pipes between socket addresses, so that one may connect to one address (e.g., a UNIX socket on localhost) and transparently have a connection established to another address (e.g., a UNIX socket on a different system). This is similar to `ssh -L` functionality, but does not use SSH and requires a pre-shared symmetric key.
> [tarsnap.com/spiped.html](https://www.tarsnap.com/spiped.html)
## How to use this image
This image automatically takes the key from the `/spiped/key` file (`-k`) and runs spiped in foreground (`-F`). Other than that it takes the same options *spiped* itself does. You can list the available flags by running the image without arguments:
```console
$ docker run -it --rm %%IMAGE%%
usage: spiped {-e | -d} -s <source socket> -t <target socket> -k <key file>
[-DFj] [-f | -g] [-n <max # connections>] [-o <connection timeout>]
[-p <pidfile>] [-r <rtime> | -R]
```
For example running spiped to take encrypted connections on port 8025 and forward them to port 25 on localhost would look like this:
```console
$ docker run -d -v /path/to/keyfile:/spiped/key:ro -p 8025:8025 --init %%IMAGE%% -d -s '[0.0.0.0]:8025' -t '[127.0.0.1]:25'
```
Usually you would combine this image with another linked container. The following example would take encrypted connections on port 9200 and forward them to port 9200 in the container with the name `elasticsearch`:
```console
$ docker run -d -v /path/to/keyfile:/spiped/key:ro -p 9200:9200 --link elasticsearch:elasticsearch --init %%IMAGE%% -d -s '[0.0.0.0]:9200' -t 'elasticsearch:9200'
```
If you don't need any to bind to a privileged port you can pass `--user spiped` to make *spiped* run as an unprivileged user:
```console
$ docker run -d -v /path/to/keyfile:/spiped/key:ro --user spiped -p 9200:9200 --link elasticsearch:elasticsearch --init %%IMAGE%% -d -s '[0.0.0.0]:9200' -t 'elasticsearch:9200'
```
### Generating a key
You can save a new keyfile named `spiped-keyfile` to the folder `/path/to/keyfile/` by running:
```console
$ docker run -it --rm -v /path/to/keyfile:/spiped/key %%IMAGE%% spiped-generate-key.sh
```
Afterwards transmit `spiped-keyfile` securely to another host (e.g. by using scp).
```
--------------------------------------------------------------------------------
/unit/logo.svg:
--------------------------------------------------------------------------------
```
<svg xmlns="http://www.w3.org/2000/svg" viewBox="149 203 988 357"><defs><style>.cls-1{fill:#fff;}.cls-2{fill:#232221;}.cls-3{fill:#009639;}</style></defs><g><path class="cls-2" d="M567.73,295.24h0a11.09,11.09,0,0,1,11.09,11.09v92.81q0,26.76,10,40T622,452.41q23.38,0,33-13.38t9.64-39.89V306.33a11.09,11.09,0,0,1,11.09-11.09h0a11.09,11.09,0,0,1,11.09,11.09v92.81q0,19.29-4.46,32.9t-12.78,22.54a48.69,48.69,0,0,1-20.49,13,85.46,85.46,0,0,1-27.36,4.1q-31.1,0-48.09-17.35t-17-56.17V306.33A11.09,11.09,0,0,1,567.73,295.24Z"/><path class="cls-2" d="M730.45,342.72h0a10.37,10.37,0,0,1,10.37,10.37v8.68q9.16-12.3,20.25-17.6a53.53,53.53,0,0,1,23.38-5.3q21.21,0,31.46,11.57t10.24,34v72.44a10.49,10.49,0,0,1-10.49,10.49h0a10.49,10.49,0,0,1-10.49-10.49V388.53q0-17.35-6.27-24.47t-19.28-7.11a41.64,41.64,0,0,0-13.86,2.41,34.27,34.27,0,0,0-12.42,7.71,40.21,40.21,0,0,0-9.16,11.21q-3.13,5.9-3.13,15.31v63.28a10.49,10.49,0,0,1-10.49,10.49h0a10.49,10.49,0,0,1-10.49-10.49V353.09A10.37,10.37,0,0,1,730.45,342.72Z"/><path class="cls-2" d="M868.45,295.24h0a11.21,11.21,0,0,1,11.21,11.21v1.93a11.21,11.21,0,0,1-11.21,11.21h0a11.21,11.21,0,0,1-11.21-11.21v-1.93A11.21,11.21,0,0,1,868.45,295.24Zm0,47.49h0a10.49,10.49,0,0,1,10.49,10.49V456.87a10.49,10.49,0,0,1-10.49,10.49h0A10.49,10.49,0,0,1,858,456.87V353.21A10.49,10.49,0,0,1,868.45,342.72Z"/><path class="cls-2" d="M919,359.36H908a8.32,8.32,0,0,1-8.32-8.32h0a8.32,8.32,0,0,1,8.32-8.32h11v-23.5a10.49,10.49,0,0,1,10.49-10.49h0a10.49,10.49,0,0,1,10.49,10.49v23.5h24.71A8.32,8.32,0,0,1,973,351h0a8.32,8.32,0,0,1-8.32,8.32H939.92v73q0,9.16,4.1,14.7t12.53,5.55a70,70,0,0,0,8.78-1,8.54,8.54,0,0,1,9.69,6.59h0a8.58,8.58,0,0,1-6.54,10.26l-2.17.44A72.17,72.17,0,0,1,952.94,470q-10.61,0-17.12-3.13A25.43,25.43,0,0,1,925.46,458a34.65,34.65,0,0,1-5.18-13.74A105.37,105.37,0,0,1,919,426.86Z"/><path class="cls-3" d="M452.69,284.92,317.13,206.65a21.46,21.46,0,0,0-21.4,0L160.17,284.92a21.46,21.46,0,0,0-10.69,18.53V460a21.45,21.45,0,0,0,10.7,18.53l135.56,78.26a21.46,21.46,0,0,0,21.4,0l135.56-78.26A21.45,21.45,0,0,0,463.39,460V303.45A21.45,21.45,0,0,0,452.69,284.92Z"/><path class="cls-1" d="M384.85,441.92c0,9.29-8.21,17-19.84,17-8.33,0-17.94-3.36-23.81-10.65l-78.27-93.67v87.34a17,17,0,0,1-17,17h-1a17,17,0,0,1-17-17l0-120.42c0-9.29,8.21-17,19.84-17,8.33,0,17.94,3.36,23.81,10.65l78.27,93.67V321.51a17,17,0,0,1,17-17h1a17,17,0,0,1,17,17Z"/></g></svg>
```
--------------------------------------------------------------------------------
/emqx/logo.svg:
--------------------------------------------------------------------------------
```
<?xml version="1.0" encoding="UTF-8"?>
<svg width="320px" height="320px" viewBox="0 0 320 320" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<title>320备份</title>
<g id="320备份" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
<g id="编组-2备份-17" transform="translate(40.000000, 22.000000)" fill="#00B173">
<g id="编组" transform="translate(41.424725, 85.086839)">
<path d="M133.374826,0 L31.0713227,0 L31.0713227,0.0212798466 C30.9290586,0.0148958926 30.7889285,0 30.6459532,0 C25.3352361,0 21.0303258,4.29285438 21.0303258,9.58869887 C21.0303258,14.883834 25.3352361,19.1766884 30.6459532,19.1766884 C30.7889285,19.1766884 30.9290586,19.1617925 31.0713227,19.1554086 L31.0713227,19.1766884 L133.374826,19.1766884 C138.684831,19.1766884 142.990453,14.883834 142.990453,9.58869887 C142.990453,4.29285438 138.684831,0 133.374826,0" id="Fill-4"></path>
<path d="M133.374826,91.3398402 L31.0713227,91.3398402 L31.0713227,91.3604107 C30.9290586,91.354736 30.7889285,91.3398402 30.6459532,91.3398402 C25.3352361,91.3398402 21.0303258,95.6326945 21.0303258,100.928539 C21.0303258,106.222965 25.3352361,110.515819 30.6459532,110.515819 C30.7889285,110.515819 30.9290586,110.501633 31.0713227,110.495249 L31.0713227,110.515819 L133.374826,110.515819 C138.684831,110.515819 142.990453,106.222965 142.990453,100.928539 C142.990453,95.6326945 138.684831,91.3398402 133.374826,91.3398402" id="Fill-6"></path>
<path d="M106.49887,55.2582997 C106.49887,50.2582451 102.659163,46.1569094 97.7603004,45.7135792 L97.7603004,45.6696009 L10.0409968,45.6696009 L10.0409968,45.6908807 C9.89873278,45.6852061 9.75931401,45.6696009 9.61562732,45.6696009 C4.30491023,45.6696009 0,49.9624553 0,55.2582997 C0,60.5541442 4.30491023,64.8469986 9.61562732,64.8469986 C9.75931401,64.8469986 9.89873278,64.8313934 10.0409968,64.8250094 L10.0409968,64.8469986 L97.7603004,64.8469986 L97.7603004,64.8023109 C102.659163,64.3596901 106.49887,60.2583544 106.49887,55.2582997" id="Fill-8"></path>
</g>
<path d="M240,69.25 L120,0 L0,69.25 L0,207.75 L120,277 L240,207.75 L240,69.25 Z M120,20.7115288 L222.048512,79.6057644 L222.048512,197.381421 L120,256.275657 L17.9386675,197.381421 L17.9386675,79.6057644 L120,20.7115288 Z" id="多边形" fill-rule="nonzero"></path>
</g>
</g>
</svg>
```
--------------------------------------------------------------------------------
/matomo/content.md:
--------------------------------------------------------------------------------
```markdown
# Matomo (formerly Piwik)
[Matomo](https://matomo.org/) (formerly Piwik) is the leading open-source analytics platform that gives you more than just powerful analytics:
- Free open-source software
- 100% data ownership
- User privacy protection
- User-centric insights
- Customisable and extensible
%%LOGO%%
# How to use this image
You can run the Matomo container and service like so:
```bash
docker run -d --link some-mysql:db %%IMAGE%%
```
This assumes you've already launched a suitable MySQL or MariaDB database container.
## Persistent data
Use a Docker volume to keep persistent data:
```bash
docker run -d -p 8080:80 --link some-mysql:db -v matomo:/var/www/html %%IMAGE%%
```
## Matomo Installation
Once you're up and running, you'll arrive at the configuration wizard page. If you're using the compose file, at the `Database Setup` step, please enter the following:
- Database Server: `db`
- Login: MYSQL_USER
- Password: MYSQL_PASSWORD
- Database Name: MYSQL_DATABASE
And leave the rest as default.
Then you can continue the installation with the super user.
The following environment variables are also honored for configuring your Matomo instance:
- `MATOMO_DATABASE_HOST`
- `MATOMO_DATABASE_ADAPTER`
- `MATOMO_DATABASE_TABLES_PREFIX`
- `MATOMO_DATABASE_USERNAME`
- `MATOMO_DATABASE_PASSWORD`
- `MATOMO_DATABASE_DBNAME`
The PHP memory limit can be configured with the following environment variable:
- `PHP_MEMORY_LIMIT`
## Docker Compose examples and log import instructions
A minimal set-up using Docker Compose is available in the [.examples folder](%%GITHUB-REPO%%/tree/master/.examples).
If you want to use the import logs script, you can then run the following container as needed, in order to execute the python import logs script:
```bash
docker run --rm --volumes-from="matomo-app-1" --link matomo-app-1 python:3-alpine python /var/www/html/misc/log-analytics/import_logs.py --url=http://ip.of.your.matomo.example --login=yourlogin --password=yourpassword --idsite=1 --recorders=4 /var/www/html/logs/access.log
```
## Contribute
Pull requests are very welcome!
We'd love to hear your feedback and suggestions in the issue tracker: [%%ISSUES%%](%%ISSUES%%).
## GeoIP
~~This product includes GeoLite data created by MaxMind, available from [https://www.maxmind.com](https://www.maxmind.com).~~ https://blog.maxmind.com/2019/12/18/significant-changes-to-accessing-and-using-geolite2-databases/
```
--------------------------------------------------------------------------------
/bash/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Bash?
Bash is the [GNU](http://www.gnu.org/) Project's Bourne Again SHell, a complete implementation of the [IEEE POSIX and Open Group shell specification](http://www.opengroup.org/onlinepubs/9699919799/nfindex.html) with interactive command line editing, job control on architectures that support it, csh-like features such as history substitution and brace expansion, and a slew of other features.
> [tiswww.case.edu/php/chet/bash/bashtop.html](https://tiswww.case.edu/php/chet/bash/bashtop.html)
%%LOGO%%
# How to use this image
The primary use cases this image is targeting are testing new features of more recent Bash versions before your primary distribution updates packages and testing shell scripts against different Bash versions to ensure compatibility. There are likely other interesting use cases as well, but those are the primary two the image was initially created to solve!
## Notes
There are a few main things that are important to note regarding this image:
1. Bash itself is installed at `/usr/local/bin/bash`, not `/bin/bash`, so the recommended shebang is `#!/usr/bin/env bash`, not `#!/bin/bash` (or explicitly running your script via `bash /.../script.sh` instead of letting the shebang invoke Bash automatically). The image does not include `/bin/bash`, but if it is installed via the package manager included in the image, that package will install to `/bin/bash` and might cause confusion (although `/usr/local/bin` is ahead of `/bin` in `$PATH`, so as long as plain `bash` or `/usr/bin/env` are used consistently, the image-provided Bash will be preferred).
2. Bash is the only thing included, so if your scripts rely on external tools (such as `jq`, for example), those will need to be added manually (via `apk add --no-cache jq`, for example).
## Interactive shell
```console
$ docker run -it --rm %%IMAGE%%:4.4
bash-4.4# which bash
/usr/local/bin/bash
bash-4.4# echo $BASH_VERSION
4.4.0(1)-release
```
## Testing scripts via bind-mount
```console
$ docker run -it --rm -v /path/to/script.sh:/script.sh:ro %%IMAGE%%:4.4 bash /script.sh
...
$ docker run -it --rm -v /path/to/script.sh:/script.sh:ro %%IMAGE%%:3.2 bash /script.sh
...
```
## Testing scripts via `Dockerfile`
```dockerfile
FROM %%IMAGE%%:4.4
COPY script.sh /
CMD ["bash", "/script.sh"]
```
Then, build and run the Docker image:
```console
$ docker build -t my-bash-app .
...
$ docker run -it --rm --name my-running-app my-bash-app
...
```
```
--------------------------------------------------------------------------------
/rust/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Rust?
Rust is a systems programming language sponsored by Mozilla Research. It is designed to be a "safe, concurrent, practical language", supporting functional and imperative-procedural paradigms. Rust is syntactically similar to C++, but is designed for better memory safety while maintaining performance.
> [wikipedia.org/wiki/Rust_(programming_language)](https://en.wikipedia.org/wiki/Rust_%28programming_language%29)
%%LOGO%%
# How to use this image
## Start a Rust instance running your app
The most straightforward way to use this image is to use a Rust container as both the build and runtime environment. In your `Dockerfile`, writing something along the lines of the following will compile and run your project:
```dockerfile
FROM %%IMAGE%%:1.67
WORKDIR /usr/src/myapp
COPY . .
RUN cargo install --path .
CMD ["myapp"]
```
Then, build and run the Docker image:
```console
$ docker build -t my-rust-app .
$ docker run -it --rm --name my-running-app my-rust-app
```
This creates an image that has all of the rust tooling for the image, which is 1.8gb. If you just want the compiled application:
```dockerfile
FROM rust:1.67 as builder
WORKDIR /usr/src/myapp
COPY . .
RUN cargo install --path .
FROM debian:bullseye-slim
RUN apt-get update && apt-get install -y extra-runtime-dependencies && rm -rf /var/lib/apt/lists/*
COPY --from=builder /usr/local/cargo/bin/myapp /usr/local/bin/myapp
CMD ["myapp"]
```
Note: Some shared libraries may need to be installed as shown in the installation of the `extra-runtime-dependencies` line above.
This method will create an image that is less than 200mb. If you switch to using the Alpine-based rust image, you might be able to save another 60mb.
See https://docs.docker.com/develop/develop-images/multistage-build/ for more information.
## Compile your app inside the Docker container
There may be occasions where it is not appropriate to run your app inside a container. To compile, but not run your app inside the Docker instance, you can write something like:
```console
$ docker run --rm --user "$(id -u)":"$(id -g)" -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:1.23.0 cargo build --release
```
This will add your current directory, as a volume, to the container, set the working directory to the volume, and run the command `cargo build --release`. This tells Cargo, Rust's build system, to compile the crate in `myapp` and output the executable to `target/release/myapp`.
```
--------------------------------------------------------------------------------
/generate-repo-stub-readme.sh:
--------------------------------------------------------------------------------
```bash
#!/usr/bin/env bash
set -Eeuo pipefail
cd "$(dirname "$(readlink -f "$BASH_SOURCE")")"
repo="${1:-}"
if [ -z "$repo" ]; then
echo >&2 'error: no repo specified'
cat >&2 <<EOUSAGE
usage: $0 repo [> README.md]
ie: $0 php > ../php/README.md
This script generates a stub README to standard out for the specified repo.
EOUSAGE
exit 1
fi
gitRepo='https://github.com/docker-library/docs'
hubPage="https://hub.docker.com/_/$repo/"
canonicalRepo="https://github.com/docker-library/$repo"
if [ -s "$repo/github-repo" ]; then
canonicalRepo="$(< "$repo/github-repo")"
fi
canonicalRepo="$(curl -fsSLI -o /dev/null -w '%{url_effective}\n' "$canonicalRepo")" # follow redirects (http://stackoverflow.com/a/3077316/433558)
maintainer="$(sed -e 's!%%GITHUB-REPO%%!'"$canonicalRepo"'!g' "$repo/maintainer.md")"
if [ -f "$repo/deprecated.md" ]; then
echo '# DEPRECATED'
echo
cat "$repo/deprecated.md"
echo
fi
case "$repo" in
buildpack-deps | docker | hello-world | hylang) disclaimer='' ;;
*) disclaimer=" (not to be confused with any official \`$repo\` image provided by \`$repo\` upstream)" ;;
esac
cat <<EOREADME
# $canonicalRepo
## Maintained by: $maintainer
This is the Git repo of the [Docker "Official Image"](https://github.com/docker-library/official-images#what-are-official-images) for [\`$repo\`]($hubPage)$disclaimer. See [the Docker Hub page]($hubPage) for the full readme on how to use this Docker image and for information regarding contributing and issues.
The [full image description on Docker Hub]($hubPage) is generated/maintained over in [the docker-library/docs repository]($gitRepo), specifically in [the \`$repo\` directory]($gitRepo/tree/master/$repo).
## See a change merged here that doesn't show up on Docker Hub yet?
For more information about the full official images change lifecycle, see [the "An image's source changed in Git, now what?" FAQ entry](https://github.com/docker-library/faq#an-images-source-changed-in-git-now-what).
For outstanding \`$repo\` image PRs, check [PRs with the "library/$repo" label on the official-images repository](https://github.com/docker-library/official-images/labels/library%2F$repo). For the current "source of truth" for [\`$repo\`]($hubPage), see [the \`library/$repo\` file in the official-images repository](https://github.com/docker-library/official-images/blob/master/library/$repo).
<!-- THIS FILE IS GENERATED BY $gitRepo/blob/master/generate-repo-stub-readme.sh -->
EOREADME
```
--------------------------------------------------------------------------------
/python/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Python?
Python is an interpreted, interactive, object-oriented, open-source programming language. It incorporates modules, exceptions, dynamic typing, very high level dynamic data types, and classes. Python combines remarkable power with very clear syntax. It has interfaces to many system calls and libraries, as well as to various window systems, and is extensible in C or C++. It is also usable as an extension language for applications that need a programmable interface. Finally, Python is portable: it runs on many Unix variants, on the Mac, and on Windows 2000 and later.
> [wikipedia.org/wiki/Python_(programming_language)](https://en.wikipedia.org/wiki/Python_%28programming_language%29)
%%LOGO%%
# How to use this image
## Create a `Dockerfile` in your Python app project
```dockerfile
FROM %%IMAGE%%:3
WORKDIR /usr/src/app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD [ "python", "./your-daemon-or-script.py" ]
```
or (if you need to use Python 2):
```dockerfile
FROM %%IMAGE%%:2
WORKDIR /usr/src/app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD [ "python", "./your-daemon-or-script.py" ]
```
You can then build and run the Docker image:
```console
$ docker build -t my-python-app .
$ docker run -it --rm --name my-running-app my-python-app
```
## Run a single Python script
For many simple, single file projects, you may find it inconvenient to write a complete `Dockerfile`. In such cases, you can run a Python script by using the Python Docker image directly:
```console
$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:3 python your-daemon-or-script.py
```
or (again, if you need to use Python 2):
```console
$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:2 python your-daemon-or-script.py
```
## Multiple Python versions in the image
In the non-slim variants there will be an additional (distro-provided) `python` executable at `/usr/bin/python` (and/or `/usr/bin/python3`) while the desired image-provided `/usr/local/bin/python` is the default choice in the `$PATH`. This is an unfortunate side-effect of using the `buildpack-deps` image in the non-slim variants (and many distribution-provided tools being written against and likely to break with a different Python installation, so we can't safely remove/overwrite it).
```
--------------------------------------------------------------------------------
/archlinux/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Arch Linux?
Arch Linux, is a lightweight and flexible Linux® distribution that tries to Keep It Simple.
Currently, we have official packages optimized for the x86-64 architecture. We complement our official package sets with a community-operated package repository that grows in size and quality each and every day.
Our strong community is diverse and helpful, and we pride ourselves on the range of skill sets and uses for Arch that stem from it. Please check out our forums and mailing lists to get your feet wet. Also glance through our [wiki](https://wiki.archlinux.org) if you want to learn more about Arch.
%%LOGO%%
# About this image
The root filesystem tarball for this image is auto-generated weekly at 00:00 UTC on Sunday in Arch Linux infrastructure. Given the rolling-release nature of Arch Linux, images are tagged with the included meta package and the timestamp of the date they were generated. For example, `%%IMAGE%%:base-20201101.0.7893` was generated the First of November 2020 in [CI job #7893](https://gitlab.archlinux.org/archlinux/archlinux-docker/-/jobs/7893). The `latest` tag will always match the latest `base` tag.
Besides `base` we also provide images for the `base-devel` and `multilib-devel` meta packages.
This image is intended to serve the following goals:
- Provide the Arch experience in a Docker Image
- Provide simplest but complete image to `base`, `base-devel` and `multilib-devel` on a regular basis
- `pacman` needs to work out of the box
- All installed packages have to be kept unmodified
> ⚠️⚠️⚠️ NOTE: For Security Reasons, these images strip the pacman lsign key. This is because the same key would be spread to all containers of the same image, allowing for malicious actors to inject packages (via, for example, a man-in-the-middle). In order to create a lsign-key run `pacman-key --init` on the first execution, but be careful to not redistribute that key. ⚠️⚠️⚠️
## Availability
Root filesystem tarballs are [provided by our GitLab](https://gitlab.archlinux.org/archlinux/archlinux-docker/-/releases) for at least two months.
## Updating
Arch Linux is a rolling release distribution, so a full update is recommended when installing new packages. In other words, we suggest to either execute `RUN pacman -Syu` immediately after your `FROM` statement or as soon as you `docker run` into a container.
## How It's Made
You can build this image with the tools on the [Arch Linux GitLab repository](https://gitlab.archlinux.org/archlinux/archlinux-docker) using the included makefile.
```
--------------------------------------------------------------------------------
/plone/logo.svg:
--------------------------------------------------------------------------------
```
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Generator: Adobe Illustrator 13.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 14948) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
version="1.1"
id="Layer_1"
x="0px"
y="0px"
width="40.686001"
height="40.686001"
viewBox="0 0 40.685999 40.686"
enable-background="new 0 0 158.253 40.686"
xml:space="preserve"
sodipodi:docname="logo.svg"
inkscape:version="0.92.2 2405546, 2018-03-11"><metadata
id="metadata3880"><rdf:RDF><cc:Work
rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
id="defs3878" /><sodipodi:namedview
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1"
objecttolerance="10"
gridtolerance="10"
guidetolerance="10"
inkscape:pageopacity="0"
inkscape:pageshadow="2"
inkscape:window-width="1916"
inkscape:window-height="1048"
id="namedview3876"
showgrid="false"
inkscape:snap-page="true"
inkscape:zoom="6.5464791"
inkscape:cx="69.00927"
inkscape:cy="-3.8796729"
inkscape:window-x="0"
inkscape:window-y="14"
inkscape:window-maximized="0"
inkscape:current-layer="Layer_1" />
<circle
cx="17.716999"
cy="11.560999"
r="4.402"
id="circle3857"
style="fill:#009ddc" />
<path
d="m 31.069,20.355999 c 0,2.433 -1.969,4.401 -4.403,4.401 -2.427,0 -4.401,-1.97 -4.401,-4.401 0,-2.433 1.975,-4.401 4.401,-4.401 2.435,-0.001 4.403,1.969 4.403,4.401 z"
id="path3859"
inkscape:connector-curvature="0"
style="fill:#009ddc" />
<circle
cx="17.702"
cy="29.176001"
r="4.402"
id="circle3861"
style="fill:#009ddc" />
<g
id="g3865">
<path
d="M 20.343,0 C 9.108,0.001 0.001,9.108 0,20.343 0.001,31.577 9.108,40.684 20.343,40.686 31.578,40.684 40.684,31.579 40.686,20.343 40.684,9.108 31.578,0.001 20.343,0 Z M 31.792,31.792 C 28.855,34.726 24.82,36.534 20.342,36.535 15.864,36.534 11.829,34.724 8.892,31.792 5.959,28.855 4.151,24.82 4.15,20.343 4.151,15.865 5.959,11.83 8.893,8.893 11.83,5.959 15.865,4.151 20.343,4.15 c 4.478,10e-4 8.513,1.81 11.45,4.743 2.934,2.938 4.742,6.973 4.743,11.45 -0.002,4.477 -1.81,8.512 -4.744,11.449 z"
id="path3863"
inkscape:connector-curvature="0"
style="fill:#009ddc" />
</g>
</svg>
```
--------------------------------------------------------------------------------
/dart/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Dart?
Dart is a client-optimized language for developing fast apps on any platform. Its goal is to offer the most productive programming language for multi-platform development, paired with a flexible execution runtime platform for app frameworks. For more details, see https://dart.dev.
By utilizing Dart's support for ahead-of-time (AOT) [compilation to executables](https://dart.dev/tools/dart-compile#exe), you can create very small runtime images (~10 MB).
## Using this image
We recommend using small runtime images that leverage Dart's support for ahead-of-time (AOT) [compilation to executables](https://dart.dev/tools/dart-compile#exe). This enables creating small runtime images (~10 MB).
### Creating a Dart server app
After [installing](https://dart.dev/get-dart) the Dart SDK, version 2.14 or later, use the `dart` command to create a new server app:
```shell
$ dart create -t server-shelf myserver
```
### Running the server with Docker Desktop
If you have [Docker Desktop](https://www.docker.com/get-started) installed, you can build and run on your machine with the `docker` command:
```shell
$ docker build -t dart-server .
$ docker run -it --rm -p 8080:8080 --name myserver dart-server
```
When finished, you can stop the container using the name you provided:
```shell
$ docker kill myserver
```
## Image documentation
### `Dockerfile`
The `Dockerfile` created by the `dart` tool performs two steps:
1. Using the Dart SDK in the `dart:stable` image, compiles your server (`bin/server.dart`) to an executable (`server`).
2. Assembles the runtime image by combining the compiled server with the Dart VM runtime and it's needed dependencies located in `/runtime/`.
```Dockerfile
# Specify the Dart SDK base image version using dart:<version> (ex: dart:2.12)
FROM dart:stable AS build
# Resolve app dependencies.
WORKDIR /app
COPY pubspec.* ./
RUN dart pub get
# Copy app source code and AOT compile it.
COPY . .
# Ensure packages are still up-to-date if anything has changed
RUN dart pub get --offline
RUN dart compile exe bin/server.dart -o bin/server
# Build minimal serving image from AOT-compiled `/server` and required system
# libraries and configuration files stored in `/runtime/` from the build stage.
FROM scratch
COPY --from=build /runtime/ /
COPY --from=build /app/bin/server /app/bin/
# Start server.
EXPOSE 8080
CMD ["/app/bin/server"]
```
### `.dockerignore`
Additionally it creates a recommended `.dockerignore` file, which enumarates files that should be omitted from the built Docker image:
```text
.dockerignore
Dockerfile
build/
.dart_tool/
.git/
.github/
.gitignore
.packages
```
--
Maintained with ❤️ by the [Dart](https://dart.dev) team.
```
--------------------------------------------------------------------------------
/rockylinux/content.md:
--------------------------------------------------------------------------------
```markdown
# Rocky Linux
Rocky Linux is a community-supported distribution derived from sources freely provided to the public by [Red Hat](ftp://ftp.redhat.com/pub/redhat/linux/enterprise/) for Red Hat Enterprise Linux (RHEL). As such, Rocky Linux aims to be functionally compatible with RHEL. The Rocky Linux Project mainly changes packages to remove upstream vendor branding and artwork. Rocky Linux is no-cost and free to redistribute. Each Rocky Linux version is maintained for up to 10 years (by means of security updates -- the duration of the support interval by Red Hat has varied over time with respect to Sources released). A new Rocky Linux version is released approximately every 2 years and each Rocky Linux version is periodically updated (roughly every 6 months) to support newer hardware. This results in a secure, low-maintenance, reliable, predictable, and reproducible Linux environment.
Thank you for using Rocky Linux! We appreciate your feedback and welcome you to the community! Please join us on IRC on Libera.chat in #rockylinux or on our Mattermost instance at https://chat.rockylinux.org
- [docs.rockylinux.org](https://docs.rockylinux.org)
- [wiki.rockylinux.org](https://wiki.rockylinux.org)
%%LOGO%%
# Rocky Linux image documentation
The `%%IMAGE%%:latest` tag is intentionally missing. Please choose a major version (currently 8 or 9) tag, or a more specific tag to ensure you are pulling the version of Rocky Linux you want: e.g. `%%IMAGE%%:8` or `%%IMAGE%%:9`
## Minimal variant
In addition to the Base container, a Minimal container with microdnf and a stripped down dependency set is available by using any of the `-minimal` tags e.g. `%%IMAGE%%:9-minimal`
## Rolling builds
Rocky Linux offers regularly updated images for all active releases. These images will be updated monthly or as needed for emergency fixes. These rolling updates are tagged with the major version number only. For example: `docker pull %%IMAGE%%:8`.
## Minor tags
Additionally, images with minor version tags that correspond to install media are also offered. **These images DO NOT receive updates** as they are intended to match installation iso contents. If you choose to use these images it is highly recommended that you include `RUN yum -y update && yum clean all` in your Dockerfile, or otherwise address any potential security concerns. To use these images, please specify the minor version tag:
For example: `docker pull %%IMAGE%%:8.4`
# Package documentation
By default, the Rocky Linux containers are built using yum's `nodocs` option, which helps reduce the size of the image. If you install a package and discover files missing, please comment out the line `tsflags=nodocs` in `/etc/yum.conf` and reinstall your package.
```
--------------------------------------------------------------------------------
/monica/logo.svg:
--------------------------------------------------------------------------------
```
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="192" height="192" version="1.1" viewBox="0 0 500 500"><title>Artboard 3.1</title><desc>Created using Figma</desc><g id="Canvas" transform="translate(-2984 68)"><clipPath id="clip-0" clip-rule="evenodd"><path fill="#FFF" d="M 2984 -68L 3484 -68L 3484 432L 2984 432L 2984 -68Z"/></clipPath><g id="Artboard 3.1" clip-path="url(#clip-0)"><g id="Group 2"><g id="Oval"><use fill="#2C2B29" transform="translate(3002.51 -26.4788)" xlink:href="#path0_fill"/></g><g id="Oval"><use fill="#FFF" transform="translate(3047.56 17.3456)" xlink:href="#path1_fill"/></g><g id="Oval 2"><use fill="#2C2B29" transform="translate(2990 -39)" xlink:href="#path2_fill"/></g><g id="Oval 2"><use fill="#2C2B29" transform="matrix(-1 0 0 1 3478 -39)" xlink:href="#path2_fill"/></g><g id="Group"><g id="Oval 4"><use fill="#2B2A28" transform="translate(3265.32 122.647)" xlink:href="#path3_fill"/></g><g id="Oval 3"><use fill="#FFF" transform="translate(3292.63 154.768)" xlink:href="#path4_fill"/></g></g><g id="Group"><g id="Oval 4"><use fill="#2B2A28" transform="matrix(-1 0 0 1 3203.93 122.647)" xlink:href="#path3_fill"/></g><g id="Oval 3"><use fill="#FFF" transform="matrix(-1 0 0 1 3176.62 154.768)" xlink:href="#path4_fill"/></g></g><g id="Oval 5"><use fill="#2C2B29" transform="translate(3200.22 256.501)" xlink:href="#path5_fill"/></g></g></g></g><defs><path id="path0_fill" fill-rule="evenodd" d="M 235.425 429.479C 349.64 429.479 476.369 356.022 460.345 214.739C 444.321 73.4567 349.64 0 235.425 0C 121.21 0 27.2705 64.3949 2.77082 214.739C -21.7289 365.084 121.21 429.479 235.425 429.479Z"/><path id="path1_fill" fill-rule="evenodd" d="M 188.85 344.334C 280.47 344.334 382.128 285.44 369.274 172.167C 356.42 58.8939 280.47 0 188.85 0C 97.2312 0 21.8755 51.6286 2.22266 172.167C -17.4302 292.706 97.2312 344.334 188.85 344.334Z"/><path id="path2_fill" fill-rule="evenodd" d="M 65.5865 165.28C 78.0014 165.322 83.3945 120.9 105.565 100.675C 125.919 82.1083 172.677 75.742 172.677 54.2762C 172.677 9.42729 124.055 0 81.1199 0C 38.1853 0 0 45.4903 0 90.3392C 0 135.188 41.7747 165.201 65.5865 165.28Z"/><path id="path3_fill" fill-rule="evenodd" d="M 69.6 154.572C 102.094 146.823 115.643 133.157 115.643 88.997C 115.643 44.8368 94.944 0 59.3049 0C 23.6657 0 0 31.8863 0 76.0465C 0 120.207 37.106 162.32 69.6 154.572Z"/><path id="path4_fill" fill-rule="evenodd" d="M 30.3863 66.4287C 39.2286 66.4287 41.8586 64.1715 45.8555 59.1037C 50.3374 53.421 53.6797 46.8294 52.5868 33.2144C 50.7608 10.465 41.1736 0 22.4162 0C 3.6587 0 -3.78365e-16 14.4228 0 33.2144C -3.78365e-16 52.0059 11.6288 66.4287 30.3863 66.4287Z"/><path id="path5_fill" fill-rule="evenodd" d="M 35.2906 50.085C 52.9487 50.085 70.0718 24.0956 70.0718 12.9499C 70.0718 1.80416 52.6939 0 35.0359 0C 17.3779 0 0 1.80416 0 12.9499C 0 24.0956 17.6326 50.085 35.2906 50.085Z"/></defs></svg>
```
--------------------------------------------------------------------------------
/r-base/content.md:
--------------------------------------------------------------------------------
```markdown
# What is R?
R is a system for statistical computation and graphics. It consists of a language plus a run-time environment with graphics, a debugger, access to certain system functions, and the ability to run programs stored in script files.
The R language is widely used among statisticians and data miners for developing statistical software and data analysis. Polls and surveys of data miners are showing R's popularity has increased substantially in recent years.
R is an implementation of the S programming language combined with lexical scoping semantics inspired by Scheme. S was created by John Chambers while at Bell Labs. R was created by Ross Ihaka and Robert Gentleman at the University of Auckland, New Zealand, and is currently developed by the R Development Core Team, of which Chambers is a member. R is named partly after the first names of the first two R authors and partly as a play on the name of S.
R is a GNU project. The source code for the R software environment is written primarily in C, Fortran, and R. R is freely available under the GNU General Public License, and pre-compiled binary versions are provided for various operating systems. R uses a command line interface; however, several graphical user interfaces are available for use with R.
> [R FAQ](http://cran.r-project.org/doc/FAQ/R-FAQ.html#What-is-R_003f), [wikipedia.org/wiki/R_(programming_language)](http://en.wikipedia.org/wiki/R_%28programming_language%29)
%%LOGO%%
# How to use this image
## Interactive R
Launch R directly for interactive work:
```console
$ docker run -ti --rm %%IMAGE%%
```
## Batch mode
Link the working directory to run R batch commands. We recommend specifying a non-root user when linking a volume to the container to avoid permission changes, as illustrated here:
```console
$ docker run -ti --rm -v "$PWD":/home/docker -w /home/docker -u docker %%IMAGE%% R CMD check .
```
Alternatively, just run a bash session on the container first. This allows a user to run batch commands and also edit and run scripts:
```console
$ docker run -ti --rm %%IMAGE%% bash
$ vim.tiny myscript.R
```
Write the script in the container, exit `vim` and run `Rscript`
```console
$ Rscript myscript.R
```
## Dockerfiles
Use `r-base` as a base for your own Dockerfiles. For instance, something along the lines of the following will compile and run your project:
```dockerfile
FROM %%IMAGE%%
COPY . /usr/local/src/myscripts
WORKDIR /usr/local/src/myscripts
CMD ["Rscript", "myscript.R"]
```
Build your image with the command:
```console
$ docker build -t myscript /path/to/Dockerfile
```
Running this container with no command will execute the script. Alternatively, a user could run this container in interactive or batch mode as described above, instead of linking volumes.
Further documentation and example use cases can be found at the [rocker-org](https://github.com/rocker-org/rocker/wiki) project wiki.
```
--------------------------------------------------------------------------------
/maven/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Maven?
[Apache Maven](http://maven.apache.org) is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.
%%LOGO%%
# How to use this image
You can run a Maven project by using the Maven Docker image directly, passing a Maven command to `docker run`:
```console
$ docker run -it --rm --name my-maven-project -v "$(pwd)":/usr/src/mymaven -w /usr/src/mymaven %%IMAGE%%:3.3-jdk-8 mvn clean install
```
## Building local Docker image (optional)
This is a base image that you can extend, so it has the bare minimum packages needed. If you add custom package(s) to the `Dockerfile`, then you can build your local Docker image like this:
```console
$ docker build --tag my_local_%%IMAGE%%:3.5.2-jdk-8 .
```
# Reusing the Maven local repository
The local Maven repository can be reused across containers by creating a volume and mounting it in `/root/.m2`.
```console
$ docker volume create --name maven-repo
$ docker run -it -v maven-repo:/root/.m2 %%IMAGE%% mvn archetype:generate # will download artifacts
$ docker run -it -v maven-repo:/root/.m2 %%IMAGE%% mvn archetype:generate # will reuse downloaded artifacts
```
Or you can just use your home .m2 cache directory that you share e.g. with your Eclipse/IDEA:
```console
$ docker run -it --rm -v "$PWD":/usr/src/mymaven -v "$HOME/.m2":/root/.m2 -v "$PWD/target:/usr/src/mymaven/target" -w /usr/src/mymaven %%IMAGE%% mvn clean package
```
# Packaging a local repository with the image
The `$MAVEN_CONFIG` dir (default to `/root/.m2`) could be configured as a volume so anything copied there in a Dockerfile at build time is lost. For that reason the dir `/usr/share/maven/ref/` exists, and anything in that directory will be copied on container startup to `$MAVEN_CONFIG`.
To create a pre-packaged repository, create a `pom.xml` with the dependencies you need and use this in your `Dockerfile`. `/usr/share/maven/ref/settings-docker.xml` is a settings file that changes the local repository to `/usr/share/maven/ref/repository`, but you can use your own settings file as long as it uses `/usr/share/maven/ref/repository` as local repo.
```dockerfile
COPY pom.xml /tmp/pom.xml
RUN mvn -B -f /tmp/pom.xml -s /usr/share/maven/ref/settings-docker.xml dependency:resolve
```
To add your custom `settings.xml` file to the image use
```dockerfile
COPY settings.xml /usr/share/maven/ref/
```
For an example, check the `tests` dir
# Running as non-root
Maven needs the user home to download artifacts to, and if the user does not exist in the image an extra `user.home` Java property needs to be set.
For example, to run as user `1000` mounting the host' Maven repo
```console
$ docker run -v ~/.m2:/var/maven/.m2 -ti --rm -u 1000 -e MAVEN_CONFIG=/var/maven/.m2 %%IMAGE%% mvn -Duser.home=/var/maven archetype:generate
```
```
--------------------------------------------------------------------------------
/ruby/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Ruby?
Ruby is a dynamic, reflective, object-oriented, general-purpose, open-source programming language. According to its authors, Ruby was influenced by Perl, Smalltalk, Eiffel, Ada, and Lisp. It supports multiple programming paradigms, including functional, object-oriented, and imperative. It also has a dynamic type system and automatic memory management.
> [wikipedia.org/wiki/Ruby_(programming_language)](https://en.wikipedia.org/wiki/Ruby_%28programming_language%29)
%%LOGO%%
# How to use this image
## Create a `Dockerfile` in your Ruby app project
```dockerfile
FROM %%IMAGE%%:3.3
# throw errors if Gemfile has been modified since Gemfile.lock
RUN bundle config --global frozen 1
WORKDIR /usr/src/app
COPY Gemfile Gemfile.lock ./
RUN bundle install
COPY . .
CMD ["./your-daemon-or-script.rb"]
```
Put this file in the root of your app, next to the `Gemfile`.
You can then build and run the Ruby image:
```console
$ docker build -t my-ruby-app .
$ docker run -it --name my-running-script my-ruby-app
```
### Generate a `Gemfile.lock`
The above example `Dockerfile` expects a `Gemfile.lock` in your app directory. This `docker run` will help you generate one. Run it in the root of your app, next to the `Gemfile`:
```console
$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%%:3.3 bundle install
```
## Run a single Ruby script
For many simple, single file projects, you may find it inconvenient to write a complete `Dockerfile`. In such cases, you can run a Ruby script by using the Ruby Docker image directly:
```console
$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:3.3 ruby your-daemon-or-script.rb
```
## Encoding
By default, Ruby inherits the locale of the environment in which it is run. For most users running Ruby on their desktop systems, that means it's likely using some variation of `*.UTF-8` (`en_US.UTF-8`, etc). In Docker however, the default locale is `C`, which can have unexpected results. If your application needs to interact with UTF-8, it is recommended that you explicitly adjust the locale of your image/container via `-e LANG=C.UTF-8` or `ENV LANG C.UTF-8`.
## Image assumptions
This image sets several environment variables which change the behavior of Bundler and Gem for running a single application within a container (especially in such a way that the development sources of the application can be bind-mounted inside a container and not have `.bundle` from the host interfere with the proper functionality of the container).
The environment variables we set are canonically listed in the above-linked `Dockerfiles`, but some of them include `GEM_HOME`, `BUNDLE_SILENCE_ROOT_WARNING`, and `BUNDLE_APP_CONFIG`.
If these cause issues for your use case (running multiple Ruby applications in a single container, for example), setting them to the empty string *should* be sufficient for undoing their behavior.
```
--------------------------------------------------------------------------------
/crate/logo.svg:
--------------------------------------------------------------------------------
```
<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 436 58" width="436" height="58"><style>.a{fill:#009dc7}</style><title>CrateDB</title><path class="a" d="m3.6 0h14.5v14.5h-14.5z"/><path class="a" d="m25.4 0h14.5v14.5h-14.5z"/><path class="a" d="m47.2 0h14.5v36.2h-14.5z"/><path class="a" d="m3.6 21.7h36.3v14.5h-36.3z"/><path class="a" d="m3.6 43.4h58.1v14.5h-58.1z"/><path d="m249.5 16.9h12.1v8.4h-12.1v19.3h12.1v8.4h-10.4c-1.5 0.1-2.9-0.2-4.3-0.7-1.3-0.6-2.6-1.3-3.6-2.3-1.1-1-1.9-2.2-2.5-3.6-0.6-1.3-1-2.7-1-4.2v-16.9h-9.7v-8.4h9.7v-12.1h9.7z"/><path d="m159.8 22.9q0-1.2 0.5-2.3 0.4-1.1 1.3-2 0.9-0.8 2-1.3 1.1-0.4 2.3-0.4h12.1v8.4h-13.3q-1 0-1.9 0.4-0.8 0.4-1.5 1-0.7 0.7-1.1 1.6-0.3 0.9-0.3 1.9v22.9h-9.7v-36.2h7.2l1.2 6h1.2z"/><path d="m90.8 16.9c0-1.6 0.3-3.2 0.9-4.6 0.6-1.5 1.5-2.8 2.7-3.9 1.1-1.2 2.4-2 3.9-2.7 1.5-0.6 3-0.9 4.6-0.9h36.4v9.7h-38.8v28.9h38.8v9.7h-36.4c-1.6 0-3.1-0.3-4.6-0.9-1.5-0.6-2.8-1.5-3.9-2.6-1.2-1.2-2.1-2.5-2.7-4-0.6-1.4-0.9-3-0.9-4.6v-24.1z"/><path fill-rule="evenodd" d="m358.9 6.1c2.1 0.9 4 2.1 5.5 3.7 1.6 1.5 2.9 3.4 3.7 5.5 0.9 2 1.3 4.2 1.3 6.4v14.5c0 2.2-0.4 4.4-1.3 6.5-0.8 2-2.1 3.9-3.7 5.4-1.5 1.6-3.4 2.8-5.5 3.7-2 0.8-4.2 1.3-6.4 1.3h-34v-48.3h34c2.2 0 4.4 0.5 6.4 1.3zm0.3 12.8q-0.6-1.3-1.6-2.3-1-1-2.4-1.6-1.3-0.5-2.7-0.5h-24.3v28.9h24.3q1.4 0 2.7-0.5 1.4-0.6 2.4-1.6 1-1 1.6-2.3 0.5-1.4 0.5-2.8v-14.5q0-1.4-0.5-2.8z"/><path fill-rule="evenodd" d="m212.7 16.9c1.3 0 2.5 0.2 3.7 0.7 1.2 0.5 2.3 1.2 3.2 2.1 0.9 0.9 1.7 1.9 2.2 3.1 0.4 1.2 0.7 2.5 0.7 3.7v26.6h-7.3l-1.2-4.8h-1.2q0 0.9-0.4 1.8-0.3 0.9-1 1.6-0.7 0.7-1.6 1-0.9 0.4-1.8 0.4h-14c-1.5 0.1-2.9-0.2-4.3-0.7-1.4-0.5-2.6-1.3-3.7-2.3-1.1-1-1.9-2.2-2.5-3.5-0.6-1.3-1-2.8-1-4.2 0-1.4 0.3-2.8 0.9-4.1 0.6-1.2 1.4-2.4 2.4-3.4 1-0.9 2.2-1.7 3.5-2.2 1.3-0.5 2.6-0.7 4-0.7h19.4v-7.3h-25.4v-7.8zm-3.6 28.9q0.7 0 1.3-0.2 0.7-0.3 1.2-0.8 0.5-0.5 0.8-1.2 0.3-0.7 0.3-1.4v-3.6h-17.6c-0.9 0-1.8 0.4-2.5 1.1-0.7 0.6-1.1 1.6-1.1 2.5 0 1 0.4 1.9 1.1 2.6 0.6 0.7 1.6 1 2.5 1.1h14z"/><path fill-rule="evenodd" d="m296.7 16.9c1.6 0 3.2 0.3 4.7 0.9 1.4 0.6 2.8 1.5 3.9 2.6 1.1 1.1 2 2.5 2.6 3.9 0.6 1.5 0.9 3.1 0.9 4.7v9.6h-30.2v6.6h27.8v7.9h-25.4c-1.6 0-3.2-0.3-4.6-0.9-1.5-0.6-2.8-1.5-4-2.6-1.1-1.2-2-2.5-2.6-4-0.6-1.4-0.9-3-0.9-4.6v-12c0-1.6 0.3-3.2 0.9-4.7 0.6-1.4 1.5-2.8 2.6-3.9 1.2-1.1 2.5-2 4-2.6 1.4-0.6 3-0.9 4.6-0.9h15.7zm3.7 15.1v-3.7q0-0.7-0.3-1.4-0.3-0.6-0.8-1.1-0.5-0.5-1.2-0.8-0.6-0.3-1.3-0.3h-14.6q-0.7 0-1.4 0.3-0.6 0.3-1.1 0.8-0.6 0.5-0.8 1.2-0.3 0.6-0.3 1.4v3.6z"/><path fill-rule="evenodd" d="m427.3 27.7q0 0 0 0 0 0 0 0.1zm0 0c2.3 1.9 3.9 4.4 4.6 7.3 0.8 2.9 0.6 5.9-0.4 8.7-1.1 2.7-2.9 5.1-5.3 6.8-2.5 1.7-5.4 2.6-8.3 2.6h-38.8v-48.2h36.3c2.7 0 5.3 0.7 7.6 2.1 2.3 1.3 4.1 3.3 5.3 5.7 1.3 2.3 1.8 5 1.6 7.6-0.2 2.6-1.1 5.2-2.6 7.4zm-38.5-3.7h26.6c1.3 0 2.5-0.5 3.4-1.4 0.9-0.9 1.4-2.1 1.4-3.4 0-1.2-0.5-2.5-1.4-3.4-0.9-0.9-2.1-1.4-3.4-1.4h-26.6zm32.5 17.5c0.9-1 1.3-2.3 1.3-3.6 0-1.4-0.4-2.6-1.3-3.6-0.9-1-2.1-1.7-3.4-1.9h-29.1v10.9h29.1c1.3-0.2 2.5-0.8 3.4-1.8z"/></svg>
```
--------------------------------------------------------------------------------
/redis/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Redis?
Redis is the world’s fastest data platform. It provides cloud and on-prem solutions for caching, vector search, and NoSQL databases that seamlessly fit into any tech stack—making it simple for digital customers to build, scale, and deploy the fast apps our world runs on.
> [redis.io](https://redis.io)
%%LOGO%%
# Security
For the ease of accessing Redis from other containers via Docker networking, the "Protected mode" is turned off by default. This means that if you expose the port outside of your host (e.g., via `-p` on `docker run`), it will be open without a password to anyone. It is **highly** recommended to set a password (by supplying a config file) if you plan on exposing your Redis instance to the internet. For further information, see the following links about Redis security:
- [Redis documentation on security](https://redis.io/docs/latest/operate/oss_and_stack/management/security/)
- [Protected mode](https://redis.io/docs/latest/operate/oss_and_stack/management/security/#protected-mode)
- [A few things about Redis security by antirez](http://antirez.com/news/96)
# How to use this image
## Start a redis instance
```console
$ docker run --name some-redis -d %%IMAGE%%
```
## Start with persistent storage
```console
$ docker run --name some-redis -d %%IMAGE%% redis-server --save 60 1 --loglevel warning
```
There are several different persistence strategies to choose from. This one will save a snapshot of the DB every 60 seconds if at least 1 write operation was performed (it will also lead to more logs, so the `loglevel` option may be desirable). If persistence is enabled, data is stored in the `VOLUME /data`, which can be used with `--volumes-from some-volume-container` or `-v /docker/host/dir:/data` (see [docs.docker volumes](https://docs.docker.com/engine/tutorials/dockervolumes/)).
For more about Redis persistence, see [the official Redis documentation](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/).
## Connecting via `redis-cli`
```console
$ docker run -it --network some-network --rm %%IMAGE%% redis-cli -h some-redis
```
## Additionally, if you want to use your own redis.conf ...
You can create your own Dockerfile that adds a redis.conf from the context into /data/, like so.
```dockerfile
FROM %%IMAGE%%
COPY redis.conf /usr/local/etc/redis/redis.conf
CMD [ "redis-server", "/usr/local/etc/redis/redis.conf" ]
```
Alternatively, you can specify something along the same lines with `docker run` options.
```console
$ docker run -v /myredis/conf:/usr/local/etc/redis --name myredis %%IMAGE%% redis-server /usr/local/etc/redis/redis.conf
```
Where `/myredis/conf/` is a local directory containing your `redis.conf` file. Using this method means that there is no need for you to have a Dockerfile for your redis container.
The mapped directory should be writable, as depending on the configuration and mode of operation, Redis may need to create additional configuration files or rewrite existing ones.
```
--------------------------------------------------------------------------------
/metadata.sh:
--------------------------------------------------------------------------------
```bash
#!/usr/bin/env bash
set -Eeuo pipefail
workdir="$(readlink -f "$BASH_SOURCE")"
workdir="$(dirname "$workdir")"
cd "$workdir"
jsonFile='metadata.json'
canonicalMetadataFile="./$jsonFile"
export maxCategories=3
self="$(basename "$0")"
usage() {
cat <<EOUSAGE
usage: $self [--write] REPO[...]
eg: $self debian
$self -w python
This script checks a givens repo's metadata.json. It checks formating (providing a diff), checks categories, and can write the formatting changes.
-h, --help Print this help output and exit.
-w, --write Apply json formatting (run without to see the diff that would be applied).
Arguments are the list of repos with a 'metadata.json' in them. 'metadata.json' is expected in every repo.
'.' can also be passed to check the format of the canonical './metadata.json' at
the root of the repo, but the max categories of '-c' is skipped for it.
EOUSAGE
}
# arg handling
opts="$(getopt -o 'hw' --long 'help,write' -- "$@" || { usage >&2 && false; })"
eval set -- "$opts"
write=
while :; do
flag="$1"
shift
case "$flag" in
--help | -h) usage && exit 0 ;;
--write | -w) write=1 ;;
--) break ;;
*)
{
echo "error: unknown flag: $flag"
usage
} >&2
exit 1
;;
esac
done
repos=( "$@" )
if [ "${#repos[@]}" -eq 0 ]; then
repos=( */ )
fi
repos=( "${repos[@]%/}" )
failures=0
for repo in "${repos[@]}"; do
repoFile="$repo/$jsonFile"
if [ ! -s "$repoFile" ]; then
echo >&2 "error: $repoFile does not exist or is empty"
(( failures++ )) || :
continue
fi
# sort object keys and pretty print with jq as our "cannonical json"
# sort categories array, no duplicates
if ! repoFileJson="$(jq -s --sort-keys '.[0] | .hub.categories |= unique' "$repoFile")"; then
echo >&2 "error parsing '$repoFile'; invalid JSON?"
(( failures++ )) || :
continue
fi
if ! filediff="$(diff -u "$repoFile" <(cat <<<"$repoFileJson"))"; then
cat <<<"$filediff"
if [ -n "$write" ]; then
cat <<<"$repoFileJson" > "$repoFile"
else
(( failures++ )) || :
fi
fi
# TODO also check for required keys and/or types?
# the canonicalMetadataFile doesn't have too many categories since it is the source of categories
# all other metadata.json files must not be more than maxCategories or have categories that aren't in the canonical set
if [ "$repoFile" != "$canonicalMetadataFile" ]; then
export repoFile
if errorText="$(jq -r --slurpfile canonical "$canonicalMetadataFile" '
.hub.categories
| (
length
| if . > (env.maxCategories | tonumber) then
"error: \(env.repoFile): too many categories: \(.) (max \(env.maxCategories))"
else empty end
),
(
. - $canonical[0].hub.categories
| if length > 0 then
"error: \(env.repoFile): unknown categories \(.)"
else empty end
)
' "$repoFile")"; then
if [ -n "$errorText" ]; then
echo >&2 "$errorText"
(( failures++ )) || :
fi
else
echo >&2 "error parsing '$repoFile'; invalid JSON?"
(( failures++ )) || :
continue
fi
fi
done
exit "$failures"
```
--------------------------------------------------------------------------------
/orientdb/content.md:
--------------------------------------------------------------------------------
```markdown
# What is OrientDB?
[OrientDB](http://www.orientdb.org) is the first Multi-Model Open Source NoSQL DBMS that combines the power of graphs and the flexibility of documents into one scalable, high-performance operational database.
%%LOGO%%
## How to use this image
When OrientDB starts it asks for the root password. The root user is able to manage the OrientDB server: create new databases, manage users and roles. The root password can be passed to the container using an environment property:
```console
$ docker run -d --name orientdb -p 2424:2424 -p 2480:2480 -e ORIENTDB_ROOT_PASSWORD=rootpwd %%IMAGE%%
```
The [Studio](http://orientdb.com/docs/last/Studio-Home-page.html) is accessible to http://<docker-host>:2480 (e.g.: http://localhost:2480)
### Attach persistent volumes
The docker image contains an OrientDB installation with basic configuration. If you need to provide **your own** config folder to **override** the one included in the OrientDB container, simply attach a persistent volume for configuration folder. Providing a configuration folder enables integration with software configuration tools such as Ansible, Chef or Puppet.
The same applies for the databases folder, which if local to the running container would go away as soon as it died/you killed it. Obviously use volumes from dedicated data container is another option.
```console
$ docker run -d --name orientdb -p 2424:2424 -p 2480:2480 \
-v <config_path>:/orientdb/config \
-v <databases_path>:/orientdb/databases \
-v <backup_path>:/orientdb/backup \
-e ORIENTDB_ROOT_PASSWORD=rootpwd \
%%IMAGE%%
```
**NOTE**: don't provide an **empty** config folder as volume, because OrientDB will startup with a very minimal configuration.
### Running OrientDB tools
The OrientDB image contains a full fledge installation, so it is possible to run the [console](http://orientdb.com/docs/last/Console-Commands.html)
```console
$ docker run --rm -it %%IMAGE%% /orientdb/bin/console.sh
```
or even the etl
```console
$ docker run --rm -it -v <config_path>:/orientdb/config %%IMAGE%% /orientdb/bin/oetl.sh ../config/oetl-config.json
```
### Override configuration parameters
Any configuration settings may be specified upon startup using the `-D` option prefix. For example, starting OrientDB in distributed configuration will work this way:
```console
$ docker run -d --name orientdb -p 2424:2424 -p 2480:2480 \
-v <config_path>:/orientdb/config \
-v <databases_path>:/orientdb/databases \
-v <backup_path>:/orientdb/backup \
-e ORIENTDB_ROOT_PASSWORD=rootpwd \
-e ORIENTDB_NODE_NAME=odb1 \
%%IMAGE%% /orientdb/bin/server.sh -Ddistributed=true
```
For further configuration options please refer to the [Configuration](http://orientdb.com/docs/last/Configuration.html) section of the online documentation.
### Environment
Environment parameters such as heap size could be passed via command line:
```console
$ docker run -d --name orientdb -p 2424:2424 -p 2480:2480 \
-e ORIENTDB_ROOT_PASSWORD=rootpwd \
%%IMAGE%% /orientdb/bin/server.sh -Xmx8g
```
```
--------------------------------------------------------------------------------
/clojure/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Clojure?
Clojure is a dialect of the Lisp programming language. It is a general-purpose programming language with an emphasis on functional programming. It runs on the Java Virtual Machine, Common Language Runtime, and JavaScript engines. Like other Lisps, Clojure treats code as data and has a macro system.
> [wikipedia.org/wiki/Clojure](http://en.wikipedia.org/wiki/Clojure)
%%LOGO%%
# How to use this image
## Build tools
Clojure has three major approaches to building and running projects:
1. [leiningen](https://leiningen.org)
1. The oldest and probably most common tool
2. [boot](http://boot-clj.com)
1. An alternative approach that solves similar problems as leiningen
3. [tools-deps](https://clojure.org/guides/deps_and_cli)
1. A more recent official tool for some of the lein/boot use cases
There are variants of this image for all three of these tools and their respective releases. The most basic form of these tags is:
1. `clojure:lein`
2. `clojure:boot`
3. `clojure:tools-deps`
But you can also append a hyphen and the version of that tool you'd like to use. For example, for lein 2.8.1 you can use this image: `clojure:lein-2.8.1`.
## Run your app with leiningen
Add a `Dockerfile` to an existing Leiningen/Clojure project with the following contents:
```dockerfile
FROM %%IMAGE%%
COPY . /usr/src/app
WORKDIR /usr/src/app
CMD ["lein", "run"]
```
Then, run these commands to build and run the image:
```console
$ docker build -t my-clojure-app .
$ docker run -it --rm --name my-running-app my-clojure-app
```
While the above is the most straightforward example of a `Dockerfile`, it does have some drawbacks. The `lein run` command will download your dependencies, compile the project, and then run it. That's a lot of work, all of which you may not want done every time you run the image. To get around this, you can download the dependencies and compile the project ahead of time. This will significantly reduce startup time when you run your image.
```dockerfile
FROM %%IMAGE%%
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
COPY project.clj /usr/src/app/
RUN lein deps
COPY . /usr/src/app
RUN mv "$(lein uberjar | sed -n 's/^Created \(.*standalone\.jar\)/\1/p')" app-standalone.jar
CMD ["java", "-jar", "app-standalone.jar"]
```
Writing the `Dockerfile` this way will download the dependencies (and cache them, so they are only re-downloaded when the dependencies change) and then compile them into a standalone jar ahead of time rather than each time the image is run.
You can then build and run the image as above.
## Compile your Lein/Clojure project into a jar from within the container
If you have an existing Lein/Clojure project, it's fairly straightforward to compile your project into a jar from a container:
```console
$ docker run -it --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%% lein uberjar
```
This will build your project into a jar file located in your project's `target/uberjar` directory.
## More details
See [the official image README](https://github.com/Quantisan/docker-clojure/blob/master/README.md) for more details about using this image with boot and tools-deps.
```
--------------------------------------------------------------------------------
/geonetwork/variant-postgres.md:
--------------------------------------------------------------------------------
```markdown
## `%%REPO%%:postgres` (Only for GeoNetwork 3 series)
This image gives support for using [PostgreSQL](https://www.postgresql.org/) as database engine for geonetwork. When you start the container, a database is created, and it is populated by geonetwork, once it starts.
Please note that this image **does not ship** the postgres database server itself, but it gives you the option to link to a container running postgres, or to connect to a postgres instance using its ip address. If you are looking for a self-contained installation of geonetwork, **including the database engine**, please have a look at the default image variant.
In order to setup the connection from geonetwork, you **must** inject the following variables into the container: - `POSTGRES_DB_USERNAME`: postgres user on your database server (must have permission to create databases) - `POSTGRES_DB_PASSWORD`: postgres password on your database server
If your postgres instance is listening on a non-standard port, you must also set that variable: - `POSTGRES_DB_PORT`: postgres port on your database server (defaults to `5432`)
### Connecting to a postgres database
If you want to connect to a postgres server, you need to pass an extra environment variable, `POSTGRES_DB_HOST`, containing the address of this server.
If you want to connect to an **external database server**, you can use either the IP address or the DNS as `POSTGRES_DB_HOST`. For instance, if the server is running on `mydns.net`, on port `5434`, the username is `postgres` and the password is `mysecretpassword`:
```console
docker run --name geonetwork -d -p 8080:8080 -e POSTGRES_DB_HOST=mydns.net -e POSTGRES_DB_PORT=5434 -e POSTGRES_DB_USERNAME=postgres -e POSTGRES_DB_PASSWORD=mysecretpassword -e POSTGRES_DB_NAME=mydbname geonetwork:postgres
```
If are want to **run postgres on a container**, you can use the container name as `POSTGRES_DB_HOST`: just make sure that containers can discover each other, by **running them in the same user-defined network**. For instance, you can create a bridge network:
```console
docker network create --driver bridge mynet
```
Then if you want to run the official image of postgres, using `some-postgres` as container name, you could launch it like this:
```console
docker run --name some-postgres --network=mynet -d postgres
```
And then you could launch geonetwork, making sure you join the same network, and setting the required environment variables, including the `POSTGRES_DB_HOST`:
```console
docker run --name geonetwork -d -p 8080:8080 --network=mynet -e POSTGRES_DB_HOST=some-postgres -e POSTGRES_DB_PORT=5432 -e POSTGRES_DB_USERNAME=postgres -e POSTGRES_DB_PASSWORD=mysecretpassword -e POSTGRES_DB_NAME=mydbname geonetwork:postgres
```
#### Configuration environment variables
These are some environments variables that can be set to configure the database connection:
- `POSTGRES_DB_HOST`: database host name.
- `POSTGRES_DB_PORT`: port where database server is listening (by default `5432`).
- `POSTGRES_DB_NAME`: name of the database. If it doesn't exist the container will try to create it.
- `POSTGRES_DB_USERNAME`: username.
- `POSTGRES_DB_PASSWORD`: password.
```
--------------------------------------------------------------------------------
/eclipse-temurin/content.md:
--------------------------------------------------------------------------------
```markdown
## Overview
The images in this repository contain OpenJDK binaries that are built by Eclipse Temurin.
# What is Eclipse Temurin ?
The Eclipse Temurin project provides code and processes that support the building of runtime binaries and associated technologies that are high performance, enterprise-caliber, cross-platform, open-source licensed, and Java SE TCK-tested for general use across the Java ecosystem.
%%LOGO%%
# Do you provide JRE (Java Runtime Environment) Images?
JRE images are available for all versions of Eclipse Temurin but it is recommended that you produce a custom JRE-like runtime using `jlink` (see usage below).
# Can I add my internal CA certificates to the truststore?
Yes! Add your certificates to `/certificates` inside the container (e.g. by using a volume) and set the environment variable `USE_SYSTEM_CA_CERTS` on the container to any value. With Docker CLI this might look like this:
```console
$ docker run -v $(pwd)/certs:/certificates/ -e USE_SYSTEM_CA_CERTS=1 %%IMAGE%%:21
```
The certificates would get added to the system CA store, which would in turn be converted to Java's truststore. The format of the certificates depends on what the OS of the base image used expects, but PEM format with a `.crt` file extension is a good bet. **Please note**: this feature is currently not available for Windows-based images.
# How to use this Image
To run a pre-built jar file with the latest OpenJDK 21, use the following Dockerfile:
```dockerfile
FROM %%IMAGE%%:21
RUN mkdir /opt/app
COPY japp.jar /opt/app
CMD ["java", "-jar", "/opt/app/japp.jar"]
```
You can build and run the Docker Image as shown in the following example:
```console
docker build -t japp .
docker run -it --rm japp
```
### Using a different base Image
If you are using a distribution that we don't provide an image for you can copy the JDK using a similar Dockerfile to the one below:
```dockerfile
# Example
FROM <base image>
ENV JAVA_HOME=/opt/java/openjdk
COPY --from=%%IMAGE%%:21 $JAVA_HOME $JAVA_HOME
ENV PATH="${JAVA_HOME}/bin:${PATH}"
```
### Creating a JRE using jlink
On OpenJDK 21+, a JRE can be generated using `jlink`, see the following Dockerfile:
```dockerfile
# Example of custom Java runtime using jlink in a multi-stage container build
FROM %%IMAGE%%:21 as jre-build
# Create a custom Java runtime
RUN $JAVA_HOME/bin/jlink \
--add-modules java.base \
--strip-debug \
--no-man-pages \
--no-header-files \
--compress=2 \
--output /javaruntime
# Define your base image
FROM debian:buster-slim
ENV JAVA_HOME=/opt/java/openjdk
ENV PATH "${JAVA_HOME}/bin:${PATH}"
COPY --from=jre-build /javaruntime $JAVA_HOME
# Continue with your application deployment
RUN mkdir /opt/app
COPY japp.jar /opt/app
CMD ["java", "-jar", "/opt/app/japp.jar"]
```
If you want to place the jar file on the host file system instead of inside the container, you can mount the host path onto the container by using the following commands:
```dockerfile
FROM %%IMAGE%%:21.0.2_13-jdk
CMD ["java", "-jar", "/opt/app/japp.jar"]
```
```console
docker build -t japp .
docker run -it -v /path/on/host/system/jars:/opt/app japp
```
```
--------------------------------------------------------------------------------
/httpd/content.md:
--------------------------------------------------------------------------------
```markdown
# What is httpd?
The Apache HTTP Server, colloquially called Apache, is a Web server application notable for playing a key role in the initial growth of the World Wide Web. Originally based on the NCSA HTTPd server, development of Apache began in early 1995 after work on the NCSA code stalled. Apache quickly overtook NCSA HTTPd as the dominant HTTP server, and has remained the most popular HTTP server in use since April 1996.
> [wikipedia.org/wiki/Apache_HTTP_Server](http://en.wikipedia.org/wiki/Apache_HTTP_Server)
%%LOGO%%
# How to use this image.
This image only contains Apache httpd with the defaults from upstream. There is no PHP installed, but it should not be hard to extend. On the other hand, if you just want PHP with Apache httpd see the [PHP image](https://hub.docker.com/_/php/) and look at the `-apache` tags. If you want to run a simple HTML server, add a simple Dockerfile to your project where `public-html/` is the directory containing all your HTML.
### Create a `Dockerfile` in your project
```dockerfile
FROM %%IMAGE%%:2.4
COPY ./public-html/ /usr/local/apache2/htdocs/
```
Then, run the commands to build and run the Docker image:
```console
$ docker build -t my-apache2 .
$ docker run -dit --name my-running-app -p 8080:80 my-apache2
```
Visit http://localhost:8080 and you will see It works!
### Without a `Dockerfile`
If you don't want to include a `Dockerfile` in your project, it is sufficient to do the following:
```console
$ docker run -dit --name my-apache-app -p 8080:80 -v "$PWD":/usr/local/apache2/htdocs/ %%IMAGE%%:2.4
```
### Configuration
To customize the configuration of the httpd server, first obtain the upstream default configuration from the container:
```console
$ docker run --rm %%IMAGE%%:2.4 cat /usr/local/apache2/conf/httpd.conf > my-httpd.conf
```
You can then `COPY` your custom configuration in as `/usr/local/apache2/conf/httpd.conf`:
```dockerfile
FROM %%IMAGE%%:2.4
COPY ./my-httpd.conf /usr/local/apache2/conf/httpd.conf
```
#### SSL/HTTPS
If you want to run your web traffic over SSL, the simplest setup is to `COPY` or mount (`-v`) your `server.crt` and `server.key` into `/usr/local/apache2/conf/` and then customize the `/usr/local/apache2/conf/httpd.conf` by removing the comment symbol from the following lines:
```apacheconf
...
#LoadModule socache_shmcb_module modules/mod_socache_shmcb.so
...
#LoadModule ssl_module modules/mod_ssl.so
...
#Include conf/extra/httpd-ssl.conf
...
```
The `conf/extra/httpd-ssl.conf` configuration file will use the certificate files previously added and tell the daemon to also listen on port 443. Be sure to also add something like `-p 443:443` to your `docker run` to forward the https port.
This could be accomplished with a `sed` line similar to the following:
```dockerfile
RUN sed -i \
-e 's/^#\(Include .*httpd-ssl.conf\)/\1/' \
-e 's/^#\(LoadModule .*mod_ssl.so\)/\1/' \
-e 's/^#\(LoadModule .*mod_socache_shmcb.so\)/\1/' \
conf/httpd.conf
```
The previous steps should work well for development, but we recommend customizing your conf files for production, see [httpd.apache.org](https://httpd.apache.org/docs/2.4/ssl/ssl_faq.html) for more information about SSL setup.
```
--------------------------------------------------------------------------------
/hitch/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Hitch?
[Hitch](https://hitch-tls.org/) is a *libev-based* high performance *SSL/TLS proxy* by [Varnish Software](https://varnish-software.com). It is specifically built to terminate TLS connections at high scale and forwards unencrypted HTTP traffic to Varnish or any other HTTP backend.
# How to use this image
Running a Hitch Docker container can be done by using the following command:
```console
$ docker run --name=hitch -p 443:443 %%IMAGE%%
```
This container will expose port `443`, which is required for HTTPS traffic.
## Configuration file and extra options
Without any argument, the container will run `hitch --config=/etc/hitch/hitch.conf`. You can mount your own configuration file to replace the default one:
```console
$ docker run -v /path/to/your/config/file:/etc/hitch/hitch.conf:ro %%IMAGE%%
```
You can also change the path of the configuration file by setting the `HITCH_CONFIG_FILE` environment variable.
Note that extra arguments can be added to the command line. If the first argument starts with a `-`, the arguments are added to the default command line, otherwise they are treated as a command.
> Our assumption is that your backend, Varnish or other, supports both *HTTP/2* and the *PROXY* protocol.
## Connecting to the backend
By default Hitch will connect to the backend using `localhost:8843` using the [PROXY protocol](https://github.com/varnish/hitch/blob/master/docs/proxy-protocol.md). If your backend server *PROXY*, the two will be able to talk together and backend will be able to expose the true client IP.
But you'll probably run your backend service in a separate container. In that case, you'll want to change the backend settings. You can either do that by replacing the [`backend`](https://github.com/varnish/hitch/blob/master/hitch.conf.man.rst#backend--) configuration setting in your mounted configuration file, or by adding a *command-line option*.
Here's how you set the backend via a *command-line option*, assuming your backend is available through `backend.example.com` on port `8443`:
```console
$ docker run %%IMAGE%% "--backend=[backend.example.com]:8443"
```
## Setting the certificate
The Hitch Docker image comes with a self-signed certificate that is stored in `/etc/hitch/certs/default`.
This certificate is automatically created during *Hitch* package install, and is a self-signed certificate using 2048-bit RSA-encrypted cipher. It is set up for the `localhost` hostname, with an expiration date 30 years in the future.
This certificate is only suited for testing. Using a bind mount, you can override the value of the certificate and use your own certificate, which is advisable.
Here's an example:
```console
$ docker run -v /path/to/your/certificate:/etc/hitch/certs/default:ro %%IMAGE%%
```
You can also override the [`pem-file`](https://github.com/varnish/hitch/blob/master/hitch.conf.man.rst#pem-file--string) configuration setting in your mounted configuration file.
If you prefer setting the certificate location on the command line, you can add the location as part of the `--backend` option.
Here's how you do this:
```console
$ docker run %%IMAGE%% "--backend=[backend.example.com]:8443:/path/to/cert.pem"
```
```
--------------------------------------------------------------------------------
/backdrop/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Backdrop CMS?
Backdrop CMS is a comprehensive Content Management System for small to medium sized businesses and non-profits. It is a fork of the Drupal project.
Backdrop CMS enables people to build highly customized websites, affordably, through collaboration and open source software. For more on the Backdrop's philosophy see https://backdropcms.org/philosophy.
%%LOGO%%
# How to use this image
The basic pattern for starting a `%%REPO%%` instance is:
```console
$ docker run --name some-%%REPO%% --link some-mysql:mysql -d %%IMAGE%%
```
The following environment variables are also honored for configuring your Backdrop CMS instance:
- `-e BACKDROP_DB_HOST=...` (defaults to the IP and port of the linked `mysql` container)
- `-e BACKDROP_DB_USER=...` (defaults to "root")
- `-e BACKDROP_DB_PASSWORD=...` (defaults to the value of the `MYSQL_ROOT_PASSWORD` environment variable from the linked `mysql` container)
- `-e BACKDROP_DB_NAME=...` (defaults to "backdrop")
- `-e BACKDROP_DB_PORT=...` (defaults to 3306)
- `-e BACKDROP_DB_DRIVER=...` (defaults to "mysql")
The `BACKDROP_DB_NAME` **must already exist** on the given MySQL server. Check out the [official mysql image](https://hub.docker.com/_/mysql/) for more info on spinning up a DB.
If you'd like to be able to access the instance from the host without the container's IP, standard port mappings can be used:
```console
$ docker run --name some-%%REPO%% --link some-mysql:mysql -p 8080:80 -d %%IMAGE%%
```
Then, access it via `http://localhost:8080` or `http://host-ip:8080` in a browser.
If you'd like to use an external database instead of a linked `mysql` container, specify the hostname and port with `BACKDROP_DB_HOST`/`BACKDROP_DB_PORT` along with the password in `BACKDROP_DB_PASSWORD` and the username in `BACKDROP_DB_USER` (if it is something other than `root`):
```console
$ docker run --name some-%%REPO%% \
-e BACKDROP_DB_HOST=10.1.2.3 \
-e BACKDROP_DB_PORT=10432 \
-e BACKDROP_DB_USER=... \
-e BACKDROP_DB_PASSWORD=... \
-d %%REPO%%
```
## %%COMPOSE%%
Run `docker compose up`, wait for it to initialize completely, and visit `http://localhost:8080` or `http://host-ip:8080`.
## Adding additional libraries / extensions
This image does not provide any additional PHP extensions or other libraries, even if they are required by popular plugins. There are an infinite number of possible plugins, and they potentially require any extension PHP supports. Including every PHP extension that exists would dramatically increase the image size.
If you need additional PHP extensions, you'll need to create your own image `FROM` this one. The [documentation of the `php` image](https://github.com/docker-library/docs/blob/master/php/README.md#how-to-install-more-php-extensions) explains how to compile additional extensions. Additionally, the [`drupal:7` Dockerfile](https://github.com/docker-library/drupal/blob/bee08efba505b740a14d68254d6e51af7ab2f3ea/7/Dockerfile#L6-9) has an example of doing this.
The following Docker Hub features can help with the task of keeping your dependent images up-to-date:
- [Automated Builds](https://docs.docker.com/docker-hub/builds/) let Docker Hub automatically build your Dockerfile each time you push changes to it.
```
--------------------------------------------------------------------------------
/oraclelinux/content.md:
--------------------------------------------------------------------------------
```markdown
# Oracle Linux
%%LOGO%%
Oracle Linux is an open-source operating system available under the GNU General Public License (GPLv2). Suitable for general purpose or Oracle workloads, it benefits from rigorous testing of more than 128,000 hours per day with real- world workloads and includes unique innovations such as Ksplice for zero- downtime kernel patching, DTrace for real-time diagnostics, the powerful Btrfs file system, and more.
> **NOTE:** the `oraclelinux` image intentionally does *not* provide a `latest` tag. You must specify [an existing tag](https://hub.docker.com/_/oraclelinux?tab=tags) when referencing this image. See *"Removal of the `latest` tag"* below for further details.
## How to use these images
The Oracle Linux images are intended for use in the **FROM** field of a downstream `Dockerfile`. For example, to use the latest optimized Oracle Linux 8 image, specify `FROM %%IMAGE%%:8`.
## Removal of `latest` tag
The `latest` tag was removed from the Oracle Linux official images in June 2020 to avoid breaking any downstream images caused by backwards-incompatible changes introduced by the release of a new version. Downstream images must specify the version, i.e. `oraclelinux:7` or `oraclelinux:8`.
### Differences between `oraclelinux:8` and `oraclelinux:8-slim`
Oracle recommends using `oraclelinux:8` for most images that extend Oracle Linux 8.
The `oraclelinux:8-slim` variant is intended primarily to provide "just enough user space" for statically compiled binaries or microservices. Use of the `8-slim` variant is discouraged for general purposes, due to the inclusion of `microdnf` in place of `dnf` and signficantly reduced locale data.
### Differences between `oraclelinux:7` and `oraclelinux:7-slim`
For images that want an Oracle Linux 7 user space, Oracle recommends using `oraclelinux:7-slim` as the base layer as it contains just enough packages for `yum` to be able to install more packages.
The `oraclelinux:7` images is based on the package set of what would be installed on a bare-metal server when performing a minimal install of Oracle Linux.
## Changelog
Oracle maintains a [CHANGELOG](https://github.com/oracle/container-images/blob/main/CHANGELOG.md) that documents by release date the errata applied and any CVE(s) that are mitigated in each update to the official images.
## Official Resources
- [Oracle Linux documentation](https://docs.oracle.com/en/operating-systems/oracle-linux/index.html)
- [Oracle Linux Yum Server](http://yum.oracle.com)
- [Unbreakable Linux Network](https://linux.oracle.com)
## Customer Support
Oracle provides support to Oracle Linux subscription customers via the [My Oracle Support](https://support.oracle.com) portal. The Oracle Linux container images are covered by Oracle Linux Basic and Premier support subscriptions. Customers should follow existing support procedures to obtain support for Oracle Linux running in a container.
## Community Support
Users without an Oracle Linux support subscription should either [open an issue](https://github.com/oracle/container-images/issues) or [start a discussion](https://github.com/oracle/container-images/discussions) in the [Oracle Linux container image repository](https://github.com/oracle/container-images) on GitHub.
```
--------------------------------------------------------------------------------
/openjdk/content.md:
--------------------------------------------------------------------------------
```markdown
# What is OpenJDK?
OpenJDK (Open Java Development Kit) is a free and open source implementation of the Java Platform, Standard Edition (Java SE). OpenJDK is the official reference implementation of Java SE since version 7.
> [wikipedia.org/wiki/OpenJDK](http://en.wikipedia.org/wiki/OpenJDK)
Java is a registered trademark of Oracle and/or its affiliates.
%%LOGO%%
# How to use this image
## Start a Java instance in your app
The most straightforward way to use this image is to use a Java container as both the build and runtime environment. In your `Dockerfile`, writing something along the lines of the following will compile and run your project:
```dockerfile
FROM %%IMAGE%%:11
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
RUN javac Main.java
CMD ["java", "Main"]
```
You can then run and build the Docker image:
```console
$ docker build -t my-java-app .
$ docker run -it --rm --name my-running-app my-java-app
```
## Compile your app inside the Docker container
There may be occasions where it is not appropriate to run your app inside a container. To compile, but not run your app inside the Docker instance, you can write something like:
```console
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:11 javac Main.java
```
This will add your current directory as a volume to the container, set the working directory to the volume, and run the command `javac Main.java` which will tell Java to compile the code in `Main.java` and output the Java class file to `Main.class`.
## Make JVM respect CPU and RAM limits
On startup the JVM tries to detect the number of available CPU cores and RAM to adjust its internal parameters (like the number of garbage collector threads to spawn) accordingly. When the container is ran with limited CPU/RAM then the standard system API used by the JVM for probing it will return host-wide values. This can cause excessive CPU usage and memory allocation errors with older versions of the JVM.
Inside Linux containers, OpenJDK versions 8 and later can correctly detect the container-limited number of CPU cores and available RAM. For all currently supported OpenJDK versions this is turned on by default.
Inside Windows Server (non-Hyper-V) containers, the limit for the number of available CPU cores doesn't work (it's ignored by Host Compute Service). To set the limit manually the JVM can be started as:
```console
$ start /b /wait /affinity 0x3 path/to/java.exe ...
```
In this example CPU affinity hex mask `0x3` will limit the JVM to 2 CPU cores.
RAM limit is supported by Windows Server containers, but currently the JVM cannot detect it. To prevent excessive memory allocations, `-XX:MaxRAM=...` option must be specified with the value that is not bigger than the containers RAM limit.
## Environment variables with periods in their names
Some shells (notably, [the BusyBox `/bin/sh` included in Alpine Linux](https://github.com/docker-library/openjdk/issues/135)) do not support environment variables with periods in the names (which are technically not POSIX compliant), and thus *strip* them instead of passing them through (as Bash does). If your application requires environment variables of this form, either use `CMD ["java", ...]` directly (no shell), or (install and) use Bash explicitly instead of `/bin/sh`.
```
--------------------------------------------------------------------------------
/haproxy/content.md:
--------------------------------------------------------------------------------
```markdown
# What is HAProxy?
HAProxy is a free, open source high availability solution, providing load balancing and proxying for TCP and HTTP-based applications by spreading requests across multiple servers. It is written in C and has a reputation for being fast and efficient (in terms of processor and memory usage).
> [wikipedia.org/wiki/HAProxy](https://en.wikipedia.org/wiki/HAProxy)
%%LOGO%%
# How to use this image
Since no two users of HAProxy are likely to configure it exactly alike, this image does not come with any default configuration.
Please refer to [upstream's excellent (and comprehensive) documentation](https://docs.haproxy.org/) on the subject of configuring HAProxy for your needs.
It is also worth checking out the [`examples/` directory from upstream](http://git.haproxy.org/?p=haproxy-2.3.git;a=tree;f=examples).
## Create a `Dockerfile`
```dockerfile
FROM %%IMAGE%%:2.3
COPY haproxy.cfg /usr/local/etc/haproxy/haproxy.cfg
```
## Build the container
```console
$ docker build -t my-haproxy .
```
## Test the configuration file
```console
$ docker run -it --rm --name haproxy-syntax-check my-haproxy haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg
```
## Run the container
```console
$ docker run -d --name my-running-haproxy --sysctl net.ipv4.ip_unprivileged_port_start=0 my-haproxy
```
You will need a kernel at [version 4.11 or newer](https://github.com/moby/moby/issues/8460#issuecomment-312459310) to use `--sysctl net.ipv4.ip_unprivileged_port_start=0` , you may need to publish the ports your HAProxy is listening on to the host by specifying the -p option, for example -p 8080:80 to publish port 8080 from the container host to port 80 in the container. Make sure the port you're using is free.
**Note:** the 2.4+ versions of the container will run as `USER haproxy` by default (hence the `--sysctl net.ipv4.ip_unprivileged_port_start=0` above), but older versions still default to `root` for compatibility reasons; use `--user haproxy` (or any other UID) if you want to run as non-root in older versions.
## Directly via bind mount
```console
$ docker run -d --name my-running-haproxy -v /path/to/etc/haproxy:/usr/local/etc/haproxy:ro --sysctl net.ipv4.ip_unprivileged_port_start=0 %%IMAGE%%:2.3
```
Note that your host's `/path/to/etc/haproxy` folder should be populated with a file named `haproxy.cfg`. If this configuration file refers to any other files within that folder then you should ensure that they also exist (e.g. template files such as `400.http`, `404.http`, and so forth). However, many minimal configurations do not require any supporting files.
### Reloading config
If you used a bind mount for the config and have edited your `haproxy.cfg` file, you can use HAProxy's graceful reload feature by sending a `SIGHUP` to the container:
```console
$ docker kill -s HUP my-running-haproxy
```
The entrypoint script in the image checks for running the command `haproxy` and replaces it with `haproxy-systemd-wrapper` from HAProxy upstream which takes care of signal handling to do the graceful reload. Under the hood this uses the `-sf` option of `haproxy` so "there are two small windows of a few milliseconds each where it is possible that a few connection failures will be noticed during high loads" (see [Stopping and restarting HAProxy](http://www.haproxy.org/download/2.3/doc/management.txt)).
```
--------------------------------------------------------------------------------
/golang/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Go?
Go (a.k.a., Golang) is a programming language first developed at Google. It is a statically-typed language with syntax loosely derived from C, but with additional features such as garbage collection, type safety, some dynamic-typing capabilities, additional built-in types (e.g., variable-length arrays and key-value maps), and a large standard library.
> [wikipedia.org/wiki/Go_(programming_language)](http://en.wikipedia.org/wiki/Go_%28programming_language%29)
%%LOGO%%
# How to use this image
**Note:** `/go` is world-writable to allow flexibility in the user which runs the container (for example, in a container started with `--user 1000:1000`, running `go get github.com/example/...` into the default `$GOPATH` will succeed). While the `777` directory would be insecure on a regular host setup, there are not typically other processes or users inside the container, so this is equivalent to `700` for Docker usage, but allowing for `--user` flexibility.
## Start a Go instance in your app
The most straightforward way to use this image is to use a Go container as both the build and runtime environment. In your `Dockerfile`, writing something along the lines of the following will compile and run your project (assuming it uses `go.mod` for dependency management):
```dockerfile
FROM %%IMAGE%%:1.24
WORKDIR /usr/src/app
# pre-copy/cache go.mod for pre-downloading dependencies and only redownloading them in subsequent builds if they change
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN go build -v -o /usr/local/bin/app ./...
CMD ["app"]
```
You can then build and run the Docker image:
```console
$ docker build -t my-golang-app .
$ docker run -it --rm --name my-running-app my-golang-app
```
## Compile your app inside the Docker container
There may be occasions where it is not appropriate to run your app inside a container. To compile, but not run your app inside the Docker instance, you can write something like:
```console
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:1.24 go build -v
```
This will add your current directory as a volume to the container, set the working directory to the volume, and run the command `go build` which will tell go to compile the project in the working directory and output the executable to `myapp`. Alternatively, if you have a `Makefile`, you can run the `make` command inside your container.
```console
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:1.24 make
```
## Cross-compile your app inside the Docker container
If you need to compile your application for a platform other than `linux/amd64` (such as `windows/386`):
```console
$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp -e GOOS=windows -e GOARCH=386 %%IMAGE%%:1.24 go build -v
```
Alternatively, you can build for multiple platforms at once:
```console
$ docker run --rm -it -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%:1.24 bash
$ for GOOS in darwin linux; do
> for GOARCH in 386 amd64; do
> export GOOS GOARCH
> go build -v -o myapp-$GOOS-$GOARCH
> done
> done
```
## Git LFS
If downloading your dependencies results in an error like "checksum mismatch", you should check whether they are using [Git LFS](https://git-lfs.com/) (and thus need it installed for downloading them and calculating correct `go.sum` values).
```
--------------------------------------------------------------------------------
/crate/content.md:
--------------------------------------------------------------------------------
```markdown
%%LOGO%%
# What Is CrateDB?
[CrateDB](http://github.com/crate/crate) is a distributed SQL database that makes it simple to store and analyze massive amounts of machine data in real-time.
CrateDB offers the scalability and flexibility typically associated with a NoSQL database, is designed to run on inexpensive commodity servers and can be deployed and run on any sort of network - from personal computers to multi-region hybrid clouds.
The smallest CrateDB clusters can easily ingest tens of thousands of records per second. The data can be queried, ad-hoc, in parallel across the whole cluster in real time.
# Features
- Standard SQL plus dynamic schemas, queryable objects, geospatial features, time series data, first-class BLOB support, and realtime full-text search.
- Dynamic schemas, queryable objects, geospatial features, time series data support, and realtime full-text search providing functionality for handling both relational and document oriented nested data structures.
- Horizontally scalable, highly available and fault tolerant clusters that run very well in virtualized and containerised environments.
- Extremely fast distributed query execution.
- Auto-partitioning, auto-sharding, and auto-replication.
- Self-healing and auto-rebalancing.
# Screenshots
CrateDB provides an [Admin UI](https://crate.io/docs/crate/admin-ui/):
# Try CrateDB
Spin up this Docker image like so:
```console
$ docker run --publish 4200:4200 --publish 5432:5432 %%IMAGE%% -Cdiscovery.type=single-node
```
Visit the [getting started](https://crate.io/docs/crate/tutorials/en/latest/install-run/) page to see all the available download and install options.
Once you're up and running, head over to the [introductory docs](https://crate.io/docs/crate/tutorials/). To interact with CrateDB, you can use the Admin UI [web console](https://crate.io/docs/crate/admin-ui/en/latest/console.html#sql-console) or the [CrateDB shell](https://crate.io/docs/crate/crash/) CLI tool. Alternatively, review the list of recommended [clients and tools](https://crate.io/docs/crate/clients-tools/) that work with CrateDB.
For container-specific documentation, check out the [CrateDB on Docker how-to guide](https://crate.io/docs/crate/howtos/en/latest/deployment/containers/docker.html) or the [CrateDB on Kubernetes how-to guide](https://crate.io/docs/crate/howtos/en/latest/deployment/containers/kubernetes.html).
## Issues
### Memory Accounting
The combinations of Linux kernel version 3.x and Docker >= 1.12 could lead to a major problem with memory accounting causing the kernel to kill the CrateDB process in the container. This problems occurs because of a [slab shrinker issue](https://lwn.net/Articles/628829/) that is fixed in kernel versions >= 4.0.
### Others
For issue specific to the CrateDB Docker image, report issues via [the `docker-crate` GitHub issue tracker](https://github.com/crate/docker-crate/issues)
For issues with CrateDB itself, report issues via [the `crate` GitHub issue tracker](https://github.com/crate/crate/issues)
## Contributing
This image is primarily maintained by [Crate.io](http://crate.io/), but we welcome community contributions!
See the [contribution docs](https://github.com/crate/docker-crate/blob/master/CONTRIBUTING.rst) for more information.
```
--------------------------------------------------------------------------------
/ubuntu/content.md:
--------------------------------------------------------------------------------
```markdown
# What is Ubuntu?
Ubuntu is a Debian-based Linux operating system that runs from the desktop to the cloud, to all your internet connected things. It is the world's most popular operating system across public clouds and OpenStack clouds. It is the number one platform for containers; from Docker to Kubernetes to LXD, Ubuntu can run your containers at scale. Fast, secure and simple, Ubuntu powers millions of PCs worldwide.
Development of Ubuntu is led by Canonical Ltd. Canonical generates revenue through the sale of technical support and other services related to Ubuntu. The Ubuntu project is publicly committed to the principles of open-source software development; people are encouraged to use free software, study how it works, improve upon it, and distribute it.
> [wikipedia.org/wiki/Ubuntu](https://en.wikipedia.org/wiki/Ubuntu)
%%LOGO%%
# What's in this image?
This image is built from official rootfs tarballs provided by Canonical (see `dist-*` tags at https://git.launchpad.net/cloud-images/+oci/ubuntu-base).
The `%%IMAGE%%:latest` tag points to the "latest LTS", since that's the version recommended for general use. The `%%IMAGE%%:rolling` tag points to the latest release (regardless of LTS status).
Along a similar vein, the `%%IMAGE%%:devel` tag is an alias for whichever release the "devel" suite on the mirrors currently points to, as determined by the following one-liner: `wget -qO- http://archive.ubuntu.com/ubuntu/dists/devel/Release | awk -F ': ' '$1 == "Codename" { print $2; exit }'`
## Locales
Given that it is a minimal install of Ubuntu, this image only includes the `C`, `C.UTF-8`, and `POSIX` locales by default. For most uses requiring a UTF-8 locale, `C.UTF-8` is likely sufficient (`-e LANG=C.UTF-8` or `ENV LANG C.UTF-8`).
For uses where that is not sufficient, other locales can be installed/generated via the `locales` package. [PostgreSQL has a good example of doing so](https://github.com/docker-library/postgres/blob/69bc540ecfffecce72d49fa7e4a46680350037f9/9.6/Dockerfile#L21-L24), copied below:
```dockerfile
RUN apt-get update && apt-get install -y locales && rm -rf /var/lib/apt/lists/* \
&& localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8
ENV LANG en_US.utf8
```
## Unminimize
Starting from [Ubuntu 24.10 "Oracular Oriole"](https://discourse.ubuntu.com/t/oracular-oriole-release-notes/44878#unminimize), the `unminimize` command will no longer be shipped by default on minimal images. It has now been moved to a dedicated package which can be installed via `apt-get install -y unminimize`.
# How is the rootfs built?
The tarballs published by Canonical, referenced by `dist-*` tags in https://git.launchpad.net/cloud-images/+oci/ubuntu-base Git repository, are built from scripts that live in [the livecd-rootfs project](https://code.launchpad.net/~ubuntu-core-dev/livecd-rootfs/+git/livecd-rootfs/+ref/ubuntu/master), especially `live-build/auto/build`. The builds are run on Launchpad. For build history see `livefs` build pages of individual releases on Launchpad:
- [Focal](https://launchpad.net/~cloud-images-release-managers/+livefs/ubuntu/focal/ubuntu-oci)
- [Jammy](https://launchpad.net/~cloud-images-release-managers/+livefs/ubuntu/jammy/ubuntu-oci)
- [Noble](https://launchpad.net/~cloud-images-release-managers/+livefs/ubuntu/noble/ubuntu-oci)
- [Oracular](https://launchpad.net/~cloud-images-release-managers/+livefs/ubuntu/oracular/ubuntu-oci)
```
--------------------------------------------------------------------------------
/mediawiki/content.md:
--------------------------------------------------------------------------------
```markdown
# What is MediaWiki?
MediaWiki is free and open-source wiki software. Originally developed by Magnus Manske and improved by Lee Daniel Crocker, it runs on many websites, including Wikipedia, Wiktionary and Wikimedia Commons. It is written in the PHP programming language and stores the contents into a database. Like WordPress, which is based on a similar licensing and architecture, it has become the dominant software in its category.
> [wikipedia.org/wiki/MediaWiki](https://en.wikipedia.org/wiki/MediaWiki)
%%LOGO%%
# How to use this image
The basic pattern for starting a `%%REPO%%` instance is:
```console
$ docker run --name some-%%REPO%% -d %%IMAGE%%
```
If you'd like to be able to access the instance from the host without the container's IP, standard port mappings can be used:
```console
$ docker run --name some-%%REPO%% -p 8080:80 -d %%IMAGE%%
```
Then, access it via `http://localhost:8080` or `http://host-ip:8080` in a browser.
There are multiple database types supported by this image, most easily used via standard container linking. In the default configuration, SQLite can be used to avoid a second container and write to flat-files. More detailed instructions for different (more production-ready) database types follow.
When first accessing the webserver provided by this image, it will go through a brief setup process. The details provided below are specifically for the "Set up database" step of that configuration process.
## MySQL
```console
$ docker run --name some-%%REPO%% --link some-mysql:mysql -d %%IMAGE%%
```
- Database type: `MySQL, MariaDB, or equivalent`
- Database name/username/password: `<details for accessing your MySQL instance>` (`MYSQL_USER`, `MYSQL_PASSWORD`, `MYSQL_DATABASE`; see environment variables in the description for [`mariadb`](https://hub.docker.com/_/mariadb/))
- ADVANCED OPTIONS; Database host: `some-mysql` (for using the `/etc/hosts` entry added by `--link` to access the linked container's MySQL instance)
## Volumes
By default, this image does not include any volumes.
The paths `/var/www/html/images` and `/var/www/html/LocalSettings.php` are things that generally ought to be volumes, but do not explicitly have a `VOLUME` declaration in this image because volumes cannot be removed.
```console
$ docker run --rm %%IMAGE%% tar -cC /var/www/html/sites . | tar -xC /path/on/host/sites
```
## %%COMPOSE%%
Run `docker compose up`, wait for it to initialize completely, and visit `http://localhost:8080` or `http://host-ip:8080` (as appropriate).
## Adding additional libraries / extensions
This image does not provide any additional PHP extensions or other libraries, even if they are required by popular plugins. There are an infinite number of possible plugins, and they potentially require any extension PHP supports. Including every PHP extension that exists would dramatically increase the image size.
If you need additional PHP extensions, you'll need to create your own image `FROM` this one. The [documentation of the `php` image](https://github.com/docker-library/docs/blob/31280550a3c7104fef824450753844d2f3d917be/php/README.md#how-to-install-more-php-extensions) explains how to compile additional extensions.
The following Docker Hub features can help with the task of keeping your dependent images up-to-date:
- [Automated Builds](https://docs.docker.com/docker-hub/builds/) let Docker Hub automatically build your Dockerfile each time you push changes to it.
```