MBCDN

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen: • awk
osrm

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
Nächste Überarbeitung 		Vorhergehende Überarbeitung
osrm [2026/03/29 04:00]
jango [Ubuntu 22.04] 		osrm [2026/04/04 12:09] (aktuell)
admin [Datenbasis]
Zeile 1: Zeile 1:
-Open Source Routing Machine. Siehe auch [[OpenStreetMap]]+OSRM (Open Source Routing Machine) ist eine Open-Source Routing-Engine für Straßennetze auf Basis von [[OpenStreetMap]]-Daten (OSM). Das Projekt ist in C++ implementiert und auf sehr schnelle Routenberechnung ausgelegt. Im Unterschied zu Geocodern wie [[Nominatim]] übersetzt OSRM keine Adressen in Koordinaten, sondern berechnet Wege zwischen bereits bekannten Koordinaten auf dem zugrunde liegenden Straßennetz. 
 + 
 +OSRM kann sowohl als HTTP-Dienst betrieben als auch als Bibliothek genutzt werden. Die offizielle Dokumentation beschreibt dafür eine HTTP-API, eine C++ Bibliothek namens libosrm sowie einen Node.js Wrapper.
  
 Demo [[https://router.project-osrm.org/route/v1/driving/16.3725,48.2082;16.3738,48.2100?overview=false]] Demo [[https://router.project-osrm.org/route/v1/driving/16.3725,48.2082;16.3738,48.2100?overview=false]]
 +
 +<code python>
 +import requests
 +
 +def get_route(start_lon: float, start_lat: float, end_lon: float, end_lat: float) -> dict:
 +    url = (
 +        f"http://localhost:5000/route/v1/driving/"
 +        f"{start_lon},{start_lat};{end_lon},{end_lat}"
 +    )
 +    params = {
 +        "overview": "false",
 +        "steps": "true"
 +    }
 +
 +    response = requests.get(url, params=params, timeout=10)
 +    response.raise_for_status()
 +    return response.json()
 +
 +
 +result = get_route(16.37208, 48.20849, 16.37382, 48.20672)
 +
 +route = result["routes"][0]
 +print("Distanz in Metern:", route["distance"])
 +print("Dauer in Sekunden:", route["duration"])
 +</code>
 +
 +=====Datenbasis=====
 +OSRM verarbeitet OpenStreetMap-Daten in einem Vorbereitungsprozess und erzeugt daraus speziell optimierte Routing-Datenstrukturen. Laut Projektseite unterstützt OSRM den Import von OSM-Daten (siehe [[PBF]]), ist für sehr große Netze ausgelegt und bietet vorkonfigurierte Profile für Auto, Fahrrad und Fußweg. Das Routing-Verhalten kann über Profile angepasst werden.
 +
 +Für die Datenvorbereitung werden Werkzeuge wie osrm-extract, osrm-contract, osrm-partition und osrm-customize verwendet. Welche Schritte nötig sind, hängt vom gewählten Routing-Algorithmus ab. Die Dokumentation und projektnahen Quellen unterscheiden dabei insbesondere zwischen CH (Contraction Hierarchies) und MLD (Multi-Level Dijkstra).
 +
 +=====API-Endpunkte=====
 +
 +Die HTTP-API von OSRM verwendet in Version 5.x das Protokoll v1. Die zentralen Dienste sind:
 +
 +  * route
 +  * nearest
 +  * table
 +  * match
 +  * trip
 +  * tile
 +
 +====Route====
 +
 +Der Dienst [[https://project-osrm.org/docs/v5.24.0/api/#route-service|route]] berechnet die schnellste Route zwischen Koordinaten auf Basis des gewählten Profils, zum Beispiel driving, bike oder foot. Er liefert unter anderem Distanz, Dauer und auf Wunsch Geometrien und Turn-by-Turn-Informationen.
 +
 +Beispiel:
 +
 +/route/v1/driving/16.37208,48.20849;16.37382,48.20672?overview=false
 +
 +====Nearest====
 +
 +Der Dienst [[https://project-osrm.org/docs/v5.24.0/api/#nearest-service|nearest]] ordnet eine Koordinate dem nächstgelegenen Straßensegment zu. Das ist nützlich, um GPS-Punkte auf das Routing-Netz zu „snappen“.
 +
 +====Table====
 +
 +Der Dienst [[https://project-osrm.org/docs/v5.24.0/api/#table-service|table]] berechnet eine Matrix aus Fahrzeiten oder Distanzen zwischen mehreren Koordinaten. Laut API-Dokumentation liefert table bei Distanzen nicht die Luftlinie, sondern die Distanzen der jeweils schnellsten Routen im Straßennetz.
 +
 +====Match====
 +
 +Der Dienst [[https://project-osrm.org/docs/v5.24.0/api/#match-service|match]] dient dem Map-Matching. Dabei werden GPS-Spuren auf wahrscheinliche Straßenverläufe abgebildet. Das ist besonders für Tracking- oder Flottenanwendungen relevant.
 +
 +====Trip====
 +
 +Der Dienst [[https://project-osrm.org/docs/v5.24.0/api/#trip-service|trip]] berechnet eine sinnvolle Reihenfolge für mehrere Wegpunkte. Das Problem ist verwandt mit dem Traveling-Salesman-Problem und eignet sich für einfache Tourenplanung.
 +
 +====Tile====
 +
 +Der Dienst [[https://project-osrm.org/docs/v5.24.0/api/#tile-service|tile]] stellt Kachelinformationen für Debugging und Visualisierung bereit.
 +
 +=====Profile=====
 +
 +Das Routing-Verhalten von OSRM wird durch Lua-Profile bestimmt. Das Profil wird bereits bei der Datenaufbereitung festgelegt und definiert, welche Straßen befahrbar sind und wie Geschwindigkeiten, Einschränkungen oder Präferenzen behandelt werden. Die offiziellen Beispiele nennen insbesondere car, bike und foot.
 +
 +Dadurch lässt sich OSRM an verschiedene Einsatzszenarien anpassen, etwa für klassische Autonavigation, Fahrrad-Routing oder Fußwege. Eigene Profile sind möglich, wenn projektspezifische Regeln benötigt werden. Diese Schlussfolgerung ergibt sich aus der dokumentierten Profil-Logik und der Lua-basierten Konfiguration.
  
 =====Setup===== =====Setup=====
  
-====WSL====+  * Disk > 15GB 
 +  * RAM > 8GB
  
 +====WSL Demo====
 +Non persistent
 <code bash> <code bash>
 #!/usr/bin/env bash #!/usr/bin/env bash
Zeile 197: Zeile 277:
 </code> </code>
  
-====Ubuntu 22.04====+====Ubuntu Setup Manager==== 
 + 
 +<code> 
 +curl "https://download.geofabrik.de/europe/austria-latest.osm.pbf" -o austria-latest.osm.pbf 
 +</code>
  
 <code bash> <code bash>
 #!/usr/bin/env bash #!/usr/bin/env bash
-set -Eeuo pipefail+set -euo pipefail
  
-# ============================================================ +COMMAND="${1:-}" 
-# Nominatim Setup für Ubuntu 22.04 + austria-latest.osm.pbf +PBF_PATH="${2:-}" 
-# Getestetes Ziel: frische Ubuntu-22.04-Maschine +PROFILE="${3:-car}"
-# +
-# Aufrufbeispiel: +
-#   sudo bash setup-nominatim-ubuntu2204.sh /pfad/zu/austria-latest.osm.pbf +
-# +
-# Optional per Env überschreiben: +
-#   NOMINATIM_USER=nominatim +
-#   NOMINATIM_HOME=/srv/nominatim +
-#   PROJECT_DIR=/srv/nominatim/nominatim-project +
-#   VENV_DIR=/srv/nominatim/nominatim-venv +
-#   FLATNODE_FILE=/srv/nominatim/flatnode/flatnode.file +
-#   INSTALL_FRONTEND=1 +
-#   SETUP_UPDATES=0 +
-# ============================================================+
  
-if [[ "${EUID}" -ne 0 ]]; then +PORT="${PORT:-5000}" 
-  echo "Bitte als root ausführen: sudo bash $0 /pfad/zu/austria-latest.osm.pbf" +CONTAINER_NAME="${CONTAINER_NAME:-osrm-demo}" 
-  exit 1 +WORKDIR="${WORKDIR:-/var/lib/osrm}" 
-fi+IMAGE="${IMAGE:-osrm/osrm-backend}"
  
-OSM_PBF="${1:-}" +need_root() { 
-if [[ -z "${OSM_PBF}" ]]; then +  if [[ "${EUID}" -ne 0 ]]; then 
-  echo "Fehler: Bitte Pfad zur .osm.pbf-Datei angeben." +    echo "Bitte mit sudo starten." 
-  echo "Beispiel: sudo bash $0 /data/austria-latest.osm.pbf" +    echo "Beispiele:" 
-  exit 1 +    echo "  sudo bash osrm-manager.sh build /pfad/austria-latest.osm.pbf car" 
-fi+    echo "  sudo bash osrm-manager.sh start /pfad/austria-latest.osm.pbf car" 
 +    exit 1 
 +  fi 
 +}
  
-if [[ ! -f "${OSM_PBF}" ]]; then +usage() { 
-  echo "Fehler: Datei nicht gefunden: ${OSM_PBF}" +  cat <<EOF 
-  exit 1 +Verwendung: 
-fi+  sudo bash osrm-manager.sh build  /pfad/datei.osm.pbf [car|bike|foot] 
 +  sudo bash osrm-manager.sh start  /pfad/datei.osm.pbf [car|bike|foot] 
 +  sudo bash osrm-manager.sh stop 
 +  sudo bash osrm-manager.sh restart /pfad/datei.osm.pbf [car|bike|foot] 
 +  sudo bash osrm-manager.sh status 
 +  sudo bash osrm-manager.sh logs 
 +  sudo bash osrm-manager.sh url [car|bike|foot]
  
-NOMINATIM_USER="${NOMINATIM_USER:-nominatim}" +Umgebungsvariablen: 
-NOMINATIM_HOME="${NOMINATIM_HOME:-/srv/nominatim}" +  PORT=5000 
-PROJECT_DIR="${PROJECT_DIR:-${NOMINATIM_HOME}/nominatim-project}" +  CONTAINER_NAME=osrm-demo 
-VENV_DIR="${VENV_DIR:-${NOMINATIM_HOME}/nominatim-venv}" +  WORKDIR=/var/lib/osrm 
-FLATNODE_FILE="${FLATNODE_FILE:-${NOMINATIM_HOME}/flatnode/flatnode.file}" +  IMAGE=osrm/osrm-backend
-INSTALL_FRONTEND="${INSTALL_FRONTEND:-1}"   # 1 = gunicorn/uvicorn + systemd +
-SETUP_UPDATES="${SETUP_UPDATES:-0}"         # 1 = Geofabrik Austria daily updates initialisieren +
-OSM2PGSQL_REPO="${OSM2PGSQL_REPO:-https://github.com/osm2pgsql-dev/osm2pgsql.git}" +
-OSM2PGSQL_SRC="${NOMINATIM_HOME}/osm2pgsql" +
-OSM2PGSQL_BUILD="${NOMINATIM_HOME}/osm2pgsql-build"+
  
-POSTGRES_VER="14"+Hinweis: 
 +  Für jedes Profil werden eigene Daten verwendet: 
 +    /var/lib/osrm/car 
 +    /var/lib/osrm/bike 
 +    /var/lib/osrm/foot 
 +EOF 
 +}
  
-log() { echo -e "\n>>> $*\n"; }+check_profile() { 
 +  case "$PROFILE" in 
 +    car) 
 +      LUA_PROFILE="/opt/car.lua" 
 +      SERVICE_MODE="driving" 
 +      ;; 
 +    bike) 
 +      LUA_PROFILE="/opt/bicycle.lua" 
 +      SERVICE_MODE="cycling" 
 +      ;; 
 +    foot) 
 +      LUA_PROFILE="/opt/foot.lua" 
 +      SERVICE_MODE="walking" 
 +      ;; 
 +    *) 
 +      echo "Fehler: Unbekanntes Profil '$PROFILE'. Erlaubt: car | bike | foot" 
 +      exit 1 
 +      ;; 
 +  esac
  
-require_cmd() { +  export LUA_PROFILE SERVICE_MODE
-  command -v "$1" >/dev/null 2>&1 || { +
-    echo "Fehlendes Kommando: $1" +
-    exit 1 +
-  }+
 } }
  
-# ------------------------------------------------------------ +install_docker_if_missing() { 
-# 1) Pakete installieren +  if command -v docker >/dev/null 2>&1; then 
-# ------------------------------------------------------------ +    echo "Docker vorhanden: $(docker --version || true)" 
-log "Installiere Systempakete" +    return 
-apt-get update -qq +  fi
-DEBIAN_FRONTEND=noninteractive apt-get install -y \ +
-  build-essential cmake g++ git curl ca-certificates lsb-release \ +
-  libboost-dev libboost-system-dev libboost-filesystem-dev \ +
-  libexpat1-dev zlib1g-dev libbz2-dev libpq-dev \ +
-  liblua5.3-dev lua5.3 lua-dkjson \ +
-  nlohmann-json3-dev libicu-dev virtualenv \ +
-  postgresql-${POSTGRES_VER}-postgis-3 \ +
-  postgresql-contrib-${POSTGRES_VER} \ +
-  postgresql-${POSTGRES_VER}-postgis-3-scripts+
  
-require_cmd git +  echo "==> Docker wird installiert"
-require_cmd cmake +
-require_cmd psql +
-require_cmd virtualenv+
  
-# ------------------------------------------------------------ +  apt-get update 
-# 2) User anlegen +  apt-get install -y ca-certificates curl
-# ------------------------------------------------------------ +
-log "Lege Systembenutzer ${NOMINATIM_USER} an" +
-if ! id -u "${NOMINATIM_USER}" >/dev/null 2>&1; then +
-  useradd -d "${NOMINATIM_HOME}" -s /bin/bash -m "${NOMINATIM_USER}" +
-fi+
  
-chmod a+x "${NOMINATIM_HOME}" +  install -m 0755 -d /etc/apt/keyrings 
-mkdir -p "${PROJECT_DIR}" "$(dirname "${FLATNODE_FILE}")" +  curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc 
-chown -R "${NOMINATIM_USER}:${NOMINATIM_USER}" "${NOMINATIM_HOME}"+  chmod a+r /etc/apt/keyrings/docker.asc
  
-# ------------------------------------------------------------ +  . /etc/os-release 
-# 3) PostgreSQL vorbereiten +  echo \ 
-#    Minimal-invasive Änderungen an postgresql.conf +    "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu ${UBUNTU_CODENAME:-$VERSION_CODENAME} stable" \ 
-# ------------------------------------------------------------ +    > /etc/apt/sources.list.d/docker.list
-log "Konfiguriere PostgreSQL grob für den Import"+
  
-PGCONF="/etc/postgresql/${POSTGRES_VER}/main/postgresql.conf" +  apt-get update 
-if [[ ! -f "${PGCONF}" ]]; then +  apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
-  echo "postgresql.conf nicht gefunden: ${PGCONF}" +
-  exit 1 +
-fi+
  
-cp -n "${PGCONF}" "${PGCONF}.bak"+  systemctl enable docker || true 
 +  systemctl start docker || true
  
-TOTAL_MEM_MB="$(awk '/MemTotal/ {print int($2/1024)}' /proc/meminfo)" +  if [[ -n "${SUDO_USER:-}" ]]; then 
-CPU_CORES="$(nproc)"+    usermod -aG docker "$SUDO_USER" || true 
 +  fi 
 +}
  
-# Konservative Heuristik: +start_docker_if_needed() { 
-# shared_buffers: ~25% RAM, cap 8GB +  if docker info >/dev/null 2>&1; then 
-# maintenance_work_mem: ~15% RAM, cap 4GB +    echo "Docker läuft." 
-# autovacuum_work_mem: 512MB oder 1GB +    return 
-# work_mem: 32MB +  fi
-shared_buffers_mb=$(( TOTAL_MEM_MB / 4 )) +
-(( shared_buffers_mb > 8192 )) && shared_buffers_mb=8192 +
-(( shared_buffers_mb < 512 )) && shared_buffers_mb=512+
  
-maintenance_work_mem_mb=$(( TOTAL_MEM_MB * 15 / 100 )) +  echo "==> Docker-Daemon wird gestartet" 
-(( maintenance_work_mem_mb > 4096 )) && maintenance_work_mem_mb=4096 +  systemctl enable docker || true 
-(( maintenance_work_mem_mb < 256 )) && maintenance_work_mem_mb=256+  systemctl start docker || true
  
-autovacuum_work_mem_mb=1024 +  for _ in $(seq 1 20); do 
-(( TOTAL_MEM_MB < 8192 )) && autovacuum_work_mem_mb=512+    if docker info >/dev/null 2>&1; then 
 +      echo "Docker läuft." 
 +      return 
 +    fi 
 +    sleep 1 
 +  done
  
-work_mem_mb=32 +  echo "Fehler: Docker ist installiert, aber der Daemon läuft nicht." 
-max_wal_size_gb=2 +  exit 1 
-(( TOTAL_MEM_MB >= 32768 )) && max_wal_size_gb=4 +}
-(( TOTAL_MEM_MB >= 65536 )) && max_wal_size_gb=8+
  
-set_pgconf() { +check_pbf_arg() { 
-  local key="$1" +  if [[ -z "$PBF_PATH" ]]; then 
-  local value="$2" +    echo "Fehler: Bitte Pfad zur .osm.pbf angeben." 
-  if grep -Eq "^[#[:space:]]*${key}[[:space:]]*=" "${PGCONF}"; then +    exit 1 
-    sed -ri "s|^[#[:space:]]*(${key})[[:space:]]*=.*|\1 = ${value}|g" "${PGCONF}" +  fi 
-  else + 
-    echo "${key} = ${value}" >> "${PGCONF}"+  if [[ ! -f "$PBF_PATH" ]]; then 
 +    echo "Fehler: Datei nicht gefunden: $PBF_PATH" 
 +    exit 1
   fi   fi
 } }
  
-# Angelehnt an die Nominatim-Doku, aber auf Host-RAM angepasst +prepare_paths() { 
-set_pgconf "shared_buffers" "'${shared_buffers_mb}MB'" +  check_pbf_arg
-set_pgconf "maintenance_work_mem" "'${maintenance_work_mem_mb}MB'" +
-set_pgconf "autovacuum_work_mem" "'${autovacuum_work_mem_mb}MB'" +
-set_pgconf "work_mem" "'${work_mem_mb}MB'" +
-set_pgconf "synchronous_commit" "off" +
-set_pgconf "max_wal_size" "'${max_wal_size_gb}GB'" +
-set_pgconf "checkpoint_timeout" "'60min'" +
-set_pgconf "checkpoint_completion_target" "0.9" +
-set_pgconf "random_page_cost" "1.0" +
-set_pgconf "wal_level" "minimal" +
-set_pgconf "max_wal_senders" "0"+
  
-if (( TOTAL_MEM_MB < 8192 )); then +  PBF_ABS="$(readlink -f "$PBF_PATH")" 
-  set_pgconf "autovacuum_max_workers" "1" +  PBF_BASENAME="$(basename "$PBF_ABS")" 
-fi+  PBF_NAME="${PBF_BASENAME%.osm.pbf}"
  
-systemctl restart postgresql+  PROFILE_DIR="${WORKDIR}/${PROFILE}" 
 +  DATASET_FILE="${PROFILE_DIR}/${PBF_BASENAME}" 
 +  OSRM_BASE="${PROFILE_DIR}/${PBF_NAME}.osrm" 
 +  PROFILE_CONTAINER_NAME="${CONTAINER_NAME}-${PROFILE}"
  
-# DB-User anlegen +  mkdir -p "$PROFILE_DIR"
-log "Lege PostgreSQL-User an" +
-if ! sudo -u postgres psql -tAc "SELECT 1 FROM pg_roles WHERE rolname='${NOMINATIM_USER}'" | grep -q 1; then +
-  sudo -u postgres createuser -s "${NOMINATIM_USER}" +
-fi+
  
-if ! sudo -u postgres psql -tAc "SELECT 1 FROM pg_roles WHERE rolname='www-data'" | grep -q 1; then +  export PBF_ABS PBF_BASENAME PBF_NAME PROFILE_DIR DATASET_FILE OSRM_BASE PROFILE_CONTAINER_NAME 
-  sudo -u postgres createuser www-data +}
-fi+
  
-# ------------------------------------------------------------ +require_prepared_dataset() { 
-# 4) osm2pgsql bauen +  local missing=0 
-# ------------------------------------------------------------ +  local required=( 
-log "Baue aktuelle osm2pgsql-Version aus Git" +    "${OSRM_BASE}" 
-if [[ ! -d "${OSM2PGSQL_SRC}" ]]; then +    "${OSRM_BASE}.ramIndex" 
-  sudo -u "${NOMINATIM_USER}" git clone "${OSM2PGSQL_REPO}" "${OSM2PGSQL_SRC}" +    "${OSRM_BASE}.fileIndex" 
-else +    "${OSRM_BASE}.edges" 
-  sudo -u "${NOMINATIM_USER}" git -C "${OSM2PGSQL_SRC}" fetch --all --tags +    "${OSRM_BASE}.geometry" 
-  sudo -u "${NOMINATIM_USER}" git -C "${OSM2PGSQL_SRC}" pull --ff-only +    "${OSRM_BASE}.turn_weight_penalties" 
-fi+    "${OSRM_BASE}.turn_duration_penalties" 
 +    "${OSRM_BASE}.datasource_names" 
 +    "${OSRM_BASE}.names" 
 +    "${OSRM_BASE}.properties" 
 +    "${OSRM_BASE}.icd" 
 +  )
  
-mkdir -p "${OSM2PGSQL_BUILD}" +  for f in "${required[@]}"; do 
-chown -R "${NOMINATIM_USER}:${NOMINATIM_USER}" "${OSM2PGSQL_BUILD}"+    if [[ ! -f "$f" ]]; then 
 +      echo "Fehlt: $f" 
 +      missing=1 
 +    fi 
 +  done
  
-sudo -u "${NOMINATIM_USER}" bash -lc " +  if [[ "$missing" -ne 0 ]]; then 
-  set -Eeuo pipefail +    echo 
-  cd '${OSM2PGSQL_BUILD}' +    echo "Fehler: OSRM-Datensatz unvollständig." 
-  cmake '${OSM2PGSQL_SRC}' +    echo "Führe zuerst aus:" 
-  make -j'${CPU_CORES}' +    echo "  sudo bash osrm-manager.sh build \"$PBF_ABS\" \"$PROFILE\"" 
-" +    exit 1 
-make -C "${OSM2PGSQL_BUILD}" install +  fi 
-ldconfig+}
  
-# ------------------------------------------------------------ +remove_container_if_exists() { 
-# 5) Python venv + Nominatim installieren +  if docker ps -a --format '{{.Names}}' | grep -qx "$PROFILE_CONTAINER_NAME"; then 
-# ------------------------------------------------------------ +    echo "==> Entferne alten Container: $PROFILE_CONTAINER_NAME" 
-log "Installiere Nominatim in Virtualenv" +    docker rm -f "$PROFILE_CONTAINER_NAME" >/dev/null 2>&1 || true 
-if [[ ! -d "${VENV_DIR}" ]]; then +  fi 
-  sudo -u "${NOMINATIM_USER}" virtualenv "${VENV_DIR}" +}
-fi+
  
-sudo -u "${NOMINATIM_USER}" "${VENV_DIR}/bin/pip" install --upgrade pip wheel setuptools +copy_input_if_needed() { 
-sudo -u "${NOMINATIM_USER}" "${VENV_DIR}/bin/pip" install "psycopg[binary]" nominatim-db nominatim-api+  if [[ -f "$DATASET_FILE" ]]; then 
 +    local src_size dst_size 
 +    src_size="$(stat -c '%s' "$PBF_ABS")" 
 +    dst_size="$(stat -c '%s' "$DATASET_FILE" 2>/dev/null || echo 0)"
  
-if [[ "${INSTALL_FRONTEND}" == "1" ]]; then +    if [[ "$src_size" == "$dst_size" ]]; then 
-  sudo -u "${NOMINATIM_USER}" "${VENV_DIR}/bin/pip" install falcon uvicorn gunicorn +      echo "==> PBF bereits vorhanden: $DATASET_FILE" 
-fi+      return 
 +    fi 
 +  fi
  
-# ------------------------------------------------------------ +  echo "==> Kopiere Eingabedatei nach $PROFILE_DIR" 
-# 6) Projektverzeichnis + .env +  cp -f "$PBF_ABS" "$DATASET_FILE" 
-# ------------------------------------------------------------ +}
-log "Erstelle Projektkonfiguration" +
-mkdir -p "${PROJECT_DIR}" +
-chown -R "${NOMINATIM_USER}:${NOMINATIM_USER}" "${PROJECT_DIR}"+
  
-cat > "${PROJECT_DIR}/.env" <<EOF +cleanup_previous_dataset_files() { 
-NOMINATIM_DATABASE_DSN=pgsql:dbname=nominatim +  echo "==> Entferne alte OSRM-Dateien für $PBF_NAME in $PROFILE_DIR" 
-NOMINATIM_DATABASE_WEBUSER=www-data +  find "$PROFILE_DIR" -maxdepth 1 -type f \ 
-NOMINATIM_FLATNODE_FILE=${FLATNODE_FILE} +    \( -name "${PBF_NAME}.osrm*" -o -name "${PBF_NAME}.timestamp" \) \ 
-EOF+    -print -delete || true 
 +}
  
-chown "${NOMINATIM_USER}:${NOMINATIM_USER}" "${PROJECT_DIR}/.env" +build_dataset() { 
-chmod 640 "${PROJECT_DIR}/.env"+  echo "==> Image laden" 
 +  docker pull "$IMAGE"
  
-# ------------------------------------------------------------ +  copy_input_if_needed 
-# 7) Import ausführen +  cleanup_previous_dataset_files
-# ------------------------------------------------------------ +
-log "Starte Nominatim-Import" +
-sudo -u "${NOMINATIM_USER}" bash -lc " +
-  set -Eeuo pipefail +
-  export PATH='${VENV_DIR}/bin:/usr/local/bin:/usr/bin:/bin' +
-  cd '${PROJECT_DIR}' +
-  nominatim import --osm-file '${OSM_PBF}' 2>&1 | tee '${PROJECT_DIR}/setup.log' +
-"+
  
-# ------------------------------------------------------------ +  echo "==> osrm-extract ($PROFILE)" 
-# 8) Optional: einfacher Frontend-Service +  docker run --rm -t \ 
-# ------------------------------------------------------------ +    -v "$PROFILE_DIR:/data" \ 
-if [[ "${INSTALL_FRONTEND}" == "1" ]]; then +    "$IMAGE" \ 
-  log "Richte systemd-Service für Nominatim-Frontend ein"+    osrm-extract -p "$LUA_PROFILE" "/data/$PBF_BASENAME"
  
-  cat > /etc/systemd/system/nominatim.socket <<EOF +  echo "==> osrm-partition" 
-[Unit] +  docker run --rm -t \ 
-Description=Gunicorn socket for Nominatim+    -v "$PROFILE_DIR:/data" \ 
 +    "$IMAGE" \ 
 +    osrm-partition "/data/${PBF_NAME}.osrm"
  
-[Socket] +  echo "==> osrm-customize" 
-ListenStream=/run/nominatim.sock +  docker run --rm -t \ 
-SocketUser=www-data+    -v "$PROFILE_DIR:/data" \ 
 +    "$IMAGE" \ 
 +    osrm-customize "/data/${PBF_NAME}.osrm"
  
-[Install] +  echo "==> Build abgeschlossen" 
-WantedBy=multi-user.target +}
-EOF+
  
-  cat > /etc/systemd/system/nominatim.service <<EOF +start_container() { 
-[Unit] +  require_prepared_dataset 
-Description=Nominatim running as a gunicorn application +  remove_container_if_exists
-After=network.target +
-Requires=nominatim.socket+
  
-[Service] +  echo "==> Starte Container $PROFILE_CONTAINER_NAME auf Port $PORT" 
-Type=simple +  docker run -d \ 
-User=www-data +    --restart unless-stopped \ 
-Group=www-data +    --name "$PROFILE_CONTAINER_NAME" \ 
-WorkingDirectory=${PROJECT_DIR} +    -p "$PORT:5000" \ 
-Environment="PATH=${VENV_DIR}/bin:/usr/local/bin:/usr/bin:/bin" +    -v "$PROFILE_DIR:/data" \ 
-ExecStart=${VENV_DIR}/bin/gunicorn -b unix:/run/nominatim.sock -w 4 -k uvicorn.workers.UvicornWorker "nominatim_api.server.falcon.server:run_wsgi()" +    "$IMAGE" \ 
-ExecReload=/bin/kill -s HUP \$MAINPID +    osrm-routed --algorithm mld "/data/${PBF_NAME}.osrm" >/dev/null
-PrivateTmp=true +
-TimeoutStopSec=5 +
-KillMode=mixed+
  
-[Install] +  echo 
-WantedBy=multi-user.target +  echo "Läuft." 
-EOF+  echo "Test-URL:" 
 +  echo "  http://localhost:${PORT}/route/v1/${SERVICE_MODE}/16.3725,48.2082;16.3738,48.2100?overview=false" 
 +}
  
-  systemctl daemon-reload +stop_container() { 
-  systemctl enable nominatim.socket +  local found=0 
-  systemctl start nominatim.socket +  for p in car bike foot; do 
-  systemctl enable nominatim.service +    local name="${CONTAINER_NAME}-${p}" 
-  systemctl start nominatim.service+    if docker ps -a --format '{{.Names}}' | grep -qx "$name"; then 
 +      echo "==> Stoppe und entferne $name" 
 +      docker rm -f "$name" >/dev/null 2>&1 || true 
 +      found=1 
 +    fi 
 +  done
  
-  # Optional: Apache als Reverse Proxy +  if [[ "$found" -eq 0 ]]; then 
-  if ! dpkg -s apache2 >/dev/null 2>&1; then +    echo "Kein passender Container gefunden."
-    apt-get install -y apache2+
   fi   fi
-  a2enmod proxy_http >/dev/null +}
-  cat > /etc/apache2/conf-available/nominatim.conf <<'EOF' +
-ProxyPass /nominatim "unix:/run/nominatim.sock|http://localhost/" +
-EOF +
-  a2enconf nominatim >/dev/null +
-  systemctl restart apache2 +
-fi+
  
-# ------------------------------------------------------------ +show_status() { 
-# 9) Optional: Austria-Updates über Geofabrik initialisieren +  echo "==> Docker" 
-# ------------------------------------------------------------ +  systemctl is-active docker || true 
-if [[ "${SETUP_UPDATES}" == "1" ]]; then +  echo
-  log "Initialisiere Replikation für Austria-Updates" +
-  cat >> "${PROJECT_DIR}/.env" <<EOF+
  
-NOMINATIM_REPLICATION_URL=https://download.geofabrik.de/europe/austria-updates +  echo "==> Container" 
-NOMINATIM_REPLICATION_UPDATE_INTERVAL=86400 +  docker ps -a --filter "name=^${CONTAINER_NAME}-" --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'
-NOMINATIM_REPLICATION_RECHECK_INTERVAL=900 +
-EOF+
  
-  sudo -u "${NOMINATIM_USER}" "${VENV_DIR}/bin/pip" install --user osmium+  echo 
 +  echo "==> Datensätze" 
 +  for p in car bike foot; do 
 +    local dir="${WORKDIR}/${p}" 
 +    if [[ -d "$dir" ]]; then 
 +      echo "--- $dir" 
 +      ls -1 "$dir" | sed 's/^/  /' || true 
 +    fi 
 +  done 
 +}
  
-  sudo -u "${NOMINATIM_USER}" bash -lc " +show_logs() { 
-    set -Eeuo pipefail +  local found=0 
-    export PATH='${VENV_DIR}/bin:${HOME}/.local/bin:/usr/local/bin:/usr/bin:/bin' +  for p in car bike foot; do 
-    cd '${PROJECT_DIR}' +    local name="${CONTAINER_NAME}-${p}" 
-    nominatim replication --init +    if docker ps -a --format '{{.Names}}' | grep -qx "$name"; then 
-  " +      found=1 
-fi+      echo "==> Logs: $name" 
 +      docker logs --tail 100 "$name" 
 +      echo 
 +    fi 
 +  done
  
-# ------------------------------------------------------------ +  if [[ "$found" -eq 0 ]]; then 
-# 10) Ausgabe +    echo "Kein passender Container gefunden." 
-# ------------------------------------------------------------ +  fi 
-log "Fertig"+}
  
-cat <<EOF+print_url() { 
 +  check_profile 
 +  echo "http://localhost:${PORT}/route/v1/${SERVICE_MODE}/16.3725,48.2082;16.3738,48.2100?overview=false" 
 +}
  
-Nominatim wurde eingerichtet.+main() { 
 +  need_root
  
-Wichtige Pfade: +  case "$COMMAND" in 
-  PBF:            ${OSM_PBF} +    build) 
-  Projekt:        ${PROJECT_DIR} +      check_profile 
-  Virtualenv:     ${VENV_DIR} +      install_docker_if_missing 
-  Flatnode:       ${FLATNODE_FILE} +      start_docker_if_needed 
-  Log:            ${PROJECT_DIR}/setup.log +      prepare_paths 
- +      build_dataset 
-Prüfen: +      ;; 
-  sudo -u ${NOMINATIM_USER} bash -lc "cd ${PROJECT_DIR} && ${VENV_DIR}/bin/nominatim admin --check-database"+    start) 
 +      check_profile 
 +      install_docker_if_missing 
 +      start_docker_if_needed 
 +      prepare_paths 
 +      start_container 
 +      ;; 
 +    restart) 
 +      check_profile 
 +      install_docker_if_missing 
 +      start_docker_if_needed 
 +      prepare_paths 
 +      remove_container_if_exists 
 +      start_container 
 +      ;; 
 +    stop) 
 +      install_docker_if_missing 
 +      start_docker_if_needed 
 +      stop_container 
 +      ;; 
 +    status) 
 +      install_docker_if_missing 
 +      start_docker_if_needed 
 +      show_status 
 +      ;; 
 +    logs) 
 +      install_docker_if_missing 
 +      start_docker_if_needed 
 +      show_logs 
 +      ;; 
 +    url) 
 +      print_url 
 +      ;; 
 +    *) 
 +      usage 
 +      exit 1 
 +      ;; 
 +  esac 
 +}
  
-API lokal testen: +main "$@"
-  curl "http://127.0.0.1/nominatim/search?q=Vienna&format=jsonv2" +
- +
-Mit Apache-Proxy: +
-  curl "http://127.0.0.1/nominatim/search?q=Vienna&format=jsonv2" +
- +
-Service-Status: +
-  systemctl status nominatim.socket +
-  systemctl status nominatim.service +
- +
-EOF+
 </code> </code>
  
 <code> <code>
-sudo bash setup-osrm.sh wien.osm.pbf car+sudo bash setup-osrm.sh build /home/austria-latest.osm.pbf foot 
 +sudo bash setup-osrm.sh start /home/austria-latest.osm.pbf foot 
 +sudo bash setup-osrm.sh status 
 +sudo bash osrm-manager.sh stop 
 +sudo bash osrm-manager.sh logs
 </code> </code>
 ====Ubuntu==== ====Ubuntu====
osrm.1774749650.txt.gz · Zuletzt geändert: 2026/03/29 04:00 von jango

Seiten-Werkzeuge

Falls nicht anders bezeichnet, ist der Inhalt dieses Wikis unter der folgenden Lizenz veröffentlicht: CC Attribution-NoDerivatives 4.0 International
CC Attribution-NoDerivatives 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki