Ein Blog

Posts mit Tag "til"

Mal wieder ein Learning von docker compose: Man kann ähnlich zu secrets in der compose-File auch configs anlegen. Das benutzt man dann so:

services:
  redis:
    image: redis:latest
    configs:
      - my_config
      - my_other_config
configs:
  my_config:
    file: ./my_config.txt
  my_other_config:
    external: true

my_config und configs ist hier ind er kurzen Syntax. Lange Syntax kann z. B. so aussehen:

services:
  redis:
    image: redis:latest
    configs:
      - source: my_config
        target: /redis_config
        uid: "103"
        gid: "103"
        mode: 0440

configs:
  my_config:
    environment: FUNNY_REDIS_CONFIG

Das holt sich die config-Werte aus der Env-Var FUNNY_REDIS_CONFIG und mountet sie im Container unter /redis_config als Datei.

Das hat mir gerade ein Deployment deutlich vereinfacht, weil ich vorher eine Datei geschrieben hab, die ich dann als :ro-Datei gemountet habe. Das ist auch immer ein bisschen Fehleranfällig mit Dateien mounten, daher ist die Lösung da ganz schön. Vorallem muss ich die Anwendung nicht anfassen und kann die Config trotzdem als Env-Var irgendwo haben,

Heute habe ich CBOR kennengelernt. Das ist quasi JSON, aber in binär. Gefunden, weil .NET 11 das jetzt in der Standardlibrary hat. Es ist auch deutlich besser standardisiert als JSON.

Mein erster Gedanke ist: Was ist mit BSON? Stellt sich heraus: BSON ist zwar binäres JSON, ist aber ausgelegt auf konkrete Verwendung in MongoDB.

git history ist neu (und experimentell) in Git. Damit versuchen sie, die üblichen Operationen zum Neuschreiben der History, die sonst immer gefummel sind, einfacher zu machen:

usage: git history fixup <commit> [--dry-run] [--update-refs=(branches|head)] [--reedit-message] [--empty=(drop|keep|abort)]
   or: git history reword <commit> [--dry-run] [--update-refs=(branches|head)]
   or: git history split <commit> [--dry-run] [--update-refs=(branches|head)] [--] [<pathspec>...]

In der nächsten Version 2.56 kommt auch noch dazu:

git history drop <commit-id>

This command will cause the identified commit to be removed from the history of the current branch, replaying all commits that were added after it. It offers an easier way of removing an offending commit. Unfortunately, it still refuses to work if the history contains merge commits, making it unusable for many (or most) repositories.

Ihr kennt ja sicher den Trick, dass wenn man sudo vergessen hat, in der Zeile danach einfach sudo !! schreiben kann, um den letzten Befehl mit Sudo auszuführen. Das !! wird dann einfach durch den vorherigen Shell-Befehl ersetzt. Stellt sich raus: Das ist Teil eines größeren Features.

Da gibt es immer einen Line-Designator, dann ggf noch einen Word-Designator und einen Modifier. Ich zitiere mal ein paar Beispiele aus dem Post:

# line designators
$ !!           # the previous line
$ !-2          # two lines back
$ !1337        # the 1337th line, as displayed by `history`
$ !ssh         # the most recent line starting with "ssh"
$ !?dandelion? # the most recent line containing "dandelion"
$ !#           # the current line, written so far
$ ^ssh^scp^    # replace first ssh with scp in previous command

# word designators
$ !:0   #  1st word --> "/path/to/script.sh"
$ !:1   #  2nd word --> "hello world"
$ !:$   # last word --> "1337"

# modifiers
$ !:$:h # strip filename (`dirname`)
$ !:1:t # strip leading path (`basename`)

Schaut nochmal bei dem Artikel vorbei, der hat noch mehr und erklärt das super.

Sehr oft sieht man curl && chmod && mv. Das geht einfacher:

# statt:
curl -o meine-binary https://example.com
chmod +x meine-binary
mv meine-binary /usr/local/bin

# Sich das chmod sparen:
curl -o meine-binary https://example.com
install meine-binary /usr/local/bin

Hier die Manpage.

Ich hab ja die Serie “HTML-Elemente und -Attribute, die kaum jemand kennt, aber doch ganz praktisch sind”. Da stoße ich meistens drauf, wenn ich mal durch die MDN-Doku scrolle. Oder einen Browser-Changelog lese.

Heute habe ich mal durch die Doku von Dockerfiles gescrollt. Hier ein paar Sachen, die man in der Praxis selten sieht, aber dennoch super sind.

Git-Repo als Build-Context

Docker-Build direkt aus einem Git-Repo:

docker build -t mein-image https://github.com/paperless-ngx/paperless-ngx.git#main

Das ist übrigens ein super Argument dafür, Multi-Stage-Dockerfiles zu machen, die ohne Verarbeitung außerhalb der Dockerfile funktionieren. Ich sehe immer noch Dockerfiles, wo einfach nur eine außerhalb des Buildprozesses kompilierte Binary reinkopiert wird. Wenn man alles in Build-Stages hat, kann man das direkt so bauen. Vielleicht jetzt nicht die super-option für die CI-Pipeline, aber um mal schnell ein Image von einem Git-Repo zu bauen, ist das super.

Dementsprechend kann man das auch in einer compose.yaml 1 als Build-Context nehmen:

services:
  paperless:
    build: https://github.com/paperless-ngx/paperless-ngx.git#main
    # ...

COPY

Wo wir gerade bei Multi-Stage-Builds waren: COPY --from kann nicht nur von anderen Stages kopieren, sondern auch aus lokalen und remote-Images. Z. B. empfiehlt composer so, wie man sich die aktuelle Binary holt:

# Specific release
COPY --from=composer/composer:2-bin /composer /usr/bin/composer

COPY kann aber auch --chmod, --chown, womit man direkt noch die Permissions anpassen kann.

Auch interessant für Multi-Stage-Build ist: COPY --link. Das ist ein etwas komplexerer Tipp, deshalb belasse ich es beim Link auf die Doku.

Mich hat aus den Socken gehauen:

# syntax=docker/dockerfile:1
FROM scratch

COPY --parents ./src/**/*.txt /parents/

# Build context:
# ./src/a.txt
# ./src/x/b.txt
# ./src/x/y/c.txt
#
# Output:
# /parents/src/a.txt
# /parents/src/x/b.txt
# /parents/src/x/y/c.txt

Globbing mit Erhaltung der Verzeichnisstruktur!

Kommen wir zu einem weiteren unterschätztem Command:

ADD

ADD kann --chmod, --chown und --link wie auch COPY.

Was aber viele nicht wissen, die Quelle kann auch ein Git-Repo oder eine HTTP-URL sein:

ADD https://example.com/archive.zip /usr/src/things/
ADD git@github.com:user/repo.git /usr/src/things/

Das Git-Repo wird dann geklont. Die URL runtergeladen.

Sicher habt ihr schonmal curl && sha256sum -c && tar -xzf gemacht oder gesehen. Ich jedenfalls schon sehr oft. ADD kann mit --unpack=true auch direkt das Zip-Archiv entpacken. Und noch besser, mit --checksum kann man auch direkt eine Checksum angeben.

ADD --unpack=true \
    --checksum=sha256:24454f830cdb571e2c4ad15481119c43b3cafd48dd869a9b2945d1036d1dc68d \
    https://example.com/archive.tar.gz /usr/src/things/

Da spart man sich direkt curl und tar zu installieren.

--unpack ist per Default übrigens true, wenn die Quelle ein lokales Archiv ist. Bei remote-Archiven ist es false.

Ist die Quelle ein Git-Repo, dann kann man mit --checksum die Commit-Id angeben.

Mal gucken, ob ich noch weitere Scahen finde. Hier gibt es noch weitere Tipps auf meinem Blog. Der mit dem Copy-From-Image war schonmal dabei.

Footnotes

  1. Das ist der neue Name für die docker-compose.yml, die auch kein version-Feld mehr hat. ↩

Mit font-variant-numeric kann man steuern, wie Zahlen gerendert werden.

Beispiele:

  • normal: 1234567890
  • ordinal: 1st 2nd 3rd
  • slashed-zero: 0 1 2 3
  • lining-nums: 1234567890
  • oldstyle-nums: 1234567890
  • proportional-nums: 1234567890
  • tabular-nums: 1234567890
  • diagonal-fractions: 1/2 3/4 5/6
  • stacked-fractions: 1/2 3/4 5/6

Code:

<ul>
	<li>normal: <span style="font-variant-numeric: normal;">1234567890</span>
	<li>ordinal: <span style="font-variant-numeric: ordinal;">1st 2nd 3rd</span>
	<li>slashed-zero: <span style="font-variant-numeric: slashed-zero;">0 1 2 3</span>
	<li>lining-nums: <span style="font-variant-numeric: lining-nums;">1234567890</span>
	<li>oldstyle-nums: <span style="font-variant-numeric: oldstyle-nums;">1234567890</span>
	<li>proportional-nums: <span style="font-variant-numeric: proportional-nums;">1234567890</span>
	<li>tabular-nums: <span style="font-variant-numeric: tabular-nums;">1234567890</span>
	<li>diagonal-fractions: <span style="font-variant-numeric: diagonal-fractions;">1/2 3/4 5/6</span>
	<li>stacked-fractions: <span style="font-variant-numeric: stacked-fractions;">1/2 3/4 5/6</span>
</ul>

tabular-nums kann man gut dafür verwenden, wenn man eine Nicht-Monospace-Font hat, aber die Zahlen an einer Stelle gleich breit haben muss. Das muss die Font natürlich unterstützen.

Mit font-variant-position kann man auch Texte in sub/sup setzen, ohne die HTML-Tags <sub>/<sup> zu verwenden.

TIL sqlite3_set_authorizer. Damit kann man einen Callback definieren, den SQLite aufruft, wenn eine Query auf eine bestimmte Datenbank/Tabelle/Spalte zugreifen möchte.

Gefunden, weil node:sqlite das jetzt kann:

import { DatabaseSync, constants } from 'node:sqlite';
const db = new DatabaseSync(':memory:');

// Set up an authorizer that denies all table creation
db.setAuthorizer((actionCode) => {
  if (actionCode === constants.SQLITE_CREATE_TABLE) {
    return constants.SQLITE_DENY;
  }
  return constants.SQLITE_OK;
});

// This will work
db.prepare('SELECT 1').get();

// This will throw an error due to authorization denial
try {
  db.exec('CREATE TABLE blocked (id INTEGER)');
} catch (err) {
  console.log('Operation blocked:', err.message);
}

cURL kann nativ S3-v4-Signaturen: AWS SigV4 requests with curl

Heute im Changelog von Bun gesehen: Node.js hat eine Histogram-API: createHistogram:

import { createHistogram } from "perf_hooks";

// Create a histogram that can record values between 1 and 1,000,000,
// maintaining 3 significant figures of precision.
const histogram = createHistogram({
  lowest: 1,
  highest: 1_000_000,
  figures: 3,
});

histogram.record(100);
histogram.record(200);
histogram.record(1000);
histogram.record(100); // Record a duplicate

console.log("Min:", histogram.min);
console.log("Max:", histogram.max);
console.log("Mean:", histogram.mean);
console.log("Standard Deviation:", histogram.stddev);
console.log("Total Count:", histogram.totalCount);
console.log("Percentile 50 (Median):", histogram.percentile(50));

Any program can be a GitHub Actions shell.

Man kann damit auch Parameter von Bash setzen. Hier global als Default:

defaults:
  run:
    shell: bash -euxo pipefail {0}

ip kann JSON ausgeben: ip -j a

Docker kann mehrere Build-Contexte. Damit kann man dann shared-Directorys haben, ohne den Build-Context auf den gemeinsamen Root zu legen.

Firefox’s html parser is written in Java and converted to C++ at build time. Hier die Java-Sourcen.

Wundert mich sehr, dass das noch niemand nach Rust portiert hat. Klar, so ein HTML-Parser is bestimmt nicht so trivial, aber wenn die Java-Implementierung sich automatisiert nach C++ übersetzen kann, wird das Problem schon relativ vereinfacht sein. Vielleicht benutzen sie in der C++-Version zu viel mutability, die man in Rust einfach nicht tun würde.

TIL: HTML-<address>-Element. War gerade dabei, zu schauen, wie man ein Impressum mit möglichst viel a11y macht.

Die Curl-CLI hat einen Parameter --libcurl <filename>[hinweis], mit dem man sich ein C-Programm ausgeben lassen kann, welches die libcurl so benutzt, dass der Request dabei heraus kommt, den man mit der Curl-CLI gemacht hat.

TIL: Das scoped-Keyword.

TIL docker system df:

# docker system df
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          5         5         1.318GB   858.6MB (65%)
Containers      5         5         3.416kB   0B (0%)
Local Volumes   5         1         442B      354B (80%)
Build Cache     0         0         0B        0B

Man kennt ja aus Docker-Multistage-Builds das COPY --from=build, um eine Datei aus einer anderen Stage zu kopieren.

Gerade habe ich beim Docker-Image von composer gesehen, dass das nicht nur beschränkt auf Images im selben Multi-stage-Build ist. Man kann dort jedes Image angeben.

Also kann man statt dem hier:

RUN php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');" \
        && php composer-setup.php --install-dir=/usr/local/bin --filename=composer \
        && php -r "unlink('composer-setup.php');" \
        && composer --version

Auch das hier machen und die Binary aus dem offiziellen composer-Image kopieren:

COPY --from=composer /usr/bin/composer /usr/bin/composer

Nachteil dabei ist, dass der Builder dafür das komplette Image runterladen muss. Ist in manchen Situationen vielleicht ganz praktisch.

HLI: Der X--Präfix für eigene HTTP-Header wurde bereits vor über 10 Jahren deprecated und wird nicht mehr empfohlen.

TIL: Dieses Pattern, wo eine Basisklasse sich selbst als Template (oder Typparameter) übergibt, hat einen Namen:

template <class T>
class Base
{
    // methods within Base can use template to access members of Derived
};
class Derived : public Base<Derived>
{
    // ...
};

Name: Curiously recurring template pattern

USB-C zu kompliziert? Man braucht 4 Stunden, um rauszufinden, welches Kabel man kaufen muss? Manchmal ist das dann irgendwie doch DisplayPort? TIL: HDMI geht auch über USB-C, war aber DOA.

TIL: Geek Code. Hier ist der Standard. Die Domain leitet heutzutage übrigens auf Google um.

-----BEGIN GEEK CODE BLOCK-----
Version: 3.1
GCS/IT/M/SS d- s-:++ a- C++ UL++ P--- L++ E---- W++N*
w++ PS+ PE- Y+ !O !K !M !V PGP+(++) !t R? !tv b e+++ z?
------END GEEK CODE BLOCK------

Heute habe ich gelernt: In docker-compose kann man sich sowas basteln, was ähnlich zu den Init-Containern aus k8s ist. Verwenden tut man dafür die depends_on-Property des Services.

Bisher ging ich davon aus, dass man mit der Property nur festlegen kann, in welcher Reihenfolge die Container gestartet werden. Das bringt einem aber nicht viel, weil die Container üblicherweise unterschiedlich lange brauchen, um zu starten. Das geht mittlerweile besser, nur die Dokumentation erwähnt es (noch) nicht:

Bei den Elementen von depends_on kann man conditions angeben. Dort kann man sagen, in welchem Zustand die Abhängigkeit sein soll, bevor der Container gestartet wird.

services:
  db:
    image: mariadb:10
    ports:
      - "3306:3306"

  init_db:
    image: mariadb:10
    command: /init-db.sh
    volumes:
      - ./init-db.sh:/init-db.sh
    env_file:
      - credentials.env
    depends_on:
      db:
        condition: service_started

  application:
    # ...
    depends_on:
      init_db:
          condition: service_completed_successfully

Durch das service_completed_successfully sagt man, dass application erst startet, wenn init_db mit einem 0-Exit-Code beendet ist. service_started ist offenbar das, was sonst auch immer der Fall war (die Doku nennt es “legacy behaviour”).

Ich hab dann noch ein bisschen Recherche betrieben und rausgefunden: Da geht noch mehr! Definiert man z. B. die Healthchecks, über die ich mal berichtet habe, kann man den Condition service_healthy angeben. Diesen Status erhält ein Container, wenn er hochgefahren und sich durch den Healthcheck als “gesund” erkannt wurde. Definiert man das in der Dockerfile oder in der docker-compose.yml, kann man damit sogar ein ./wait-for-it.sh loswerden. Da hat sich ja echt was getan bei docker-compose.

Heute lernte ich: Die SQLite-CLI kann ZIP-Dateien öffnen. Der Inhalt ist dann in Form einer virtuellen Tabelle sichtbar.

Weiter unten wird auch ein Command vorgestellt, das einem Indexe empfiehlt.

Heute lernte ich die HEALTHCHECK-Instruktion bei Dockerfiles. Damit kann ein Container einen Befehl definieren, mit dem man rausbekommen kann, ob der Container gerade “Healthy” ist. Erinnert ein bisschen an die Probes aus K8s.

HEALTHCHECK --start-period=10s --timeout=10s \
            CMD curl --fail http://localhost:80 || exit 1

Man kann das auch in einer Compose-File definieren[hinweis].

TIL es gibt ein standardisiertes Format für Test-Output: Test Anything Protocol (TAP).

HLI, dass argv[0] NULL sein kann. Hintergrund: Man kann beim Syscall execve einfach {NULL} übergeben. Das wurde jetzt für PolicyKit relevant und endete in “pwnkit”.

Dass argv[0] NULL sein kann, haben viele Programme sicherlich nicht auf dem Schirm. Gibt bestimmt auch viele andere betroffene Software.

TIL es gibt ein IAsyncDisposable, das einfach ein IDisposable ist, dessen Dispose-Methode asynchron ist.

Es gibt manchmal so Sachen, die findet man und denkt sich “wow, das ist wahrscheinlich so ein Basic-Wissen und ich lerne das erst jetzt kennen”. Es ist natürlich normal, dass man Lücken hat.

Heute wollte ich ein einfaches Problem lösen: Ich habe ein paar Dateien archiviert, die ich nicht veränderbar haben will. Da denkt man sich vielleicht: “Gut, einfach chmod -w <datei> und da hat sich das”.

Leider ist dem nicht so. Die Datei kann dann zwar nicht mehr geöffnet und verändert werden, aber sie kann weiterhin überschrieben und verschoben werden. Vorher habe ich mir ehrlich gesagt noch nie darüber Gedanken gemacht.

Dieses Problem kann man mit den Unix-Rechten offenbar nicht lösen (wenn doch, schickt mir eine Mail). Stattdessen bin ich relativ schnell auf chattr (Man-Page) gestoßen. Damit kann man, wie der Name auch vermuten lässt, Attribute von Dateien und Ordnern ändern. Der Unterschied ist, dass das ein Feature von Dateisystem ist, das das Dateisystem auch implementieren muss. Außerdem muss es als Root ausgeführt werden, unabhängig vom Besitzer der Datei.

Mein Problem konnte ich letztendlich damit lösen:

sudo chattr -R -V +i <file>

TIL ¥ ist in Japan der de-facto-Directory-Separator, hauptsächlich aus historischen Inkompatibilitäten zwischen ASCII und dem damals verwendeten Encoding in Japan, SHIFT_JIS. Obwohl sie heute UTF-8 nutzen, verwenden sie es weiterhin. Die Geschichten in den Kommentaren sind sehr interessant!

Ich habe heute gelernt, dass man bei npm init einen weiteren Parameter übergeben kann, einen Initializer. Das ist ein Wrapper, der solche Dinge wie create-react-app automatisch ausführt. Ohne den Parameter nennt man das anscheinend “legacy init”.

Beispiel: Für ein ESM-kompatibles npm-Projekt macht man dann npm init esm (es wird create-esm ausgeführt).

TIL: restrict in C hat kein Äquivalentes Konzept in C++. Ist vielleicht auch ganz gut so. Sowas sollte eher vom Compiler enforced werden.

TIL: Oracle hat seinen Ursprung in der CIA[hinweis]. Die CIA brauchte eine dicke Datenbank. Das interne Projekt mit dem Codenamen hieß Oracle, was später zu der Firma wurde.

Cooler Hack: Git als NoSql-Datenbank.

Dabei habe ich auch gelernt, dass man sich den Inhalt einer Datei in einem bestimmten Branch mit git show <branch>:<dateipfad> anzeigen lassen kann.