De vi zomer-opfris-cursus loopt nog steeds, en deze week gaan we kijken naar het werken met meerdere bestanden tegelijk.

De vi zomer-opfris-cursus gaat door, en dit keer kijken we naar het gebruik van de verschillende “yank” en “delete” registers in vi.

De vi zomer-opfris-cursus gaat door, en dit keer kijken we naar het efficiënt bewegen van je cursor in (grote) documenten.

Wanneer je tekst-bestanden wilt bewerken op een Unix of Linux systeem heb je een grote keuze aan tools om het werk gedaan te krijgen. Van de oude vertrouwde line-editor ed tot moderne grafische geheugenvreters als VSCode.

Er is daarentegen maar één editor die je op 99.9% van de systemen bijna gegarandeerd kujnt tegekomen, en dat is tegelijk één van de meest veelzijdige en uitbreidbare editors ooit: vi en/of vim.

Vroeger, toen alles nog beter anders was, wisselden we op het schoolplein diskettes met elkaar uit om shareware spellen met elkaar te delen. Een beetje spel was zo vijf tot tien 1.44MB diskettes, en kopiëren duurde dan ook wel eventjes.

De techniek ging vooruit, en we stapten over op CD-ROMS, ZIP-drives, USB-sticks, en het grote boze Internet.

Tegenwoordig is een Operating Systeem meerdere gigabytes groot, en dan heb je de applicaties en spelletjes die je wilt nog niet eens geïnstalleerd.

Iedereen kent waarschijnlijk robots.txt wel, instructies voor webcrawlers over wat ze met jouw website mogen doen. Minder mensen kennen waarschijnlijk humans.txt, een soortgelijk bestand, maar voor mensen, om duidelijk te maken wie er aan een site hebben meegewerkt.

Het debuggen van applicaties die draaien op Kubernetes kan heel makkelijk zijn, mits je in je containers zelf daar de goede tools voor hebt. Nu gaat er natuurlijk niks boven goede instrumentatie met goede traces, logs, en metrics, maar helaas zijn die niet altijd beschikbaar. Echte debugging tools in je container images (denk aan bijvoorbeeld gdb en vrienden) is vaak niet aan te raden, omdat we vanuit een beveiligings-standpunt dat soort tools niet in onze images willen hebben zitten.

Het wordt pas echt leuk als je container images zelfs geen shell erin hebben zitten. Denk hierbij aan de groeiende hoeveelheid “Distroless”-images, maar ook aan images met slechts een enkele, statisch-gelinkte, binary, zoals veel Golang applicaties.

In meer dan 25 jaar professionele IT ervaring heeft Wander een heleboel verschillende organisaties en teams van dichtbij gezien. In die tijd heeft hij een aantal gewoontes, van zowel individuen als teams, gezien die bijdragen aan het goed functioneren, en daarmee aan succesvolle projecten.

Het is alweer een tijdje geleden dat we hier voor het laatst naar een extensie voor de Gnome Desktop hebben gekeken. Gelukkig zitten de extensie ontwikkelaars niet stil, en hebben we weer wat moois om je te laten zien.

Dit keer gaat het om de “Dynamic Music Pill” extensie. Een kleine widget die in je top-bar of je dock kan leven, en laat zien welke muziek je momenteel speelt. Dat klinkt niet super interessant, en Gnome heeft al een standaard persistent notification die hetzelfde doet, maar deze extensie is uitgebreid te beïnvloeden qua uiterlijk, kan songteksten laten zien, en is gewoon 250% meer “Bling” dan de standaard.

Wander heeft weer eens last van “Oude man schreeuwt tegen wolken”. Dit keer uit hij zijn frustratie over hoe mensen AI chatbots zoals ChatGPT en Claude inzetten bij hun dagelijkse werkzaamheden. En hier is hij niet alleen in, onderzoek van MIT geeft hem gelijk.

Een tijdje geleden heeft Wander een collega geholpen om een raar probleem met OpenShift nodes en IPv6 op te lossen. Het bleek niet aan OpenShift te liggen, maar een kleine instelling op één van de VLANs die gebruikt werd in één datacenter.

Moderne hardware biedt een plethora aan sensor informatie aan richting het besturingssysteem dat er bovenop draait. Één van die soorten informatie heeft te maken met de temperatuur van de verschillende onderdelen. Dit is handig, want hierdoor kan het OS reageren op stijgende (of dalende) temperaturen door bijvoorbeeld de workload aan te passen, of door ventilatoren harder te laten werken. Een gedeelte van deze taken wordt natuurlijk ook door de systeem firmware (BIOS) gedaan, maar dan kan het OS dir gedrag vaak ook weer beïnvloeden.

In Bash kun je een hoop nuttige, maar soms ook rare, dingen doen met variabelen. Één van die dingen is transformatie terwijl een variabele uitgepakt wordt tijdens de “Expansion” fase. Zo kun je indirectie toepassen, default of alternatieve waardes gebruiken, substring vervangingen, en meer.

ArgoCD Applications hebben een optionele Finalizer die gezet kan worden waardoor ArgoCD alle resources van een Application verwijderd als de Application zelf wordt verwijderd. Standaard wordt deze niet gezet, maar…

Wanneer een Application wordt aangemaakt vanuit een ApplicationSet wordt deze Finalizer standaard wel gezet.

Wanneer je in een bash script meerder processen naast elkaar wilt draaien dan kun je er een paar nar de achtergrond sturen. Wanneer je communicatie tussen die processen nodig hebt kun je extra File Descriptors aanmaken, en slimme dingen dingen doen met input en output redirectie, named pipes, sockets, en meer.

Sinds Bash 4.0 in 2010 kun je dat ook simpeler doen. Op de achtergrond blijft het toveren met file descriptors en redirectie, maar in het script zelf leest (en schrijft) het allemaal wat makkelijker dankzij het coproc commando.

Iedereen die regelmatig met Kubernetes werkt is blootgesteld aan kubectl (of oc als je OpenShift gebruikt). Dit commando kent een hoop trucjes die je leven makkelijker kunnen maken, maar helaas kent niet iedereen die trucjes.

In deze video laat Wander vijf handige dingen zien waarmee je dagelijks tijd kunt besparen, tijd die je vervolgens kunt gebruiken om meer Sudo Friday te kijken.

Als je voor het eerst een Red Hat examen, zoals de RHCSA, of een ander hands-on examen gaat maken dan kunnen de druk en de stress hoog oplopen. Een onbekende omgeving, een berg aan opgaves, en een tikkende klok maken je leven niet makkelijker.

Wanneer je documentatie maakt voor je eindgebruikers, vooral wanneer er GUI werk in zit, kan het handig zijn om acties voor te doen in een filmpje. Nu zijn filmpjes vaak groot, en het toevoegen van “controls” aan HTML <video> elementen hoeft ook niet altijd even leuk te zijn.

Nu hadden we toen het internet nog jong en onschuldig was veel “animated gifjes”, bewegende plaatjes zonder geluid. Het .gif formaat bestaat natuurlijk nog steeds, maar resolutie, kleurdiepte, frame-rate, en vooral ook bestandsgrootte zijn niet meer van deze tijd. Gelukkig hebben we tegenwoordig AVIF, plaatjes die gebruiken maken van het moderne AV1 video compressie algoritme. AVIF afbeeldingen zijn klein (zelfs als ze lossless in plaats van lossy worden opgeslagen), en ondersteunen, net zoals GIF, animatie en transparantie.

Op een standaard, leeg, Kubernetes cluster is netwerk verkeer tussen Pods, zelfs in verschillende Namespaces, niet gefilterd. Dit betekent dat Pods uit één Namespace gewoon mogen babbelen met Pods in een andere Namespace. Nu is dit soms gewenst gedrag, maar in de meeste gevallen wordt er toch net dat beetje meer aan netwerk beveiliging gevraagd.

Dit kun je oplossen met NetworkPolicies, stukjes configuratie die bepalen (per Pod) vanaf welke bronnen inkomend netwerk verkeer wordt toegestaan, en tegen welke doelen uitgaand netwerk verkeer wordt toegestaan.

Zoals elk jaar hebben we ook dit jaar weer een leuke Paas Puzzel voor jullie.

Dit jaar is de opdracht simpel: In deze video zitten een aantal paaseieren verstopt. Vind ze allemaal, zet de letters in de juiste volgorde, en stuur je antwoord in.

Je hebt tot en met Donderdag 9 April 2026 om je antwoord in te sturen, in sturen kan via ons antwoord formulier: https://forms.cloud.microsoft/e/wRJWAy7kYW

Alvast veel succes!

Ze zeiden dat het niet kon. Dat er niet genoeg CPU was, niet genoeg geheugen, niet genoeg I/O.

Maar ze hadden het allemaal fout!

Na maanden zwoegen over een assembler, wat vieze hacks, en een heleboel optimalisatie is het dan gelukt: HCS heeft Kubernetes geport naar de Commodore 64!

Nog lang niet alle resource types worden ondersteund, meer dan 2 à 3 containers draaien (of een grotere container) is nog wat moeizaam, maar het werkt!

Nu we de eerste hordes hebben genomen staan de volgende items op onze roadmap voor de eerste release:

• Ram Expansion Unit (REU) support → Dit zou ervoor moeten zorgen dat we meer en grotere containers kunnen draaien
• Persistent Storage (Storageclasses, PVs, PVCs). Heeft waarschijnlijk IDE64 support nodig, 1541 en 1571 zijn te langzaam

Het standaard gedrag van de meeste StorageClasses op Kubernetes is het verwijderen van een onderliggend PersistentVolume (PV) wanneer de bijbehorende PersistentVolumeClaim (PVC) wordt verwijderd.

Nu is dit in de meeste gevallen gewenst gedrag, waarom zouden we oude rotzooi bewaren, maar in sommige gevallen is dit juist precies niet wat je wilt.

Één van de “hippe” design-patronen voor applicaties van de afgelopen paar jaar is de Microservice. Het uit elkaar trekken van je applicatie in meerdere, kleine, services, die via het netwerk en een afgesproken (simpele) API met elkaar praten. Hier horen dan ook principes bij als “loosely-coupled” die zeggen dat het falen van component A niet tot het falen van component B mag leiden (maar component B mag best zeggen dat iets nu niet kan).

De meeste Kubernetes gebruikers weten wel hoe ze Environment Variabelen op een container moeten definiëren. Wat niet iedereen weet is dat je naast het hardcoden van deze variabelen ze ook op meerdere manieren uit ConfigMaps en Secrets kunt alten komen, of zelfs uit specifieke velden van je Pod zelf.

Wanneer je een container start met podman zal de tijzone binnen de container standaard op UTC gezet worden, standaard universele tijd. Wanneer je hosts in meerdere tijdzones hebt draaien is dit erg fijn, want de logtijden etc. van de verschillende containers zullen allemaal met elkaar gelijk lopen.

Sommige mensen vinden dit daarentegen minder fijn, omdat ze dan in hun hoof moeten gaan omrekenen naar de lokale tijd wanneer ze de logs aan het interpreteren zijn.

Tegenwoordig is “Kubernetes” het standaard antwoord op de vraag “Hoe moeten we dit draaien?”.

Wander is het hier niet mee eens. Hoe leuk hij Kubernetes ook vind, het zou niet per definitie het goede antwoord moeten zijn. Kubernetes voegt een laag aan beheer en complexiteit toe die in veel gevallen vermeden kan worden, of in ieder geval zwaar gereduceerd tot een meer Linux-native oplossing.

Als consultant kijkt Wander graag mee over de schouder (of via screenshare) naar de terminals van andere mensen. Soms leert hij een nieuw trucje, soms ziet hij iets moois, maar soms ziet hij ook dingen waar de haren op zijn rug van overeind gaan staan.

Sinds de eerste (beta) release van Red Hat Linux in 1994 heeft de familieboom van Red Hat (afgeleide) distributies wat flinke kronkels en vertakkingen gemaakt. Zoveel zelfs dat sommige mensen door de takken de boom niet meer zien.

Bijna elk Linux systeem heeft een vorm van “swap”, maar wat is dat nou precies? En wat doet dat voor me? Heb ik het echt nodig? Kan ik het eten?

Op dit kanaal hebben we in het verleden al eens gekeken naar Kyverno, een handige manier om beleid af te dwingen op Kubernetes objecten, en externe certificaten voor OpenShift Routes.

Met de release van Kyverno 1.15 een aantal maanden geleden is er een aantal nieuwe policy types beschikbaar gekomen voor Kyverno die gebruiken maken van Common Expression Lanaguage (CEL), dezelfde taal die ook door Kubernetes zelf gebruikt wordt op objecten als validatingadmissionpolicies, maar ook door dingen als Tekton Webhook Triggers.

CEL regels evalueren meestal sneller, en met minder resource gebruik dan traditionele Kyverno regels.

Op het gemiddelde Linux werkstation heb je een ruime keuze aan terminal emulators. Sommige, zoals XTerm, gaan al langer mee dan veel van onze kijkers, andere, zoals ptyxis, bieden speciale integraties met je desktop omgeving of containers.

Een andere categorie is degene waar de emulators puur voor de snelheid gaan. Zo snel mogelijk renderen, zoveel mogelijk tekst per seconde over het scherm heen pompen.

Één van de emulators uit de laatste categorie is kitty. Maar snelheid alleen is niet genoeg, kitty biedt ook een grote hoeveelheid aan configureerbaarheid en extensies. Zo kun je graphics rechtstreeks in je terminal bekijken, zijn er remote-control mogelijkheden, en zit er een tab/window/pane systeem in dat doet denken aan tmux.

Tegenwoordig kun je je “AI” Large Language Models met spcifiekere kennis enn vaardigheden verrijken door ze te koppelen aan Model COntext Protocol (MCP) servers. Dit zijn programma’s die via een JSON API je LLMs met extra informatie of vaardigheden kunnen uitbreiden. Uit het Red Hat Lightspeed project is nu de linux-mcp-server voortgekomen, een MCP die (basis) informatie kan geven over je lokale systeem, en systemen waar je met SSH toegang tot hebt.

Zoals elk jaar had HCS Company ook dit jaar weer een uitdagende puzzel voor jullie rond de feestdagen. Velen van jullie hebben hem geprobeerd op te lossen, en een aantal van jullie is dat nog gelukt ook.

Mocht je zijn vastgelopen, maar kun je de puzzel toch niet loslaten? Met het linkje hieronder kun je de puzzel nog steeds maken, de inzendperiode is helaas wel voorbij.

Zoek je wat hints? Bekijk dan deze video om te zien hoe Wander hem oplost. N.B. Dit is Één van de mogelijke manieren om bij de oplossing te komen, heb jij het anders gedaan maar kwam je op hetzelfde resultaat dan had je hem gewoon goed.

De puzzel zelf kun je hier vinden.

In het verleden hebben we hier gekeken naar de OpenShift Web Terminal Operator toen die nog in Technology Preview zat. Nu, wat jaren later, is die operator al lang en breed normaal beschikbaar, maar ook veel meer aanpasbaar geworden.

Zo kun je tegenwoordig persistent storage toevoegen, je eigen timeouts aangeven, en je shell kiezen.

Iets dat ook aanpasbaar is is het image dat gebruikt wordt om je terminals in te draaien, maar de documentatie rondom waar dat image aan moet voldoen is nogal summier…

Wat is er nou fijner dan in je vrije tijd, die jullie hopelijk allemaal hebben tijdens de feestdagen, lekker samen met je kinderen (of innerlijke kind) te leren programmeren?

Nu is het alleen zo dat met traditionele/volwassen programmeertalen het flink wat tijd en kennis kost om iets te maken dat er voor je kinderen ook gelikt uitziet. Graphics en geluid hebben vaak nog extra kennis nodig, en een hoop extra code.

Gelukkig zijn er ook tools zoals Scratch, leuke interactieve programmeer omgevingen die geschikt zijn voor kinderen. Het meeste zware werk gebeurt met Sleur-en-Pleur™, en het toetsenbord blijft over om je spelletjes mee te bedienen, of om de waardes in vakjes tijdens het programmeren mee in te vullen.

Zoals elk jaar heeft HCS Company ook dit jaar weer een uitdagende puzzel voor jullie rond de feestdagen.

Dit keer is het een Capture-the-Tree uitdaging: De Kerstman heeft op zijn systeem een raar bestand gevonden (schijfplaatje.iso), en daarmee zou je de oplossing van dit jaar moeten kunnen vinden. Ga jij de uitdaging aan?

De puzzel zelf kun je hier vinden.

Mocht je alleen op zoek zijn naar het antwoordformulier dan staat die hier

Op moderne Linux machines kun je bijna alles van het kernel en userspace inspecteren met eBPF, de Extended Berkeley Packet Filter. Oorspronkelijk bedoelt voor firewalls is dat nu uitgegroeid tot een framework voor volledige systeem tracing.

Voor de fossielen onder ons: Denk SystemTap, maar dan meer gestandaardiseerd, en zonder rare kernel modules.

Één van de makkelijkste manieren om met eBPF te werken op een Linux systeem is met het tooltje bpftrace. bpftrace laat je programma’s schrijven met een syntax die wat lijkt op awk, en die je rechtstreeks vanaf de commandline kunt laten uitvoeren. Dit is niet de enige, of de beste, methode, maar wel een heel erg toegankelijke.

In het verleden hebben wij op dit kanaal al naar OpenShift User Namespaces gekeken, toen ze in versie 4.17 voor het eerst als Technology Preview (TP) verschenen. Toen moest je als admin nog door wat hoepeltjes heenspringen: Een FeatureGate activeren waardoor je cluster niet meer kon updaten, de container engine omzetten naar crun, en wat ander kunst en vliegwerk.

Nu, met OpenShift 4.20, is de feature General Availability (GA) geworden, en kan iedereen het gebruiken. Dit is goed, en mooi, en wat meer superlatieven, maar Wander heeft er nog steeds wat commentaar op.

Wanneer het gaat om het “branden” van iets als een .iso bestand naar een USB stick dan hebben we tegenwoordig keuze te over. We hebben meerdere grafische tooltjes, leuke TUI dingen voor in de terminal, maar natuurlijk ook de OG: dd.

De eerste twee soorten tooltjes zijn vaak erg specifiek (brand een iso naar een USB), maar met dd kun je ook dingen doen als uppercase/lowercase wisselen, “sparse” bestanden maken, of zelfs alle even en oneven bytes switchen.

Wanneer je op een Linux commandline een proces op de achtergrond wilt draaien gebruik je traditioneel “Job Control”, dus magie met &, fg, bg, jobs, etc. Wanneer je dan ook resource gebruik wilt beperken ga je dit doen in combinatie met commando’s als nice en vrienden.

Nu is dit voor veel dingen meer dan afdoende, en hoef je niet meer verder te kijken. Wil je daarentegen meer controle over resource gebruik, automagisch herstarten na een failure, of andere, moderne, gemakken, dan zul je naar andere tooling moeten grijpen.

Vroegâh, toen alles nog beter anders was, had een proces of gebruikers-rechten, en mocht bijna niks, of root-rechten, en mocht bijna alles. Tools als arping, die zelf netwerk pakketjes willen maken buiten het kernel om, moesten toen dan ook op disk het SETUID bitje hebben, zodat ze bij het uitvoeren als root zouden draaien.

Al terug in 1999 is hier verandering in gekomen, toen processen “Capabilities” konden krijgen met het 2.2 kernel. Sinds 2008 kunnen deze capabilities ook aan executables op disk gekoppeld worden, zodat er fijnmazig rechten uitgedeeld kunnen worden aan tools die dat nodig hebben.

In Fedoraland komt Sinterklaas niet één, maar twee keer per jaar langs. Vorige week was het weer feest, en nu mogen wij met alweer de 43e versie van Fedora Linux spelen.

Fedora 43 is een redelijk rustige release, met geen grote wijzigingen of verrassingen. Er zijn wat versie bumps (Gnome 49, Python 3.14, etc.), en bij nieuwe installaties wordt de /boot partitie standaard wat groter gemaakt (van 1GiB naar 2GiB).

Markdown is de facto standaard voor het formatteren van documentatie bestanden bij je broncode. Ook wordt het op veel andere plaatsen gebruikt waar tekst documenten opmaak nodig hebben, terwijl je ze wel leesbaar wilt houden. ook gebruiken sommige applicaties, zoals LogSeq, het als hun bestandsformaat voor hun eigen opslag.

Omdat Markdown gemaakt is om ook als tekst leesbaar en mooi te zijn is er niks dat je tegenhoudt om met “gewone” tools als cat en vim je Markdown te lezen, maar het kan natuurlijk altijd mooier.

Voor in de GUI zijn er een heleboel editors en readers om je Markdown mooi te maken, maar ook in de terminal kan dit. Zo zal vim standaard syntax-highlighting toepassen. Maar het kan natuurlijk altijd mooier…

Als IT Professionals brengen we vaak lange dagen door achter onze computers. En terwijl veel mensen wel wat handigheidjes kennen in hun favoriete text editor, gebruiken veel mensen maar weinig van de handigheidjes en shortcuts die ze op de commandline bij het invoeren van commando’s kunnen gebruiken.

Dan hebben we het niet over het judicieel gebruik van de geschiedenis en tab-completion, daar hebben we hier in het verleden al naar gekeken, maar naar de editing faciliteiten die je ook hebt bij het intypen van je commandlines.

In een moderne IT omgeving is het heel erg makkelijk om oplossingen te bedenken en te maken die erg complex zijn, terwijl hetzelfde probleem over het algemeen ook met minder complexiteit opgelost kan worden. Dit zegt niks over de effectiviteit van de oplossing, maar wel over de onderhoudbaarheid.

Complexe oplossing zijn vaak foutgevoeliger, en moeilijker te onderhouden dan elegantere, minder complexe, oplossingen.

In Bash scripts is het mogelijk om bepaalde signalen af te vangen voordat ze het huidige draaiende proces raken. Het script kan dan kiezen om iets anders met zo een signaal te doen.

Netwerken scannen hebben we hier al vaker bekeken, bijvoorbeeld met nmap. Maar dit is wel altijd een commandline bezigheid geweest, met veel opties, vlaggetjes, en een steile leercurve.

Dat moet ook makkelijker kunnen…

De meeste grote muziek streamingsdiensten hebben een officiële desktop client voor Linux, of in ieder geval een web-based player met een Electron client eromheen die moet doen also hij een volwassen client is.

Het nadeel aan deze clients is dat ze meestal veel resources gebruiken, en/of niet mooi in de rest van je desktop passen of integreren.

Bijna iedereen heeft wel eens set -euo pipefail bovenaan een shell script zien staan.

Maar wat betekent dat nou precies? En waarom gebruiken we dat? Waar vind ik daar de documentatie van? Wat is de betekenis van het leven?

In het verleden hebben we op dit kanaal al vaker gekeken naar het configureren van metrics, voornamelijk op Kubernetes platformen. In die gevallen was het vaak een eenvoudige setup met behulp van bijvoorbeeld een Operator, waardoor je met een paar klikken klaar was.

Nu is het tegenwoordig bijna net zo makkelijk om goede, robuuste, metrics te verzamelen van je “klassieke” systemen. De RHEL System Roles Ansible collection heeft een een role genaamd metrics die gebruikt kan worden om Performance Co-Pilot (PCP) te configureren om metrics te verzamelen, maar ook om een Valkey (of Redis op oudere systemen) te configureren om metrics van meerdere hosts te verzamelen, en een Grafana (inclusief dashboards en datasources) op te zetten.

Als je een digitale foto (of ander plaatje) van lage resolutie of kwaliteit hebt, en je wilt die toch kunnen gebruiken ergens waar je een hogere resolutie nodig hebt, dan kun je grijpen naar wat standaard beeldbewerkings software zoals Gimp. Een beetje “scale”, een beetje “sharpen”, en je hebt waarschijnlijk al redelijk snel iets dat je met trots “mèh” mag noemen, misschien zelfs wel “mid”.

Gelukkig zijn er applicaties die niks anders als doen hebben dan het vergroten/verbeteren van plaatjes. Sommigen daarvan zullen niet veel betere resultaten halen dan wat je zelf met generieke bewerking software kon doen, maar anderen gebruiken wat modernere (en CPU/GPU intensievere) algoritmes om een beter resultaat te behalen.

Op zich lijkt YAML niet zo raar. Whitespace is misschien belangrijk, en het inline gebruik van JSON kan er soms wat vies uit zien, maar over het algemeen lijkt het toch redelijk eenvoudig.

Totdat het niet meer zo eenvoudig blijkt te zijn. Waardes die spontaan lijken te veranderen, landen die blijkbaar niet mogen bestaan, port-mappings die veranderen in (schijnbaar) willekeurige getallen…

Wanneer je op OpenShift een cluster-brede (AllNamespaces) operator installeerd wordt er door de Operator Lifecycle Manager (OLM) een kopie van de Cluster Service Version (CSV) in elke namespace op je cluster neergezet. Deze kopie is hier voor de informatie van je eindgebruikers, zodat ze kunnen kijken welke operators beschikbaar zijn in hun namespaces.

Dit klinkt natuurlijk heel nobel en eervol, maar wanneer je honderden, of zelfs duizenden, namespaces hebt op een cluster kost dit behoorlijk wat resources (CPU, Geheugen) voor OLM zelf om bij elke reconcile deze CSVs bij te werken. Ook is het een grote aanslag op de performance van Etcd en de Kubernetes APIServer, want die moeten al die aanpassingen op al die objecten verwerken.

Wanneer we enge dingen gaan op virtuele machine maken we vaak op Hypervisor niveau een “Snapshot”, zodat we in het geval dat dingen een ventilator geraakt hebben we makkelijk een stapje terug kunnen doen om het nogmaals te proberen.

Wanneer je op Bare-Metal draait, of een virtualisatie omgeving zonder snapshot mogelijkheid, wordt dit een stukje moeilijker.

Je kunt LVM of Stratis snapshots maken (als je die gebruikt natuurlijk), maar de snapshots van verschillende volumes synchroniseren, je bootloader entries en bijbehorende kernels ook meenemen, als ook het terugzetten van die snapshots kan wat ingewikkelder zijn.

Gelukkig is daar een tooltje voor Snapshot manager (Snapm), die dit alles voor je kan automatiseren.

Wanneer je RHEL systemen wilt upgrade tussen major versies, bijvoorbeeld van RHEL9 naar RHEL10, dan is een schone installatie altijd de voorkeursmethode. Maar soms heb je systemen, of processen, waarbij dat niet kan. In die gevallen zul je een in-place upgrade moeten uitvoeren.

Op RHEL-familie systemen kan dat met het leapp tooltje. Deze weet precies welke aanpassingen er gemaakt moeten worden aan een systeem om de upgrade succesvol uit te voeren.

In het verleden hebben we op dit kanaal al gekeken naar de verschillende soorten “Services” die je op Kubernetes kunt aanmaken, maar eentje zijn we toen overgeslagen: “ExternalName”.

Met dit soort services kun je een Service op Kubernetes laten doorverwijzen (via DNS CNAME) naar een externe service.

Het is al een lange tijd mogelijk om uitgaand netwerk verkeer vanuit een namespace op OpenShift vanaf een ander IP adres te laten komen dan het andere cluster verkeer. Vroeger, met OpenShiftSDN, was dit puur op namespace basis, als het verkeer kwam vanaf een apart IP adres, of niet. IP adressen konden ook niet door meer dan één namespace gebruikt worden.

Tegenwoordig, met OVN Kubernetes als SDN, kan dit een stuk fijnmaziger. Egress IPs kunnen geselecteerd worden door labels op zowel de namespace als de workload zelf, waardoor het mogelijk wordt om IP adressen te delen tussen namespaces, en zelf meerdere IP adressen te gebruiken voor verschillende workloads in een namespace.

Het klinkt in deze tijd van Observability misschien raar, maar soms is het gewenst om minder te monitoren.

Wanneer je clusters groeien, en de CPU, geheugen, en opslag druk van je monitoring stack blijft groeien, kan het soms gewenst zijn om minder verschillende metrics te verzamelen om die druk lager te houden. In die gevallen kun je op een OpenShift cluster terugvallen op het minimal CollectionProfile.

Wanneer het gaat over TLS certificaten toevoegen aan Ingress objecten op OpenShift dan is er altijd een groot verschil geweest tussen OpenShift Routes en andere vormen van Ingress: Bij OpenShift Routes moesten de certificaten ge-embed in het Route objectr, terwijl je bij andere Ingress objecten naar een certificaat in een Secret kon wijzen.

Deze situatie is, zoals zoveel OpenShift dingen, historisch gegroeid, maar met een goede reden: De OpenShift Engineers waren nogal huiverig voor het geven van algemene Secret lees-rechten aan de OpenShift Router. Met de release van OpenShift 4.19 is hier verandering ingekomen, je mag nu in een Route naar een Secret wijzen met je certificaat info. Wel moet je expliciet een Role en een Rolebinding aanmaken die de OpenShift Router expliciete leesrechten geeft op je Secret.

Dit maakt het werken met tools als cert-manager en External Secrets Operator een stuk makkelijker, deze hebben nu geen extra tooling meer nodig om de opgehaalde of gegenereerde certificaten in de Route te embedden.

Soms zijn er tooltjes die een fractie van de functionaliteit hebben van een een grotere tool, maar juist daarom veel beter geschikt zijn voor bepaalde taken.

Deze week bekijkt Wander met jullie één van dit soort tools: Gradia

Sinds kort is het mogelijk om de volledige Red Hat Knowledge Base en Documentation Portal self-hosted en airgapped te draaien vanuit een container. Dit maakt het mogelijk om ook in een volledig disconnected omgeving toegang te hebben tot je product documentatie, CVE en Errata databases, support artikelen, en meer.

Om dit op te zetten heb je niet meer nodig dan een Red Hat account met een actieve Satellite subscriptie, een machine die wel internet heeft om de images op te halen, en een machine met minimaal 30GiB vrije diskruimte om de Red Hat Offline Knowledge Portal (RHOKP) op te draaien.

Deze week neemt Wander jullie mee terug in de tijd naar het begin van de jaren tachtig. En wat is er nou beter om te tijdreizen dan revisie beheer software? Specifieker, de grootvader van alle revisie beheer software: Revision Control System (RCS).

Voor sommigen van jullie zal dit een herinnering zijn aan beter tijden, voor anderen een hoofdstuk van hun leven dat ze gesloten hebben en hopen nooit meer te hoeven openen. Voor de chronologisch minder bevoordeelde mensen is het misschien dat irritante commando dat je bestanden liet verdwijnen op RHEL4 en ouder als je per ongeluk ci typte in plaats van vi.

Vorige week is tijdens de Red hat Summit Red hat Enterprise Linux 10 (RHEL10) uitgebracht. Ook al zitten er wat leuke nieuwe dingen in deze versie, toch wordt Wander heerlijk blij van hoe saai de release is. Het is een evolutie, geen revolutie, voor het OS.

Sommige van de “nieuwe” features waren ook al (gedeeltelijk) beschikbaar op RHEL9, zoals RHEL Image Mode, waarbij je (virtuele) machines uitrolt en update vanuit container images. Andere dingen draaien meer in de cloud bij Red Hat, zoals alle nieuwe Insights features.

In deze video laat Wander jullie één van de echt nieuwe features zien in RHEL10: Commandline Assistant.

Vroeger (toen alles nog beter was) kon je met redelijk gemak een grafische applicatie op een remote machine draaien met de ouput op je lokale machine door ssh -X te gebruiken. Dit zette de DISPLAY variabele op de remote machine naar een nep display, en stuurde al het verkeer van die display over de SSH verbinding door naar je lokale display.

Dit was natuurlijk erg handig, maar het was ook niet erg veilig. Tegenwoordig gebruikt bijna alles Wayland in plaats van X11, en dat maakt dingen als stiekem alle toetsenbord input stelen, of de inhoud van vensters van andere applicaties lezen een stuk moeilijker, een win voor de beveiliging. Helaas maakt dat het over het netwerk draaien van grafische applicaties ook wat moeilijker.

Gelukkig is daar natuurlijk ook een oplossing voor.

In het verleden hebben we hier op dit kanaal al eens gekeken naar het automatisch schalen van je applicaties aan de hand van custom metrics. Maar dat waren custom metrics, en met Keda. De basis, de standaard Kubernetes HorizontalPodAutoscaler, hebben we nog niet behandeld.

Deze week een keertje geen leuke technische nieuwigheden, maar een (korte) verhandeling en oproep van Wander over het begrijpen van wat je doet.

Te vaak ziet Wander dat mensen wel weten hoe ze een kunstje moeten uitvoeren, maar niet snappen wat dat kunstje op de achtergrond voor ze doet, of hoe het werkt.

Meestal als je KubeVirt (OpenShift Virtualization voor de OpenShift gebruikers onder ons) draait, en je wilt virtuele machines van buiten het cluster beschikbaar maken, dan grijp je naar zaken als Secundaire netwerken met OVS of Multus. Dit is dan ook de methode die bijvoorbeeld door Red Hat wordt aangeraden voor OpenShift. Het voordeel hiervan is dat het mooi samenwerkt met dingen als UserDefinedNetworks (UDN), VLAN tagging/trunking, etc.

Maar we hebben niet altijd allemaal toegang tot nodes met extra netwerk-kaarten, mooie netwerk setups, enzovoort. Sommige van ons doen veel werk met dingen als Kind, OpenShift Local (CRC), of andere kleine setups. In die gevallen kun je je VMs wel exposen aan het externe netwerk als je een beetje vals speelt door bijvoorbeeld MetalLB te gebruiken.

Vorige week hadden we hier de jaarlijkse HCS Paaspuzzel. Ondertussen is de inzendtermijn verstreken, en kunnen we met jullie de oplosing bespreken.

Zoals ieder jaar hebben wij ook dit jaar weer een leuke Paaspuzzel voor jullie. Dit jaar is het een Capture-the-Egg challenge geworden; Net een Capture-the-Flag, maar dan met Pasen.

Om mee te doen kun je naar het scenario op KillerCoda gaan en de instructies opvolgen.

Het insturen van je antwoord kan tot en met 24 April 2025, via het formulier dat gelinkt staat in de KillerCoda.

Soms heb je een probleem waar je met de gewone foutmeldingen of logging niet uitkomt. Applicaties die alleen maar zeggen “File not found”, maar niet zeggen welk pad ze proberen te openen bijvoorbeeld. In dat soort gevallen zou je naar een volledige, zware, debugger als gdb kunnen grijpen, maar je kunt ook eerst iets eenvoudigers proberen.

In de Gnome Desktop kun je in “Files” applicatie (Nautilus) de gebruikte iconen voor je folders aanpassen. In deze video laat Wander zien hoe je dit kunt doen in “Files” zelf, of op de commandline met het gio commando.

Als bonus kijken we snel naar de “Iconic” applicatie (te installeren vanaf FlatHub) om makkelijk mooie folder icoontjes te maken je folders.

Vandaag, 28 Maart 2025, stapt onze HCS collega Benoit in het huwelijksbootje met Annelise. Om dat heugelijke moment te vieren hebben we vandaag een speciale Sudo Friday voor jullie, maar vooral voor het gelukkige bruidspaar.

In de video kijkt Wander met jullie naar een aantal commando’s die (in)direct wat met bruiloften te maken hebben.

Vergeet vooral niet Om het verse bruidspaar veel geluk te wensen in de comments.

Wanneer je Kustomize gebruikt om je Kubernetes applicaties (of configuraties) uit te rollen kun je tegen het probleem aanlopen dat je een wijziging wilt maken aan je bases of je components, maar zonder dat deze tegelijk al je verschillende omgevingen raakt.

Gelukkig gebruikt Kustomize voor het ophalen van externe resources een handige library genaamd go-getter die met een simpele syntax verschillende Git revisies kan ophalen.

Dashboards en statuspagina’s zijn twee verschillende dingen. Een dashboard is bedoeld voor beheerders en laat gedetailleerde statistieken zien die gebruikt kunnen worden voor correlatie. Een statuspagina is daarentegen bedoeld voor eindgebruikers, en laat een simpel beschikbaar/niet beschikbaar zien.

Wanneer je eenb statuspagina wilt toevoegen aan je infrastructuur dan heb je een hoop keuzes uit self-hosted (open-source) paketten, en betaalde diensten die door third-parties gehost worden. ZO kun je bijvoorbeeld beginnen met het overzicht van Awesome Status Pages op GitHub.

Wander vond daarentegen dat er iets simpels miste dat je met een enkel configuratie bestand ergens in een container of een VM kon draaien, specifiek geënt op OpenShift/Kubernetes of andere dingen die je met Prometheus kunt monitoren.

In deze video laat hij openshift-status zien, een klein tooltje dat een statuspagina voor één of meerdere clusters maakt aan de hand van Prometheus queries. Geen externe databases, of andere dependencies, alleen een enkele binary en een configuratie bestand.

Hier bij Sudo Friday hebben we al vaker gekeken naar manieren om Kubernetes Resource Requests en Limits te werken, bijvoorbeeld hoe dat geïmplementeerd wordt met CGroups, of hoe je ze “Correct” kunt zetten met een Vertical Pod Autoscaler (VPA).

Wat we daarentegen nog nooit hebben gedaan is uitleggen wat Requests en Limits nou precies inhouden, en waarom een applicatieteam zelf er om zou moeten geven.

In het verleden hebben we hier gekeken naar een manier om namespaces op een Kubernetes cluster te managen met een ArgoCD ApplicationSet en Kustomize. Toen gebruikten we veelvuldig “Replacements”, maar omdat deze buiten de Kustomize tree stonden moesten we ArgoCD vertellen om de Kustomize LoadRestrictor op None te zetten.

Maar in 2½ jaar tijd veranderd er veel, tools krijgen nieuwe functionaliteit, mensen krijgen voortschrijdende inzichten, en we worden allemaal wat ouder en wijzer.

In het verleden hebben we op dit kanaal al vaker gekeken naar grafische management tools voor Kubernetes.

Een grote die we toen niet gedaan hebben was Lens, aangezien deze niet meer open-source is. Gelukkig is er ook Freelens, een fork van de open core van Lens (Openlens) die actief ontwikkelt wordt.

Op OpenShift gebruiken veel mensen voor monitoring/metrics de standaard Prometheus stack die wordt meegeleverd, maar er zijn ook andere opties. Vooral als je naar een lichtere oplossing zoekt kan het handig zijn om naar alternatieven te kijken.

In het verleden hebben we hier op dit kanaal al gekeken naar Podman Desktop en al meerdere malen naar Quadlets.

Maar wat we nog niet gedaan hebben is kijken naar de combinatie van die twee. Gelukkig is daar een extensie voor die makkelijk geïnstalleerd kan worden.

Met ArgoCD kun je op meerdere manieren een groep van (verwante) applicaties beheren. Een klassieke methode is met het zogenaamde “App-of-Apps” patroon. Één applicatie die andere applicaties aanmaakt binnen ArgoCD. Dit kan in sommige gevallen handig zijn, maar soms wil je wat meer automatisering en wat minder handwerk. In die gevallen kan een ArgoCD “ApplicationSet” nuttig zijn: Een ArgoCD objectr dat automagisch aan de hand van een lijst van “generators” applicaties opbouwt.

In sommige omgevingen krijgen OpenShift beheerders te horen dat (specifieke) workloads gelimiteerd moeten worden in wat ze (buiten het cluster) kunnen aanspreken aan externe diensten en hosts. Nu kun je dit met standaard NetworkPolicy objecten oplossen, maar aangezien afnemers over het algemeenNetworkPolicy objecten in hun eigen namespaces mogen editen is dit niet de meest robuuste oplossing.

Je zou ook kunnen gaan werken met EgressIP objecten, en verkeer van die IP adressen buiten het cluster laten filteren, maar dan kom je al snel in een wereld waar je honderden extra IPv4 adressen nodig hebt.

Je zou ook met AdminNetworkPolicy objecten bezig kunnen gaan, maar deze zijn nog redelijk nieuw, en werken nog niet buiten OpenShift.

Gelukkig is er ook nog een vierde optie voor gebruikers van het OVN-Kubernetes SDN: EgressFirewalls

Wanneer je met Podman een container of pod maakt wordt deze als je niks anders opgeeft aan het standaard “podman” network gekoppeld. Als je meer controle wilt, bijvoorbeeld omdat je een gelaagde applicatie in meerdere containers of pods draait, dan mag je ook zelf extra netwerken aanmaken en bepalen welke containers/pods aan welke netwerken gekoppeld zitten.

Praktisch iedereen die netwerken beheert heeft het wel eens gezien: Twee hosts die hetzelfde IP(v4) adres proberen te gebruiken. Dit zorgt over het algemeen voor veel hilariteit en weinig productiviteit.

Op systemen die “NetworkManager” gebruiken kan er een simpele veiligheidsmaatregel worden aangezet: een ARP request voor het gewenste IPv4 adres voordat deze geactiveerd wordt. Is het adres in gebruik, dan wordt de verbinding niet geactiveerd.

Op RHEL9 en ouder staat deze test standaard uit, op RHEL10 en Fedora41 staat deze test standaard aan.

Om het nieuwe jaar goed te beginnen, en misschien wat te helpen met goede voornemens, laat Wander in deze video het (stokoude) commandline tooltje fortune zien. Een kleine applicatie die een willekeurige quote uit een (willekeurige) gekozen lijst aan quotes laat zien.

Spoiler Alert: Deze video bevat wat hints voor de Kerst Puzzel

Zoals elk jaar hebben we ook dit jaar weer de traditionele Kerst Puzzel voor jullie.

Dit jaar is de opgave simpel:

Je bent ingebroken op het datacenter van de Kerstman (iets met jezelf uit de database van stoute mensen willen verwijderen). Je hebt nu een shell op de authorative nameserver voor het .santa domein, en je bent op zoek naar de hostnaam (FQDN) en omschrijving van de server waar de database voor de stouterds op wordt bewaard.

Zoals elk jaar hebben we ook dit jaar weer de traditionele Kerst Puzzel voor jullie.

Dit jaar is de opgave simpel:

Je bent ingebroken op het datacenter van de Kerstman (iets met jezelf uit de database van stoute mensen willen verwijderen). Je hebt nu een shell op de authorative nameserver voor het .santa domein, en je bent op zoek naar de hostnaam (FQDN) en omschrijving van de server waar de database voor de stouterds op wordt bewaard.

In het verleden hebben we hier al vaker gekeken naar Podman Quadlets, een makkelijke manier om containers als systemd services te draaien. We hebben gekeken naar het maken van container units, en naar het templaten van comtainer units. Maar wat we nog niet gedaan hebben is het kijken naar container image builds met quadlets.

In een Containerfile levert elk RUN commando een aparte “layer” op in het resulterende image. Wanneer je in een latere layer data uit een eerdere layer verwijdert blijft deze data dus wel in je container image zitten, je ziet het alleen niet meer.

Een veel voorkomend voorbeeld hiervan is bijvoorbeeld de gecachete metadata van je package manager.

Wanneer je kustomize gebruikt om met Overlays de lifecycle-fases van je applicatie te beheren dan ga je vroeger dan later een keer de vragen stellen hoe je promoties van images (en Bases) tussen deze fases kunt automatiseren. Met de hand references en image transformers doorzetten is meestal geen optie vanwege de kans op fouten, en het willen automatiseren van de promotie pipelines.

Nu zijn er bestaande oplossingen met tools als Renovate die dit (gedeeltelijk) voor je kunnen oplossen, maar die hebben vaak wat meer infrastructuur nodig. Als je deze tools nog niet gebruikt dan zou je zelf wat scriptjes kunnen schrijven, maar nu heb je nog iets extras om te beheren en bij te houden.

Één van de nieuwe features in RHEL9.5 is de mogelijkheid om in Cockpit, de grafische management console van RHEL, bestanden te beheren alsof je in een grafische file-manager werkt.

Basis Kubernetes kent maar twee manieren van authenticatie: Een lijst van statische oauth bearer tokens, gekoppeld aan gebruikers en groepen, en client TLS certificaten met de gebruikersnaam in het “CN” (Common Name) veld en eventuele groepen in één of meer “O” (Organization) velden.

Op een Linux systeem heb je de keuze uit een aantal compressie tools en algoritmes voor het verkleinen van je bestanden en/of archieven. Ook kunnen sommige bestandsystemen (zoals Btrfs) transparant compressie toepassen op bestanden waar nodig.

Op dit kanaal hebben we al vaker gekeken naar Podman. Zo hebben we gekeken naar het maken van systemd units van je containers, het werken met podman-compose, het draaien van Kubernetes manifesten met Podman, en meer.

Maar één van de dingen die we nog nooit gedaan hebben is het gebruiken van Pods met Podman, en dat terwijl dat zelfs in de naam zit.

Argo Rollouts op OpenShift

Met Argo Rollouts kun je Deployment objecten vervangen door Rollout objecten die meer controle geven over hoe updates aan een Deployment uitgerold worden. Langzaam aan met Canaries, atomisch met Green-Blue changeover, en meer. Dit alles kan automatisch gebeuren, met handmatige promotie stappen, combinaties daarvan, en zelfs met probes die kijken of een nieuwe versie goed werkt.

Één van de uitdagingen die wij vaak zien bij klanten op het gebied van platform management is het “right-sizen” van applicaties; Het goed zetten van de requests en limits voor applicaties zodat ze altijd aan resources kunnen gebruiken wat ze nodig hebben, maar niet onnodig veel aanvragen dat niet door de rest van de applicaties op het cluster gebruikt kan worden.

Naast educatie van applicatie teams, een belangrijke stap, kan het ook handig zijn om teams (geautomatiseerde) adviezen te geven over de “juiste” instellingen voor hun applicaties. Een tool die daarbij kan helpen is de Vertical Pod Autoscaler van OpenShift.

Met de release van OpenShift 4.17 is er een feature in Technology Preview gekomen waar Wander al heel lang op zat te wachten: User Namespaces.

User Namespaces hebben niks te maken met Kubernetes Namespaces, maar met Linux Kernel Namespaces. Met User Namespaces kan een container een ander idee hebben van wat user ids zijn dan het onderliggende OS. Zo kan een proces in een container denken root te zijn, en alle rechten hebben (binnen de container) die daarbij horen, maar buiten de container stiekem een ander UID hebben. Dit is hetzelfde principe als met Rootless Podman, maar nu beschikbaar (als beta) op Kubernetes, en dus ook op OpenShift.

Met deze feature hoeven cluster beheerders minder vaak uitzonderingen te maken voor onder andere COTS applicaties door toegang to verlenen tot de anyuid of nonroot Security Context Constraints (SCC), wat kan leiden tot een beter security posture.

In de Kubernetes wereld is “Kustomize” één van de handigste manieren om met je manifesten om te gaan als je naar meerdere omgevingen of life cycle fases wilt uitrollen. Het is niet voor niks dat de basis-functionalieit van Kustomize ook in het kubectl en oc commando zit ingebakken.

Naast alle ingebouwde transformatie die Kustomize kan uitvoeren op zaken als replicas, images, labels, etc. is er ook een ingebouwde transformer die patches kan uitvoeren, zowel Strategic Merge patches die misschien kent van kubectl apply als JSON6902 patches zoals bekend van kubectl patch.

Vorige week hebben we met jullie gekeken naar een interactieve tutorial over het schrijven van je eerste Containerfile. Deze week bouwen we verder op die kennis, en willen we jullie via een nieuws scenario kennis laten maken met “Multi-Stage Builds”.

Op dit kanaal hebben we het vaak over containers en container-gerelateerde zaken zoals Kubernetes. Één van de dingen die we daarentegen nog nooit besproken hebben is de basis van het zelf maken van containers en container images.

Deze week gaan we hier wat nieuws mee uitproberen, in plaats van een video met uitleg, en eventueel wat source-code, krijgen jullie een interactieve leeromgeving met instructies waar je de uitleg tegelijk in de praktijk kunt toepassen.

Je kunt dit lab vinden op Killercoda in de HCS Sudo Friday omgeving

Veel beheerders brengen (terecht) een groot deel van hun dag door op de command prompt. Nu wordt natuurlijk alles wat geautomatiseerd kan worden ook geautomatiseerd, maar wat handwerk zal er altijd zijn. Nu kan het zijn dat sommig van dat handwerk een kans van falen heeft, bijvoorbeeld omdat een remote systeem (tijdelijk) niet bereikbaar is, omdat een mirror nog niet gesynchroniseerd is, of gewoon omdat de stand van de maan je systeem niet aanstaat.

In plaats van een commando dan met de hand meerdere keren te proberen kun je ook je shell dit voor je laten doen. Één van de manieren waarop dat kan is met een until block.

Bij veel bedrijven draaien er naast de standaard software die door de OS leverancier is aangeleverd ook custom applicaties op de servers. Soms zijn deze in huis geschreven, soms zijn deze door een andere leverancier aangeleverd. Maar in beide gevallen is de kans klein dat deze services al restricties opgelegd hebben gekregen via een SELinux policy.

Het is gelukkig mogelijk om zelf policy modules te schrijven die de bestaande SELinux policy uitbreiden met extra types en regels voor je custom applicaties. Hoever je wilt gaan in het opleggen van restricties is aan jou.

Praktisch elke Kubernetes/OpenShift beheerder kent het principe van de NetworkPolicy, objecten binnen een namespace die bepalen welk verkeer van en naar je pods is toegestaan binnen die namespace.

Om hier gezonde defaults voor af te dwingen hebben de meeste (multi-tenant) clusters ook al maatregelen, zoals DefaultProjectRequestTemplates of Kyverno “generate” regels, die een set “standaard” NetworkPolicies in elke namespace neerzetten.

Het probleem dat nu ontstaat is dat als tenants hun eigen NetworkPolicies moeten kunnen maken, om de toegang binnen hun applicaties fijnschalig te kunnen regelen, ze ook rechten moeten hebben om de defaults aan te passen of te verwijderen. Nu hoeft dat geen probleem te zijn, maar als teams minder voorzichtig of ervaren zijn kan dat al snel leiden tot support calls omdat de OpenShift ingress pods bijvoorbeeld niet meer bij hun applicatie mogen, en hun Routes zijn stukgegaan.

Gelukkig hebben in OpenShift 4.14 NetworkPolicies een uitbreiding gehad, die in 4.16 GA gegaan is en dus ondersteund gebruikt kan worden: AdminNetworkPolicies.

Op moderne Linux systemen kun je (terugkerende) taken voor de toekomst plannen met Systemd “timer” units. Maar de oudere, bekendere, methode van at en cron is meestal ook nog beschikbaar.

In deze video laat Wander zien hoe je deze twee klassiekers zowel als gewone gebruiker en als root kunt gebruiken.

Één van de handige Podman functionaliteiten waar we in het verleden een keertje kort wat over gezegd hebben, maar nooit dieper hebben laten zien, is het podman kube subcommando. Dit stukje Podman laat je twee dingen doen, een lokale Podman container of pod als Pod op een Kubernetes cluster deployen, en Kubernetes manifesten deployen als Podman pods en containers.

Twee jaar geleden hebben we samen met jullie gekeken naar het handmatig maken van een Systemd unit van je containers. Een jaar geleden hebben we laten zien hoe je dat moderner kunt doen met Quadlets. Vandaag willen we met jullie kijken naar een recente uitbreiding op quadlets van Podman 5.0.0 (hopelijk straks in RHEL9.5, maar nu al in Fedora) die het mogelijk maakt om ook je containers via Systemd templates aan te maken. Templates geven je de mogelijkheid om een basis unit te definiëren, waar je vervolgens instanties van kunt starten met hun eigen naam. Die naam kun vervolgens ook als variable in je units gebruiken voor bijvoorbeeld de locatie van data-directories of commandline parameters.

Als je meerdere vensters open hebt staan kan het zijn dat je makkelijk afgeleid raakt door de inhoud van een ander venster dan die waar je mee aan het werk bent. Mocht jij daar ook last van hebben dan laat Wander speciaal voor jou in deze video een Gnome extensie zien die je daarbij kan helpen: Dim Background Windows.

Nu heel het land schoolvakantie heeft en het (hopelijk) iets rustiger is op het werk is het tijd om wat aan je persoonlijke ontwikkeling te doen. Één van de manieren waarop je dat zou kunnen doen is door jezelf bloot te stellen aan wander andere Operating Systemen dan je gewend bent.

Natuurlijk kun je dat doen hoe je het altijd al gedaan hebt, door een ISO te downloaden en die in je virtualisatie software naar keuze te steken, maar je zou ook een keertje wat nieuws kunnen proberen.

Nu het (bijna) vakantie is wordt het voor veel mensen weer tijd om bij te lopen met het kijken van de series en films die ze het afgelopen jaar gemist hebben. Wanneer je alles van je streamingdiensten afhaalt wordt er automatisch voor je bijgehouden wat je al gekeken hebt, en waar je bent gebleven. Maar als je ook gebruik maakt van de bioscoop, DVDs/Blu-Rays, of andere digitale media, dan kan het zijn dat je een geheugensteuntje nodig hebt van waar je bent gebleven.

Text-to-Speech (TS) en Speech-to-Text (STT) tools bestaan al jaren, zo weet Wander nog hoe hij bij zijn SoundBlaster16 een Text-to-Speech tooltje kreeg dat misschien geen hele goede kwaliteit was, maar in in ieder geval wel verstaanbaar.

Je kunt tegenwoordig geen steen gooien zonder iets “AI” te raken. Nu mist de “I” uit AI nog overal, maar sommige dingen kunnen dat wel geloofwaardig nadoen. Één van de huidige hype vlakken zij Large Language Models (LLM), software met datasets die plausibel klinkende antwoorden kunnen geven op vragen. Waarschijnlijk ben je wel bekend met commerciële LLMs, zoals bijvoorbeeld ChatGPT.

Wanneer je op een Linux systeem regelmatig dynamisch bestandssystemen moet mounten (bijvoorbeeld NFS home directories), of liever niet alle mounts standaard aan hebt staan terwijl ze nauwelijks gebruikt worden, kan de automounter (autofs) uitkomst bieden.

Autofs mount zichzelf op een directory, en mount dan vervolgens dynamisch subdirectories wanneer ze aangesproken worden, en unmount ze na een periode van inactiviteit weer.

De meeste beheerders zijn wel bekend met de basis van het systemctl commando om hun (draaiende) services te beheren. Maar soms wil je toch iets meer gemak, zoals het makkelijk naar de logs van een service kunnen klikken, of de dependencies in één overzicht kunnen zien.

Iedere beheerder komt wel een keer op het punt dat hij het root wachtwoord van een systeem niet (meer) kent. Misschien is het een oud, niet goed gedocumenteerd, systeem, misschien is het een super-speciaaltje uit een verloren tijd, of misschien had iemand dikke vingers bij het instellen.

In een moderne setup kan het het makkelijkst zijn om dat systeem gewoonweg opnieuw in te spoelen, maar helaas is dat niet altijd een mogelijkheid. In het geval van een virtuele machine zou je ook het disk-image ergens anders kunnen koppelen en op die manier /etc/shadow bewerken, maar ook dat is niet altijd een uitkomst.

Wat je wel (bijna) altijd kunt doen, als er geen wachtwoord op de bootloader staat, of dat wachtwoord is bekend, is inbreken op het boot proces en op die manier jezelf toegang verschaffen tot het systeem, waarna je dingen kunt doen als het root wachtwoord resetten naar een bekende waarde.

In wat recente videos hebben we gekeken naar SELinux troubleshooting en policy queries, zonder de basis van SELinux te behandelen. Nu hebben we de basis meer dan twee jaar geleden behandeld in een serie videos, maar het is wel weer tijd voor een opfrisser.

Mensen die de hele dag in hun editor of IDE naar keuze leven hebben waarschijnlijk een flinke lading aan trucjes, kunstjes, macros, en zwarte magie die ze uit hun vingertoppen schudden om veelvoorkomende transformaties uit te voeren. Denk bijvoorbeeld aan Base64 Encode/Decode, het omzetten van een document tussen JSON en YAML, of het escapen van speciale karakters in URLS.

Mar de mensen die dit soort acties met minder regelmaat uit moeten voeren zijn vaak op zoek naar de goede plugin of commandline tool voor wat ze willen, en vallen vaak terug op (soms wat minder betrouwbare) websites om dit voor ze te doen.

Zij die gelukkig genoeg zijn om op een moderne Linux desktop te werken kunnen ook gebruik maken van “Text Pieces”, een handige grafische applicatie die je makkelijk transformaties laat uitvoeren op (stukken van) je tekst.

Naast een hele rits aan ingebouwde filters kun je Text Pieces ook uitbreiden met je eigen filters door daar (eenvoudige) scripts voor te schrijven.

Op een RHEL systeem is standaard een SELinux policy (meestal targeted) actief die bepaalt wat services wel, maar vooral ook niet, mogen doen. In principe is alles wat niet expliciet is toegestaan verboden, maar wat er nou precies is toegestaan is voor veel beheerders een enigma.

Gelukkig zijn er tooltjes waarmee je een SELinux policy kunt uitlezen om te zien wat er nou precies allemaal inzit, zonder naar de source van de policy te hoeven grijpen. Een bijkomend voordeel van je draaiende systeem uitlezen is dat eventueel geladen modules en extensies ook uitgelezen worden.

Sinds de release van Red Hat Enterprise Linux (RHEL) 9.4 is er een toffe Technology Preview (TP) waarmee je ostree gebaseerde RHEL systemen kunt uitrollen met je eigen custom images. Denk de Universal Blue variant van Silverblue, maar dan voor je eigen custom RHEL deployments, of het nou gaat om machines in de cloud, bare-metal, lokale VMs, etc.

Een van de leukste dingen hieraan, naast de standaard voordelen van image-based deployments met ostree zoals pijnloze rollbacks etc., is hoe makkelijk het is om je eigen images te maken aan de hand van een Containerfile (Dockerfile voor degenen die in het vorige decennium leven).

Iedere beheerder die RHEL(-familie) systemen beheert is wel eens tegen een probleem aangelopen waarbij SELinux iets aan het tegenhouden was dat eigenlijk niet tegengehouden had moeten worden. Dan kun je zelf de SELinux log files induiken (/var/log/audit/audit.log), maar je kunt ook andere tooltjes daar naar laten kijken voor je, om wat leesbaardere output te krijgen.

In deze video wilde Wander met jullie een discussie op gang brengen over hoe afbeeldingen van Cyber Security in Populaire media een vertekend beeld geven bij het algemene publiek over het vakgebied.

Sommige mensen vinden het fijn om wat kalmerende achtergrond geluiden te hebben terwijl ze werken. Voor die mensen is er “Blanket”, een applicatie om je eigen soundscapes te maken door verschillende loopende geluiden, zoals witte ruis, fluitende vogeltjes, of kabbelende beekjes, te mixen.

Iedereen die ooit wat op een Unix, Linux, of BSD commandline gedaan heeft kent waarschijnlijk het tooltje top wel. Een handig manier om snel een overzicht van het CPU en geheugen van je processen te krijgen. Nu is er niks mis met het top commando, maar het mist informatie over dingen als netwerk en disk gebruik, en erger nog, het ziet er niet 733t uit.

De meeste mensen die Flatpak kennen zullen dat waarschijnlijk vooral doen vanwege het feit dat het een makkelijke, distributie onafhankelijke, manier is om grafische applicaties mee te installeren en te draaien, vaak in een sandbox.

Maar wist je dat je ook commandline apps kunt draaien met Flatpak? Dit kan handig zijn om de bijbehorende CLI tools van je grafische applicaties te gebruiken, maar ook om tools uit de runtimes van je Flatpak applicaties te gebruiken.

In veel browsers heb je tegenwoordig de mogelijkheid om van een spelende video een kleiner, zwevend Picture-in-Picture (PiP) venster te maken, dat boven je andere vensters blijft zweven. Nu zou het handig zijn als je dat met elk venster zou kunnen doen, bijvoorbeeld om een langlopend shell commando in de gaten, of de webcamviewer voor je 3D printer.

Als je gebruikt maakt van de Gnome Desktop dan is er een handige extensie die je kunt installeren die je precies die functionaliteit biedt: van elk venster dat je maar wilt een (schaalbare) miniatuur maken die je kunt verplaatsen, en die boven je andere vensters blijft zweven: WTMB (Window Thumbnails).

Zoals elk jaar heeft HCS Company ook dit jaar weer een leuke puzzel voor jullie met Pasen.

Dit jaar is de Paashaas langs geweest op Wander zijn desktop, en heeft daar wat woorden voor jullie verstopt achtergelaten. De woorden kunnen zich echt overal bevinden, in plaatjes, applicaties, tekstbestanden, etc., maar overal staat duidelijk aangegeven om welk woord het gaat. Aan jullie de taak om alle zes de woorden te vinden, die in de goede volgorde te zetten, en de resulterende zin op te sturen.

Één van de meest onmisbare tools bij het debuggen van problemen ope een Kubernetes/OpenShift cluster zijn de “Events”. Kleine stukjes informatie/logging die door de verschillende controllers gegeneerd worden (als Kubernetes objecten) met informatie over wat er allemaal gebeurt en misgaat. Zo zul je in deze events berichten tegenkomen over het al dn niet succesvol ophalen van container images, het starten van pods en containers, het aanmaken van Jobs vanuit een CronJob, het falen van de verschillende probes die op een pod kunnen staan, en meer.

Als je een applicatie die via Hem charts wordt gedistribueerd in je OpenShift GitOps (ArgoCD) wilt opnemen heb je twee opties:

1. Een ArgoCD applicatie van het type “Helm” maken
2. De Helm chart via kustomize laten renderen, en de kustomization.yaml in je ArgoCD opnemen.

De eerste oplossing is het makkelijkst, en heeft weinig extra configuratie nodig. Het nadeel is wel dat je wat betreft aanpassingen gelimiteerd bent op wat de schrijver van de chart via de values.yaml heeft aangeboden.

Wanneer je extra aanpassingen nodig hebt kom je dus al snel uit op de tweede methode: De helm chart via kustomize laten renderen (inclusief aanpassingen via values.yaml), en daar extra aanpassingen op doen via de bekende kustomize transformers zoals images:, patches:, replicas:, etc.

Soms kan het gebeuren dat er in een instantie van AWX (of Ansible Tower, of Red Hat Ansible Automation Platform) credentials staan opgeslagen die belangrijk zijn, maar die nergens anders terug te vinden zijn. Ga je in zo een geval naar de web interface van AWX, die krijg je overal bij de belangrijke velden $encrypted$ te zien, maar niet de waardes die je zo hard nodig hebt.

Gelukkig is er een manier om via het awx-manage commando deze waardes niet alleen op te vragen, maar ook te laten ontsleutelen.

In een vorige aflevering van Sudo Friday hebben we gekeken naar een aantal grafische applicaties om je Kubernetes clusters mee te managen. Een applicatie die daarvoor op Wander zijn lijst stond om te onderzoeken, maar die helaas (nog) niet met alle authenticatie methodes werkte, en dus helaas ook niet met OpenShift, was “Seabird”.

Één van de belangrijkste features van elke pakketmanager is het kunnen terug rollen naar vorige versies. Dit kan bijvoorbeeld nuttig zijn wanneer een nieuwere versie een bug heeft geïntroduceerd in een applicatie waar je op vertrouwd.

Met yum/dnf heb je hiet het downgrade commando voor, die naar de vorige versie gaat, of de versie die je opgegeven hebt.

Met flatpak kun je exact hetzelfde doen, alleen gebruiken we daar geen Epoch-Version-Release nummering zoals bij RPM pakketten, maar werken we met Git commit hashes voor de versie van het manifest.

Praktisch elk Open Source project heeft wel een logo of een mascotte, maar sommige zijn bekender dan anderen, terwijl hun project of applicatie misschien wel heer erg bekend is.

In deze video laat Wander veertien verschillende logos zien, en jullie mogen raden van welk project ze zijn.

Niet iedereen is gelukkig genoeg om het budget te hebben voor Ansible Automation Platform (AAP), en sommige mensen gebruiken liever een upstream open-source versie van een product dan de betaalde, ondersteunde, versie. Voor Ansible orkestratie kom je dan al snel uit op Ansible AWX.

Recente versies van AWX zijn alleen geschreven om op een Kubernetes platform te draaien, en uitgerold te worden via een operator. Nu kun je wel een dev versie met podman draaien, maar dat levert ook weer problemen op.

Hoe doe je dat dan als je geen (toegang tot) een Kubernetes cluster hebt? De minikube variant zoals beschreven in de AWX documentatie is alleen bedoelt voor test omgevingen, niet productie… Het antwoord kan zijn: “K3S”. Deze lichtgewicht Kubernetes implementatie is wel geschikt voor productie, en kan ook redelijk eenvoudig geïnstalleerd worden.

Via het upstream “kubevirt” project is het mogelijk om virtuele machines te draaien als pods op een Kubernetes cluster. Op OpenShift is hier een door Red Hat ondersteunde versie van genaamd “OpenShift Virtualization”. Op deze manier kun je je VMs makkelijk (bijna) hetzelfde beheren als je containers, bijvoorbeeld met een tool als ArgoCD, of met Tekton Pipelines.

De hardcore CLI fanaten onder ons zullen het niet willen geloven, maar er zijn echt mensen die de voorkeur geven aan een grafische omgeving waar ze in mogen klikken met een muis of een touchscreen voor hun beheer-werkzaamheden.

Als jij ook van die mensen kent, of er zelf eentje bent natuurlijk, dan ben je waarschijnlijk blij om te weten dat er meerdere applicaties zijn die je een grafische omgeving willen geven om je Kubernetes en/of OpenShift clusters te beheren.

De meeste mensen die met Bash werken zijn wel bekend met het fenomeen “Command Substitiuion”; Je zet in een commandline een commoando tussen $( en ), of tussen backticks `, en dat stuke van je commandline wordt vervangen door de output van dat commando.

Nu zijn er helaas situaties waar je die output in een (tijdelijk) bestand nodig hebt voor een ander commando, en je niet moeilijk wilt doen met het herschikken van file-descriptors of het zelf aanmaken van tijdelijke bestanden. In die gevallen kun je gebruik maken van “Process Substitution”, waarbij Bash zelf voor de tijdelijke bestanden zorgt in de vorm van named pipes.

OpenShift Network Observability Operator

In recente versies van OpenShift kun je de “Network Observability Operator” installeren om een beter inzicht te krijgen in de netwerk flows tussen de verschillende componenten/pods/services/etc op je cluster, als ook het netwerk verkeer dat je cluster verlaat.

Deze inzichten kunnen dan gebruikt worden voor verschillende zaken; Het doorberekenen van netwerk gebruik, optimalisatie van traffic-flow tussen de componenten van een micro service, of zelfs het detecteren van “ongebruikelijk” verkeer in een applicatie.

Zo aan het begin van een nieuw jaar is voor veel mensen het uitgelezen moment om als onderdeel van de goede voornemens hun organistaie aan te pakken. Nu zijn er een heleboel tools die je hiermee proberen te helpen, van simpele todo items in Outlook, tot complexe notities in EverNote. Een nadeel is dat veel van deze tools closed-source zijn, en/of je data ergens in de wolken opslaan.

Gelukkig zijn er ook open-source oplossingen die wel om je privacy geven, en die vaak zelfs meer functionaliteit of configureerbaarheid (3x woordwaarde) hebben dan hun gesloten verwanten.

De HCS Kerst Puzzel van 2023 is nu een week bezig. Mocht je in het begin vast zijn komen te zitten dan krijg je in deze video een korte walkthrough van het eerste gedeelte: Jezelf toegang verschaffen tot ons kantoor. (Nog een hint, in het echt gaat dat het makkelijkst door voor ons te komen werken.)

Volgens goede HCS traditie hebben we ook dit jaar weer een leuke Kerst Puzzel voor jullie. In het verleden zijn we bezig geweest met puzzle hunts op Kubernetes, sudokus, japanse puzzels, quizzes, en meer. Dit jaar hebben we eer wat anders, en het is geweldig geworden: Onze eigen Vincent van Dam heeft een heus retro text-adventure voor jullie gemaakt!

In tegenstelling tot sommige andere text-adventures kun je niet “af”. Het is niet donker, je wordt niet opgegeten door een grue. Wel moet je met de goede mensen praten (een heuse sterrencast aan HCS-ers), de juiste voorwerpen gebruiken op de juiste plekken, een potje fußbal winnen, en het allebelangrijkste: Kerst Redden!

In het verleden hebben we al vaker gekeken naar grafische systeem monitoring tools, maar er kan natuurlijk altijd meer bij.

Één van de meer recente toevoegingen aan het landschap is “Mission Center”, een tool die geïnspireerd lijkt door de standaard systeem mnonitoring view in nieuwere versies van Windows.

Een handige toevoeging van Mission Center is het ook kunnen bekijken van de load op verschillende delen van je videokaart(en), zoals de video encoding/decoding of het gebruik van de processors op je GPU.

Het is weer die tijd van het jaar dat sommige onder ons smachtend uitzien naar de sneeuw, terwijl anderen hopen dat de sneeuw snel voorbij gaat. Want alhoewel sneeuw mooi kan zijn om naar te kijken, is een straat vol sneeuw toch wat minder als je naar buiten wilt.

Af en toe kan het handig zijn om een volledige grafische desktop omgeving te draaien apart van je normale desktop. Bijvoorbeeld om een zwaar verouderde versie van een browser te gebruiken om tegen oude remote-management kaarten aan kunnen praten die vasthouden aan encryptie-standaarden die door moderne browsers als onveilig worden gezien, en dus niet meer gebruikt kunnen worden.

Hier zou je een virtuele machine voor kunnen gebruiken, maar het kan ook met minder overhead in een container.

Mensen die de Gnome Desktop omgeving gebruiken zijn waarschijnlijk wel bekend met de “Quick Toggle” om tussen light-mode en dark-mode te schakelen. Wat ze waarschijnlijk ook weten is hoe het theme van de standaard Gnome Terminal niet mee veranderd met deze keuze.

In een vorige video hebben we hier al eens gekeken naar “Toolbox”, een handig tooltje om dev omgevingen op te zetten in containers. Nu heeft Toolbox een broertje dat iets meer functionaliteit ingebouwd heeft, zoals het aanmaken van containers via een configuratie bestand, of het exporteren van grafische apps uit een container naar de launcher van je desktop: “Distrobox”

Als je vaak op de command line met Kubernetes of OpenShift werkt dan wil je soms specifieke stukken of velden van een manifest pakken om daar wat mee te doen. Dit kan je natuurlijk met -o yaml of -o json doen om daar vervolgens met yq of jq leuke dingen mee te doen, maar je zou ook de ingebouwde JsonPath of Go-Template functionaliteit kunnen gebruiken.

Als je een systeem hebt waar gebruikers van een afstand op mogen inloggen kan het handig zijn vanuit security of resource optiek om ze te beperken tot wat ze mogen doen. Hier zijn een aantal traditionele mogelijkheden voor, maar tegenwoordig kun je hun sessies ook beperken tot het draaien in een container. Dit heeft een aantal voordelen ten opzichte van traditionele methodes, zo komen bijvoorbeeld alle sessies uit in dezelfde container, en kan het verkrijgen van extra rechten permanent dichtgezet worden.

Als je Fedora Silverblue draait (of een andere rpm-ostree gebaseerde spin) is het upgraden tussen major versies van Fedora een snel en relatief pijnloos proces van slechts een paar minuten.

Af en toe kan het handig zijn om snel een grafisch overzicht te hebben van hoe je systeem resources gebruikt worden, zonder tegelijk op de CLI naar tools als top en ps te grijpen. Een recente toevoeging aan het landschap van tooltjes die dat bieden is “Resources”, een moderne Gnome applicatie die verschillende systeem statistieken in een aantrekkelijk jasje verpakt.

Wanneer je bezig gaat met SSL certificaten op OpenShift kom je al snel uit bij cert-manager, een operator die certificaten kan laten (genereren en) ondertekenen door een aantal verschillende vormen van Certificate Authorities.

Een nadeel aan cert-manager is dat het niet automatisch certificaten kan genereren voor OpenShift Routes, maar wel voor reguliere Ingress objecten.

Regelmatig terugkerende taken op een container platform kun je op Kubernetes inregelen met een CronJob. Maar als je die taak elke minuut gaat uitvoeren levert dat misschien een belastingspatroon op op je cluster dat ongewenst is, helemaal als de taak veel resources als externe filesystemen nodig heeft.

Nu zou je natuurlijk een traditionele Cron daemon in een container kunnen draaien, maar dan kom je er al snel achter dat deze graag als root draaien, met setgid en setuid permissies, en dat vind een container platform als OpenShift weer minder grappig zonder dat je SecurityContextConstraints met veel rechten gaat uitdelen. Ook zul je een init systeem in je container moeten stoppen omdat anders mogelijke zombie processen niet goed opgeruimd worden, en voor je het weet ben je een half OS in je container aan het stoppen.

Ook als je je taken vaker dan eens per minuut wilt draaien, of als je specifieke scheduling wensen hebt zoals “elke derde dinsdag van September” voldoet een traditionele Cron daemon of een Kubernetes CronJob al snel niet meer.

Er zijn een hoop momenten waarop je data wilt delen met één of meer virtuele machines. Traditioneel gezien betekende dit een netwerk-share opzetten en die aan je VMs koppelen, met alle overhead en security aspecten van dien.

Volledige disk-encryptie op Linux systemen kan al jaren via het gebruik van Linux Unified Key Setup (LUKS). Dit zorgt ervoor dat er tijdens het opstarten van een systeem om een passphrase wordt gevraagd waarmee (een van) de encryptie-key(s) kan worden ontsleuteld, en de rest is transparant voor de eindgebruiker.

In sommige gevallen kan het handig zijn als het boot-proces niet wordt onderbroken, bijvoorbeeld bij het herstarten van servers op afstand. Om dit te bereiken kun je grijpen naar tools als clevis en tang, die de encryptie keys onder bepaalde voorwaarden via het netwerk kunnen vrijgeven, maar je zou ook gebruik kunnen maken van de Trusted Platform Module (TPM) op moderne hardware.

Een web-applicatie bouwen kun je tegenwoordig in een heleboel verschillende talen (en frameworks) doen. Als ontwikkelaar heb je de keuze uit zoveel verschillende opties dat je toolset kiezen al een eerste probleem om op te lossen kan zijn.

Dat probleem hebben we niet altijd gehad. Decennialang is de keuze voor een taal duidelijk geweest: Wetenschappelijke problemen in Fortran, Business-Applicaties in Cobol.

Ook tegenwoordig kom je nog op een hoop verschillende plekken Cobol applicaties tegen, vaak in de back-end of de batch-verwerking bij grotere administratieve partijen.

#HCS #SudoFriday #Cobol #webapp #httpd #cgi #isitfriday

Je kunt al jaren lang je Linux systemen via een webbrowser managen met Cockpit, een handige tool die een aantal beheerszaken flink eenvoudiger maakt. Maar tot nu toe heb je altijd twee dingen nodig gehad: Een systeem met de Cockpit Webserver (cockpit-ws) geïnstalleerd om naar toe te verbinden met je browser, en de cockit-bridge dienst geïnstalleerd op elk systeem dat je wilt managen.

Één van de meest gebruikte formaten voor opgemaakte tekst op het internet, buiten HTML, is Markdown. Het voordeel van Markdown is dat tekst er als platte tekst in een simpele editor goed en begrijpelijk uitziet, maar ook simpel gerendered kan worden naar formaten als HTML en PDF met mooie opmaak.

Een applicatie op Kubernetes beheren is nog lang niet altijd zo gemakkelijk. Gelukkig is daar iets voor uitgevonden: Kubernetes operators. Een operator is als het ware een controller op Kubernetes (of OpenShift) om instanties van complexe applicaties te maken, configureren en beheren.

Het updaten van een Fedora Silverblue versie tussen major versies (een “rebase” genoemd") is een relatief snel en pijnloos proces. Maar als je ook de extra repositories van RPMFusion gebruikt kan het zijn dat je (eenmalig) een paar kleine extra stappen moet nemen om te zorgen dat je ook geupgrade pakketten uit die repositories gaat gebruiken.

De standaard Gnome Desktop op RHEL en Fedora systemen kan eenvoudig worden aangepast of uitgebreid met extensies die het gedrag of uiterlijk van de desktop in meer of mindere maten aanpassen.

Terminals zijn vaak een beetje monochromatisch, veel tekst, weinig kleur. In een zonnige zomer als deze willen we naturlijk allemaal graag wat meer kleur, en ook in onze terminals.

Op moderne Fedora systemen (en ook andere distributies) wordt standaard een filesysteem gebruikt dat momenteel niet in RHEL beschikbaar is: Btrfs.

Btrfs heeft een aantal leuke features die anders op een andere manier (bijvoorbeeld via Stratis en/of VDO) opgevangen moeten worden, zoals copy-on-write snapshots, transparante compressie, en sub-volumes.

Op moderne Fedora systemen (en ook andere distributies) wordt standaard een filesysteem gebruikt dat momenteel niet in RHEL beschikbaar is: Btrfs.

Btrfs heeft een aantal leuke features die anders op een andere manier (bijvoorbeeld via Stratis en/of VDO) opgevangen moeten worden, zoals copy-on-write snapshots, transparante compressie, en sub-volumes.

Op moderne Fedora systemen (en ook andere distributies) wordt standaard een filesysteem gebruikt dat momenteel niet in RHEL beschikbaar is: Btrfs.

Btrfs heeft een aantal leuke features die anders op een andere manier (bijvoorbeeld via Stratis en/of VDO) opgevangen moeten worden, zoals copy-on-write snapshots, transparante compressie, en sub-volumes.

Er zijn in de Linux wereld veel manieren om applicaties te packagen voor eindgebruikers. Deze methodes zijn grofweg op te delen in twee types; Het eerste type maakt geen onderscheid tussen Operating Systeem onderdelen en applicaties, denk bijvoorbeeld aan RPM of DPKG, en het tweede type houdt applicaties gescheiden van het onderliggende OS, zoals je ook kent van je mobiele telefoon.

In dat tweede type heb je ook weer een aantal smaken, AppImage, Snap, Flatpak, en meer.

Er zijn een hoop gevallen waarbij een OpenShift cluster vanuit technische- of veiligheidsredenen niet aan het internet verbonden mag of kan zijn. Nu geeft dit natuurlijk nogal wat problemen bij het installeren, upgraden, en gebruiken van zo’n cluster.

Nu heeft OpenShift de mogelijkheid om verzoeken voor images vanaf externe container registries om te leiden naar een registry van jouw keuze. Nu moet je alleen die registry nog vullen met de goede images, en dat zijn er nogal wat…

Tijdens het ontwikkelen van een applicatie kan het helpen om snel te kunnen itereren op builds en tests, zonder steeds naar een extern systeem te moeten pushen om je builds of images te testen. ook kan het nuttig zijn om lokale versies van externe servies, zoals databases, te draaien met test data.

Maar als je meerdere containers lokaal wilt orkestreren kan het soms uiputtend worden om al die losse containers te moeten blijven stoppen, starten, bijwerken, etc. In die gevallen zou het handig zijn als je al je builds, configs, en meer met een enkel configuratie bestand en een enkel commando kon beheren.

Sinds een aantal jaren kun je naast de regulier Fedora Workstation (en de spins daarvan) ook een radicaal andere versie van een Fedora desktop installeren: Fedora Silverblue.

Op een Silverblue systeem heb je niet één root filesysteem, maar meerdere. Updates werken dan ook niet op je live systeem, maar als overlays op een upstream image. Applicaties installeer je als het even kan via Flatpak, maar je mag ook zelf RPM pakketten laten layeren bovenop het basis image.

Met de release van OpenShift 4.13 is de support voor het gebruik van de nieuwste generatie Control Groups (cgroup v2) van Technology Preview (TP) naar General Availability (GA) gegaan. Wel staat de standaard instelling nog op de eerste generatie.

Met de release van OpenShift 4.13 is de Custom Metrics Autoscaler Operator gepromoveerd naar General Availability (GA). Met deze operator kun je het aantal replica’s van je deployments automatisch laten schalen aan de hand van CPU gebruik, geheugen gebruik, custom Prometheus metrics, of Kafka Queues (die laatste is wel nog Technology Preview).

De beste methode om naar een nieuwe major versie van Red Hat Enterprise Linux (RHEL) te migreren is met een schone installatie of een nieuw image. In een ideale wereld kun je dit zonder problemen met al je systemen doen, je custom software werkt gewoon, en al je machines zijn volledig met behulp van automation uitgerold en geconfigureerd. In de echte wereld heb je helaas echter altijd wel een paar machines die zoveel handwerk hebben gehad, of zo slecht gedocumenteerd zijn, dat dit niet mogelijk is.

Voor die gevallen is er sinds de release van RHEL8 wel een manier om in ieder geval je OS wel te kunnen upgraden naar een nieuwe versie, zonder een nieuwe installatie te moeten doen: Leapp

In een heterogene server omgeving wil je vaak dezelfde (soort) taken uitvoeren op machines die verschillende distributies draaien. Nu kun je hiervoor verschillende playbooks gebruiken, maar je kunt je playbooks ook slim hiermee om laten gaan en voor één doel ook één playbook gebruiken.

Bijna iedereen die met Bash werkt kent de magische variabele $? wel, met daarin de exit-code van je meest recente commando. Maar wist je dat ook de individuele exit-codes van de onderdelen van een pipeline kunt bekijken?

Vroeger was mounten “makkelijk”, je zette wat instellingen op wat regels in /etc/fstab, draaide mount -a, en hoopte dat het na een reboot ook nog werkte. Echte dependencies voor geneste mounts waren er niet, en alle dingen die je systeem nodig hadden om te draaien zoals /proc en /sys stonden er ook in.

Nu is dit voor eenvoudige dingen genoeg, maar zodra je ook mounts gaat toevoegen die wat moeizamer zijn, zoals mounts die netwerk nodig hebben, of die een harde afhankelijkheid hebben op een al reeds draaiende service, werdt het “interessant”, en dan niet op een leuke manier.

Ook kon een kleine typfout in een secundaire mount het hele boot proces van een systeem tegenhouden, met alle outages en andere lol van dien.

Met pasen hebben jullie alemaal mee kunnen doen met de jaarlijkse HCS Paas Puzzel, en dat hebben velen van jullie ook gedaan. Er is ondertussen een winnaar getrokken, en inzenden kan niet meer.

Vandaag loopt Wander voor degene die zijn vastgelopen op de puzzel over alle vragen heen, en laat zien waar je de antwoorden had kunnen vinden.

Podman Containers als systemd Units - Nieuwe Heetheid met Quadlet

In een vorige video hebben we al eens gekeken hoe je een systemd unit kan maken van een Podman container. De functionaliteit zoals daar beschreven werkt nog steeds, maar vanaf Podman 4.4 is er ook een makkelijkere methode met behulp van Quadlet.

Met de nieuwe manier kun je een systemd .container unit schrijven, die tijdens het opstarten van je systeem automagisch een .service unit genereert met de juiste instellingen.

Zoals elk jaar organiseert HCS Company ook dit jaar weer een leuke puzzel met Pasen. Dit jaar is het een quiz met twaalf vragen. Elk goed antwoord op een vraag brengt je vanzelf bij de volgende vraag. Hoe goed ken jij HCS, Open-Source, Memes, en je eigen browser?

De puzzel zelf kun je hier vinden, als je alle vragen goed hebt kom je vanzelf uit bij de instructies voor het insturen van je antwoord.

Onder de goede inzendingen verloten we een prachtige rugtas van Red Hat gevuld met HCS goodies. Inzenden kan tot vrijdag 14 April 2023. Inzendingen ontvangen na die datum dingen helaas niet meer mee naar de prijzen.

Op de commandline met podman containers werken kan waarschijnlijk net dat kleine beetje makkelijker dan je nu doet. In deze video laat Wander vier handige kleine trucjes zien die je leven net dat kleine beetje zullen verbeteren.

RHEL, en dus ook geralteerde distros als CentOS, Rocky, en Alma) hebben een beperkte, gecureerde, lijst aan pakketten die geïnstalleerd kunnen worden. Voor veel use-cases zal deze lijst genoeg zijn, maar in sommige gevallen wil een beheerder toch ent dat beetje meer hebben.

Wanneer je grote stukken output moet genereren vanuit je Python code kan het handig zijn om in plaats van f-strings (hoe leuk die ook zijn) een grotere template engine te gebruiken. Iets waarin je blokken kunt hergebruiken, loopjes kunt draaien, en zelfs wat logica kunt stoppen.

Ansible is een geweldige tool, maar versie verschillen tussen jouw versie van Ansible en die van je collega kunnen voor vervelende problemen zorgen, bijvoorbeeld als je nieuwere functionaliteit probeert te gebruiken dan wat de versie van Ansible van je collega ondersteunt.

Dit probleem wordt alleen nog maar erger als je ook gaat kijken naar de verschillende versies van geïnstalleerde collections, modules, en python dependencies. Gooi daar een sausje van benodigde systeem-pakketten (RPM, DPKG, etc.) overheen, en je eindigt al snel met een “Op mijn machine werkte het wel..” scenario.

De API servers op Kubernetes clusters (en dus ook OpenShift) zijn gelimiteerd op het aantal acties dat ze gelijktijdig uit willen voeren. Kom je hierboven, dan zegt de API server gewoon “NEE”.

Sinds Kubernetes 1.20 kun je daarentegen wel bepalen hoe belangrijk dingen zijn. Want: Alle API requests zijn gelijk, maar sommige API requests zijn gelijker dan anderen. Wel is het natuurlijk noodzakelijk dat we wel alle soorten requests worden afgehandeld, we moeten wel eerlijk blijven…

Wanneer je applicatie teams op je OpenShift cluster toelaat, en die gaan gebruik maken van BuildConfigs en/of DeploymentConfigs, dan zou het zomaar kunnen dat er niet netjes wordt opgeruimd. Deze objecten laten vaak artefacten performance van je cluster negatief kan beïnvloeden.

Virtueel Kaal Ijzer met Sushy Tools

In sommige gevallen kan het handig zijn om een virtuele machine te kunnen behandelen alsof het BareMetal is. Denk bijvoorbeeld aan het testen van provisioning scripts met Ansible, of aan het ontwikkelen van automation rondom OpenShift installaties.

In het verleden kon je dit bijvoorbeeld doen met VirtualBMC, maar met een paar beperkingen:

• Iedere VM had een eigen netwerk poort nodig, en moest apart geconfigureerd worden
• Beperkt tot het IPMI protocol (dus geen upload van virtuele media)

Tegenwoordig kun je ook sushy-emulator gebruiken van het sushy-tools project. Deze spreekt geen IPMI, maar RedFish, een modernere standaard waar je bijvoorbeeld wel virtuele media mee kunt laden. Ook heb je maar een enkele instantie nodig per hypervisor, die automatisch alle draaiende LibVirt machines ontdekt en beschikbaar maakt.

Sinds python 3.5 kun je in je python code gebruik maken van “Type Hints”, een manier om aan je IDE/Linter/etc. kenbaar te maken welke type je verwacht als functie parameters, en wat voor een type je teruggeeft als functie/methode.

De python runtime doet niks met deze types, maar je ontwikkel omgeving kan deze hints gebruiken om je te helpen (mogelijke) problemen op te sporen voordat ze voor ellende zorgen.

In deze video laat Wander een simpel voorbeeld zien met behulp van Codium, de volledig Open Source versie van VSCode.

In een Multi-Tenant OpenShift (of standaard Kubernetes) omgeving wil je als beheerder je eindgebruikers soms de vrijheid geven om zelf Project(Requests)s of Namespaces aan te maken, maar wwel binnen vastomlijnde naamgevings protocollen. In het verleden hebben we al eens gekeken hoe je dit met OPA Gatekeeper kunt doen, en hoe je zelf een Validating of Mutating Admission Webhook kunt maken. Dit keer kijken we hoe je dit met Kyverno kunt doen.

Een filesysteem op Linux heeft geen rechtstreekse koppeling tussen een bestandsnaam en de inhoud van dat bestand. In plaats daarvan wordt er gebruik gemaakt van een systeem van dentries en inodes.

In veel gevallen wil je voor je databases bij je Cloud Native applicaties een externe database gebruiken, of iets op een groot database cluster in je datacenter, of iets gemanaged door je cloud provider. Maar er zijn ook veel gevallen waarin je zelf meer controle wilt over de databases, of waar het extern afnemen niet kan of niet handig is. In die gevallen kun je zelf je databases hosten in je Kubernetes/OpenShift cluster.

Zoals ondertussen traditie is hadden we ook afgelopen kest weer een puzzel voor jullie. In deze video laat Wander zien hoe je deze had kunnen oplossen, en welke rode haringen we verstopt hadden in deze puzzel.

Wil je de puzzel zelf proberen zonder eerst naar de oplossing te kijken? Spelen kan nog steeds hier, maar de inzendtermijn is helaas wel al verstreken.

Sinds RHEL9 heeft de standaard .bashrc voor nieuwe gebruikers een trucje geleerd: Het laden van bestanden uit de ~/.bashrc.d directory.

Hiermee is het mogelijk om geen custom monolithisch .bashrc bestand meer bij te houden, met alle nare neveneffecten van dien wanneer je gaat automatiseren, maar om over te stappen op een modulair systeem, waarbij je gewoonweg de goede bestanden voor de gewenste functionaliteit kopieert naar de juiste systemen.

Wanneer je in Python een commandline tooltje bouwt, en je behoeftes voor het parsen van opties en argumenten meer wordt dan alleen maar wat argumenten lezen, zul je al snel een library gaan zoeken die daar bij kan helpen.

De twee standaard opties zijn argparse en optparse, maar er zijn ook libraries die meer kunnen, en makkelijker zijn in het gebruik.

Zoals ondertussen bijna traditie is geworden biedt HCS Company jullie ook dit jaar weer een leuke Kerst Puzzel aan. Je kunt hem spelen op https://kerstpuzzel2022.hcs-company.com/.

Nieuw dit jaar is de kleurwedstrijd die op dezelfde site te vinden is.

In een vorige video hebben we gekeken hoe je namespaces kunt beheren met behulp van GitOps methodologieën. Deze week gaan we hierop verder bouwen en gaan we ook (Cluster)ResourceQuotas introduceren.

In het verleden hebben we op dit kanaal al vaker gekeken naar het managen van namespaces voor applicatie-teams op Kubernetes en OpenShift clusters. Deze keer kijken we naar hetzelfde probleem, maar pakken we het op een GitOps methode aan.

Sinds enige jaren heeft de RHEL familie van distributies een krachtige web-based management tool: Cockpit

De afgelopen jaren heeft OpenShift voor de logging stack standaard gebruik gemaakt van de EFK stack (ElasticSearch, FluentD, Kibana). Tegenwoordig kunnen cluster beheerders er ook voor kiezen om LokiStack voor de logging te gebruiken.

Als je op OpenShift User Workload Monitoring hebt aangezet kunnen ontwikkelaars wel custom metrics laten ophalen en opslaan, en ze uitvragen via de OpenShift Web Console, maar complexere dashboards zijn (nog) niet in de console mogelijk.

Gelukkig is het wel mogelijk om via de community Grafana Operator deze metrics ook uit te vragen, en via dashboards inzichtelijk te maken. Wel loop je dan tegen het probleem aan dat als je dit via de reguliere instantie van Thanos Querier wilt doen het een alles-of-niks spel wordt: Of je hebt geen toegang tot metrics, of je mag bij alle metrics van het cluster en alle applicaties.

Ook dat laatste probleem kan opgelost, door de speciale tenancy poort van Thanos Querier te gebruiken, waarbij je per query metrics voor één namespace tegelijk mag opvragen, mits je rechten hebt op die namespace.

In OpenShift is een monitoring stack aanwezig, gebaseerd op Prometheus, die standaard al erg veel rijk metrics verzamelt over allerlei onderdelen van je platform. Zo kunnen applicatie-teams hier al standaard van alles in over vinden over het geheugen-, CPU-, disk-, en netwerk-gebruik van hun applicaties.

Wanneer een team hun applicatie wil verrijken met custom metrics dan kan dat ook, maar hier moeten wel zowel aan de platform kant als aan de applicatieve kant een aantal dingen voor gedaan worden.

Om verkeer van buiten een Kubernetes/OpenShift cluster in te krijgen heb je waarschijnlijk een LoadBalancer nodig, om bijvoorbeeld je Ingress te ontsluiten, of om services rechtstreeks aan te bieden.

Wanneer je in een cloud omgeving draait biedt je provider waarschijnlijk loadbalancers aan die rechtstreeks door je cluster aangestuurd kunnen worden, maar wanneer je op Baremetal draait, of op LibVirt, of op VMWare, dan missen deze opties.

Op een Kubernetes cluster (dus ook OpenShift) kun je je pods bereikbaar maken met Service objecten. Deze objecten kunnen verschillende types hebben, headless, ClusterIP, NodePort, LoadBalancer, en ExternalName.

Wanneer je een OpenShift cluster aan een (of meerdere) externe authenticatie bronnen hebt gekoppeld is het fijn als je ook de groepen die gedefinieerd staan in die externe bronnen zou kunnen gebruiken.

Bij het gebruik van OpenID Connect providers wordt dit automatisch voor je gedaan, maar voor andere providers zul je zelf wat moeten doen.

Het uitrollen (installeren, configureren, integreren) van een OpenShift cluster in een Enterprise omgeving kan een flinke uitdaging zijn. Bij HCS zijn we die uitdaging al vele malen en bij vele klanten aangegaan. Één van de tools die we daar bijna altijd bij gebruiken is onze eigen HCS OpenShift Installer, een set van playbooks die het uitrollen en configureren in een enterprise omgeving makkelijker, en consistenter, maakt.

Veel beheerders gebruiken de tool/programmeertaal awk niet, of niet zo goed als ze zouden kunnen. Om daar verandering in te brengen laat Wander in deze video wat voorbeelden zien van een makkelijk te gebruiken functionaliteit die je scripts beter kan maken.

Soms is het handig om de maximale throughput tussen twee machines op je netwerk te testen. In dat geval kun je op Linux systemen vertrouwen op het tooltje iperf3, een manier om netwerk throughput te meten over TCP, UDP, en SCTP.

Sinds kort heeft het podman project een nieuwe applicatie erbij: Podman Desktop. Deze kan gebruikt worden als vervanging voor Docker Desktop, maar dan als pure open-source. Podman Desktop is beschikbaar als Flatpak voor Linux systemen, en als installer for Windows en macOs systemen.

Als je op Kubernetes requests en limits zet op een pod, doet dit op het onderliggende OS hele interessante dingen om je instellingen te garanderen. In deze video laat Wander (in vogelvlucht) zien hoe CPU en geheugen requests en limits worden omgezet naar CGroup instellingen naar de per-pod slices die worden aangemaakt.

Zodra je Ansible playbooks wat interessanter worden kom je al snel op het punt waarbij je minimaal één van de volgende punten tegenkomt:

• Je wilt een bepaalde taak maar één keer uitvoeren, dus niet op alle hosts
• Je wilt een bepaalde taak op een andere host uitvoeren dan de host die het doelwit is van je play
• Je wilt een aantal taken achter elkaar uitvoeren op één host, voordat het play doorgaat naar de volgende host.

In veel gevallen is het nuttig om in je Ansible playbooks bepaalde acties te laten afhangen van het wel of niet iets gewijzigd hebben in een vorige stap. Zo kun je bijvoorbeeld het laten herstarten van een Web server laten afhangen van het gewijzigd zijn van een configuratie.

Bij het werken op de command (CLI) is het soms iets te makkelijk om vertrouwelijke te lekken. Dit kan zijn via gevoelige informatie op de commandline zelf, die ook nog eens in je history kan worden opgeslagen, of zelfs via het simpelweg bestaan van een proces van een bepaalde gebruiker.

Sinds enige tijd heeft het Linux kernel een ingebouwde VPN mogelijkheid die het mogelijk maakt om redelijk gemakkelijk een veilig, en snel, VPN op te zetten: WireGuard.

Sinds kort is het mogelijk om op OpenShift Sandboxed Containers te draaien, containers die niet het kernel delen met de rest van de containers op een systeem, maar containers die draaien met hun eigen kernel, in hun eigen virtuele machine.