INSTALLATION

Erst die Bereitstellungsgrenzen klären, dann die aktuelle offizielle Anleitung verwenden.

Das Projekt veröffentlicht einen einzeiligen Online-Installer und Mindestwerte für die Infrastruktur. Behandeln Sie beides als Ausgangspunkt der Evaluation — nicht als Produktions- oder Sicherheitsgarantie.

DIREKTE ANTWORTMonkeyCode lässt sich auf Infrastruktur installieren, die Ihr Team betreibt.

Das README trennt Konsole und Entwicklungshost und verlinkt einen Online-Einstieg. Der gemeinsame Vorbereitungsblock unten lädt und prüft Dateien; er führt weder Einstieg noch Installer aus.

Der Einstieg enthält temporäre signierte URLs; der Paket-Hash identifiziert das geprüfte Release. Entpackte Dateien selbst prüfen und separat über eine Installation auf einem isolierten Host entscheiden. Ein verifizierter Download ist keine erfolgreiche Produktinstallation.

Vom Wegwerf-Test zur abgenommenen Bereitstellung.

Der Installer beginnt den Prozess; Ihre Abnahmeprüfungen entscheiden, ob das Ergebnis für den Team-Einsatz taugt.

  • SCHRITT 1 · Isolierte Infrastruktur vorbereiten: Konsole und Entwicklungshost zuweisen, DNS und TLS festlegen und erlaubte ein- und ausgehende Routen dokumentieren.
  • SCHRITT 2 · Paket prüfen, Installation separat entscheiden: Der gemeinsame Vorbereitungsblock liest den offiziellen Einstieg als Daten und holt frische signierte URLs. Geprüfte Version, HTTPS-Quelle, Paket-SHA-256, Archivstruktur, Manifest-Version/Architektur und Compose-SHA-256 müssen vor dem Entpacken stimmen. Unbekannte Versionen und Abweichungen stoppen. Dateien selbst lesen und erst danach auf einem Wegwerf-Host mit Snapshot über den Installer entscheiden. Paket und verification.json aufbewahren; Image-Tags und Laufzeitdownloads bleiben veränderlich.
  • SCHRITT 3 · Git- und Modellzugriff konfigurieren: begrenzte Zugangsdaten verwenden, das Ziel der Modellanfragen festlegen und prüfen, dass Geheimnisse nicht in Aufgabenausgaben oder Logs erscheinen.
  • SCHRITT 4 · Abnahmeaufgabe ausführen: ein unkritisches Repository klonen, bauen, Tests laufen lassen, das Diff prüfen und bestätigen, dass eine zweite Person das Ergebnis reproduzieren kann.
  • SCHRITT 5 · Betrieb vor dem Rollout planen: Backup, Wiederherstellung, Upgrades, Rollback, Host-Ersatz, Kapazitätswarnungen, Aufbewahrung und Incident-Verantwortung testen.

Diese Kontrollen nicht aus „Self-Hosted" ableiten.

Prüfen Sie jede Kontrolle in Ihrer tatsächlichen Version und Topologie.

  • Netzgrenzen: Modell-APIs, Git-Hosts, Paketregistries, Vorschauen, Updates und Telemetrie.
  • Identität und Geheimnisse: Administratorzugriff, Repository-Zugangsdaten, Modellschlüssel, Rotation und Sperrung.
  • Isolation: zwischen Aufgaben, zwischen Projekten sowie Host-, Dateisystem-, Prozess- und Netzisolation.
  • Betrieb: Logs, Aufbewahrung, Backups, Wiederherstellungstests, Upgrades, Rollback und Reaktion auf Schwachstellen.

Das aktuell geprüfte Paket herunterladen und verifizieren

Benötigt werden Linux x86_64 oder aarch64, Python 3, curl, CA-Zertifikate und ein beschreibbares Verzeichnis. Dieser Block lädt und prüft Dateien; er führt weder Einstieg noch Installer aus. Am 2026-10-20 wurden beide offiziellen Architekturpakete geladen und verifiziert. Produktinstallation und Laufzeitabnahme wurden nicht durchgeführt.

# Preparation only: this block NEVER runs an installer.
# Optional: use your own retained package instead of the current official entry.
# export MONKEYCODE_PACKAGE=/absolute/path/to/monkeycode-online-linux-ARCH.tgz
python3 - <<'PY'
import hashlib, json, os, pathlib, platform, re, shutil, subprocess, tarfile, tempfile
from urllib.parse import unquote, urlsplit

VERSION = "v261009"
PINS = {"amd64": "6dd439a994920e435137101a8953ec0843131110f07eb6ef48877c98d05344c4", "arm64": "ad42bf3ed93a651fb98652374ae44bd870b29288beed04e8cd28c8d2d18e1d35"}
HOST = "monkeycode-release.oss-cn-hangzhou.aliyuncs.com"
arch = {"x86_64": "amd64", "aarch64": "arm64", "arm64": "arm64"}.get(platform.machine())
if not arch:
    raise SystemExit("STOP: unsupported architecture: " + platform.machine())
work = pathlib.Path(tempfile.mkdtemp(prefix="monkeycode-review-", dir=".")).resolve()
package = work / ("monkeycode-online-linux-" + arch + ".tgz")

def fetch(url, destination):
    subprocess.run(["curl", "--proto", "=https", "--proto-redir", "=https", "--tlsv1.2",
                    "-fsSL", "--connect-timeout", "20", "--max-time", "180", url,
                    "-o", str(destination)], check=True)

try:
    retained = os.environ.get("MONKEYCODE_PACKAGE")
    if retained:
        shutil.copyfile(pathlib.Path(retained).expanduser(), package)
    else:
        entry = work / "official-entry.txt"
        fetch("https://monkeycode-ai.com/online/install", entry)
        text = entry.read_text(encoding="utf-8")
        def declaration(name):
            values = re.findall(r'^' + name + r'="([^"\r\n]+)"$', text, re.M)
            if len(values) != 1:
                raise ValueError("missing or ambiguous entry declaration: " + name)
            return values[0]
        if declaration("VERSION") != VERSION:
            raise ValueError("official release changed; review the new package before updating pins")
        url = declaration(arch.upper() + "_URL")
        parsed = urlsplit(url)
        expected = "/online-package/" + VERSION + "/" + package.name
        if (parsed.scheme != "https" or parsed.hostname != HOST or parsed.port not in (None, 443)
                or parsed.username or parsed.password or parsed.fragment or unquote(parsed.path) != expected):
            raise ValueError("unexpected package URL; review the official entry as text")
        fetch(url, package)

    actual = hashlib.sha256(package.read_bytes()).hexdigest()
    if actual != PINS[arch]:
        raise ValueError("package SHA-256 mismatch; do not extract or run it")
    root = "monkeycode-online-linux-" + arch
    required = {root + "/" + name for name in
                ("manifest.json", "docker-compose.yml", "package.env", "install.sh", "installer", ".env.example")}
    with tarfile.open(package, "r:gz") as archive:
        members = archive.getmembers()
        names = [m.name for m in members]
        if len(names) != len(set(names)) or set(names) != required | {root}:
            raise ValueError("unexpected archive layout")
        if sum(m.size for m in members) > 64 * 1024 * 1024:
            raise ValueError("unexpected unpacked size")
        for member in members:
            safe = member.isdir() if member.name == root else member.isfile() and member.name in required
            if not safe:
                raise ValueError("unsafe archive member: " + member.name)
        manifest = json.load(archive.extractfile(root + "/manifest.json"))
        if manifest.get("version") != VERSION or manifest.get("arch") != arch or manifest.get("package_type") != "online":
            raise ValueError("manifest version/architecture/type mismatch")
        compose = archive.extractfile(root + "/docker-compose.yml").read()
        if hashlib.sha256(compose).hexdigest() != manifest.get("compose_sha256"):
            raise ValueError("compose SHA-256 mismatch")
        # Package, manifest and archive checks all finish before extraction.
        (work / root).mkdir()
        for member in members:
            if member.isfile():
                target = work / member.name
                target.write_bytes(archive.extractfile(member).read())
                target.chmod(member.mode & 0o755)
    (work / "verification.json").write_text(json.dumps({"version": VERSION, "arch": arch,
        "package_sha256": actual, "manifest_commit": manifest.get("commit"),
        "compose_sha256": manifest["compose_sha256"], "installer_executed": False}, indent=2) + "\n")
    print("VERIFIED (download/archive only; NOT installed):", VERSION, arch, actual)
    print("Review directory:", work / root)
    print("Keep the .tgz and verification.json privately for this exact release.")
except Exception as error:
    raise SystemExit("STOP: " + str(error) + "\nUntrusted files retained for inspection at: " + str(work)
                     + "\nDo not run them. Retry in a new directory after resolving the cause.")
PY
Der offizielle Einstieg enthält ablaufende signierte URLs; seine Bytes ändern sich auch bei gleicher Version. Er wird strikt als Daten gelesen. Geprüfte Version und HTTPS-Paketadresse, Paket-SHA-256, Archivstruktur, Manifest-Version/Architektur und Compose-SHA-256 müssen vor dem Entpacken stimmen. Neue Versionen und Abweichungen stoppen. Prüfungen nicht umgehen und Hashes erst nach Paketprüfung ändern.
Die Hashes sind eigene Messungen, keine Herstellersignatur. Image-Tags und Laufzeitdownloads bleiben veränderlich. Bei Downloadfehlern in einem neuen Verzeichnis eine frische signierte URL holen. Versions-, Hash- und Manifestfehler müssen untersucht werden; ungeprüfte Verzeichnisse nicht weiterverwenden.

Paketdownload und Manifest von v261009 am 2026-10-20 erneut geprüft.

Eigene Messung: Paketvorbereitung für v261009

Am 2026-10-20 wurden beide Linux-Architekturpakete geladen und Paket, Archiv, Manifest und Compose erfolgreich geprüft. Kein Installer, Linux-Programm, Login, Produkttask, Restore oder Laufzeitdownload wurde ausgeführt. Dies ist eine Dateiprüfung, kein Ubuntu-Installationsergebnis oder Leistungsbenchmark.

Tatsächlicher Host: macOS arm64; die Betriebssystemversion wurde nicht erfasst. arm64 nutzte die native Architekturerkennung. Für amd64 wurde nur platform.machine auf x86_64 gesetzt, um Dateien zu laden und zu prüfen. Es gab keinen amd64-Laufzeit- oder Emulationstest.

Beobachtet am 2026-10-20, als bereinigter Bericht veröffentlicht am 2026-10-21. Die Veröffentlichung bedeutet keinen neuen Produkttest.

PaketarchitekturGemessenes PaketDownload angefordert (UTC)Vorbereitung angefordert (UTC)
amd64
monkeycode-online-linux-amd64.tgz
6377747 bytes
SHA-256 6dd439a994920e435137101a8953ec0843131110f07eb6ef48877c98d05344c4

exit 0
arm64
monkeycode-online-linux-arm64.tgz
5837528 bytes
SHA-256 ad42bf3ed93a651fb98652374ae44bd870b29288beed04e8cd28c8d2d18e1d35

exit 0

Horizontal scrollen, um alle Messwerte zu lesen.

Manifest-Angaben und geprüfte Compose-Datei

Beide Manifeste nennen Version, Pakettyp online und den folgenden Commit. Das sind Paketangaben, kein unabhängig reproduzierter Build und kein Herkunftsnachweis aus diesem Commit.

v261009 · online · commit bc4bd6099bb7874ed95db01c95777a748713cfae

  • amd64 — Build-Zeit laut Manifest:
  • arm64 — Build-Zeit laut Manifest:

Gemessener SHA-256 von docker-compose.yml (entspricht beiden Manifesten): 2d161ca641c079dcc4ba0d9cb034feb86dec77314802e99f90e6004cd2ce4621

Durchgeführte Prüfungen

  1. Offiziellen Einstieg ausschließlich als Text lesen; geprüfte Version sowie Host und Pfad der HTTPS-Paketadresse verlangen.
  2. Komprimierte Bytes und SHA-256 vor dem Öffnen messen. Genau ein Verzeichnis und sechs reguläre Dateien verlangen; Duplikate, Links und andere Einträge ablehnen.
  3. Manifest-Version, Architektur und Typ online prüfen, anschließend Compose hashen, bevor Dateien entpackt werden.
  4. Den veröffentlichten reinen Vorbereitungsablauf für beide Architekturen ausführen; Originalpaket und Prüfbeleg privat aufbewahren.

Das aufbewahrte arm64-Paket bestand außerdem die Offline-Vorbereitung (Exit 0, ohne Netzwerk oder Installer-Ausführung); die genaue Testzeit wurde nicht erfasst.

Separat bestanden 17 Tests mit inaktiven Fixtures einschließlich Ablehnungsfällen. Sie nutzten weder Netzwerk noch Herstellerausführung und sind keine 17 Produktinstallationen.

Beobachtete Grenze: Gleiche Version bedeutet nicht identischen Einstiegstext

Zwei Abrufe des offiziellen Einstiegs am selben Tag nannten v261009, hatten aber verschiedene SHA-256-Werte. Der Einstieg enthält ablaufende signierte URLs. Die Tabelle dokumentiert Textunterschiede, keine Fehler nach einer Installer-Ausführung. Paketprüfungen bleiben Pflicht.

  • · 1699 bytes · SHA-256 0e31f77e6689a51d8d4e989a7c7f4643939809ff9dc4f8715026ac08de8c3461
  • · 1699 bytes · SHA-256 74362954f4a5841190e1e12bcf3aada73fe4ba51160ae394836d28019657cc22

Was dieser Bericht nicht belegt

Die SHA-256-Werte sind Community-Messungen, keine Herstellersignaturen. Image-Tags und externe Laufzeitressourcen bleiben veränderlich. Ubuntu-Produktinstallation, Login, Task, Restore und Produktionsabnahme wurden nicht durchgeführt. Diese Website spiegelt keine Pakete und garantiert keine dauerhafte Verfügbarkeit alter Releases.

Das JSON benennt private Ausgangsbelege mit Dateiname und SHA-256. Abrufprotokolle mit signierten URLs und lokalen Pfaden bleiben privat; diese Angaben wurden aus dem öffentlichen Bericht entfernt.

Mit eigener Paketkopie ohne Installation nachrechnen

Das Paket über den obigen Vorbereitungsablauf beziehen oder eine eigene aufbewahrte Kopie verwenden. Protokoll und Prüfer herunterladen, zuerst die Python-Datei lesen und dann Beispielpfad und Architektur ersetzen. Der Prüfer liest lokale Dateien; er lädt, entpackt oder startet keine Paketinhalte.

verify-install-preparation.py vor dem Ausführen lesen. Beim amd64-Paket arm64 im Beispiel durch amd64 ersetzen.

curl --proto '=https' --tlsv1.2 -fsSLo install-preparation.json https://monkeycode.cc/evidence/install-preparation-v261009-2026-10-20.json
curl --proto '=https' --tlsv1.2 -fsSLo verify-install-preparation.py https://monkeycode.cc/evidence/verify-install-preparation.py
python3 verify-install-preparation.py install-preparation.json /path/to/monkeycode-online-linux-arm64.tgz arm64

Bei Erfolg erscheinen Paket- und Compose-Hash als JSON; Abweichungen enden mit STOP. Bei einer geänderten Quelle oder einem nicht verfügbaren alten Paket zur Prüfung stoppen, keinen neuen Hash einsetzen und keine Prüfung entfernen.

Erst prüfen; die Installation bleibt ein eigener Schritt

Im ausgegebenen Verzeichnis install.sh, package.env, docker-compose.yml, .env.example und manifest.json lesen; enthaltenen Installer und externe Downloads bewerten. Erst nach eigener Prüfung auf einem Wegwerf-Linux-Host mit Snapshot in genau dieses Verzeichnis wechseln und den folgenden Befehl bewusst ausführen. Vollständige Installation, Anmeldung, Aufgabe und Wiederherstellung wurden hier nicht validiert.

sudo ./install.sh

Ein Release aus einem selbst aufbewahrten Paket reproduzieren

Diese Website spiegelt keine historischen Pakete. Wenn genau dieses v261009-Paket aufbewahrt wurde, MONKEYCODE_PACKAGE auf dessen absoluten Pfad setzen und denselben Block ausführen. Er überspringt den veränderlichen Einstieg, prüft aber Paket, Architektur, Manifest und Compose. Ohne eigenes Paket bleibt der aktuelle offizielle Einstieg die Quelle; alte Releases sind nicht dauerhaft zugesichert. Originalpaket, verification.json und geprüfte Laufzeitabhängigkeiten privat aufbewahren.

Fehler und Wiederherstellung

Kein Installer startet automatisch. Nicht unterstützte Hardware stoppt vor dem Download; Paket-, Manifest- und Archivfehler vor dem Entpacken. Fehler lassen ein neues Prüfverzeichnis zurück. Nach Ursachenklärung in einem neuen Verzeichnis beginnen. Scheitert eine separat gestartete Installation teilweise, zuerst den Host-Snapshot wiederherstellen. Sichere Wiederholbarkeit wird nicht vorausgesetzt.

Dokumentierter Ausgangspunkt

Zwei Infrastrukturrollen, nicht ein generischer Server.

Dies sind veröffentlichte Mindestwerte. Parallele Umgebungen, Repository-Größe, Builds, Vorschauen, Modelle, Logs und Aufbewahrung können den Bedarf erhöhen.

KomponenteCPUArbeitsspeicherSpeicher
MonkeyCode-Konsole2 cores4 GB40 GB
Entwicklungshost8 cores16 GB100 GB

Vom MonkeyCode-Projekt veröffentlicht; geprüft am 05.08.2026. Reserven für Parallelität, Builds, Image-Caches, Repositorys, Logs und aufbewahrte Artefakte einplanen.

HÄUFIGE FRAGEN

Häufige Fragen, beantwortet

Welche Infrastruktur benötigt MonkeyCode?
Das aktuelle README nennt mindestens 2 CPU-Kerne, 4 GB Arbeitsspeicher und 40 GB Speicher für die Konsole sowie 8 CPU-Kerne, 16 GB Arbeitsspeicher und 100 GB Speicher für einen Entwicklungshost.
Reicht der einzeilige Installer für die Produktion?
Nein. Er ist ein Einstiegspunkt. Für den Produktivbetrieb braucht es weiterhin Entscheidungen zu Kapazität, Netzwerk, Zugangsdaten, Backups, Modellroute, Monitoring, Upgrades und Sicherheit.

EVIDENZHINWEIS

Private Cloud, On-Premises und Offline-Betrieb sind nicht gleichbedeutend. Offline-Betrieb benötigt Wege für Modelle, Pakete und Updates.

MONKEYCODE

Erst die Bereitstellungsgrenzen klären, dann die aktuelle offizielle Anleitung verwenden.

Cookie-Einstellungen

Wir verwenden Cookies nur für Analysen (GA4 + Matomo) zur Verbesserung der Doku. Keine Werbung, kein Cross-Site-Tracking.