From af9aeeee3c5f4f659bb31addeba468bd58c881a9 Mon Sep 17 00:00:00 2001 From: Marcus Fihlon Date: Sun, 24 Mar 2024 19:29:20 +0100 Subject: [PATCH] =?UTF-8?q?=E2=9C=A8=20import=20sessions=20from=20DOAG?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Marcus Fihlon --- pom.xml | 5 + .../swiss/fihlon/apus/conference/Session.java | 22 + .../conference/SessionImportException.java | 26 + .../apus/conference/doag/ConferenceAPI.java | 98 + .../fihlon/apus/conference/doag/Schedule.java | 21 + .../conference/doag/ConferenceAPITest.java | 37 + src/test/resources/DOAG.json | 5756 +++++++++++++++++ 7 files changed, 5965 insertions(+) create mode 100644 src/main/java/swiss/fihlon/apus/conference/Session.java create mode 100644 src/main/java/swiss/fihlon/apus/conference/SessionImportException.java create mode 100644 src/main/java/swiss/fihlon/apus/conference/doag/ConferenceAPI.java create mode 100644 src/main/java/swiss/fihlon/apus/conference/doag/Schedule.java create mode 100644 src/test/java/swiss/fihlon/apus/conference/doag/ConferenceAPITest.java create mode 100644 src/test/resources/DOAG.json diff --git a/pom.xml b/pom.xml index c735efa..b717d6c 100644 --- a/pom.xml +++ b/pom.xml @@ -155,6 +155,11 @@ 4.8.3 true + + org.json + json + 20240303 + org.springframework.boot spring-boot-starter-test diff --git a/src/main/java/swiss/fihlon/apus/conference/Session.java b/src/main/java/swiss/fihlon/apus/conference/Session.java new file mode 100644 index 0000000..4d1b6c7 --- /dev/null +++ b/src/main/java/swiss/fihlon/apus/conference/Session.java @@ -0,0 +1,22 @@ +/* + * Apus - A social wall for conferences with additional features. + * Copyright (C) Marcus Fihlon and the individual contributors to Apus. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +package swiss.fihlon.apus.conference; + +import java.time.LocalDateTime; + +public record Session(String id, LocalDateTime date, String title, String speaker) { } diff --git a/src/main/java/swiss/fihlon/apus/conference/SessionImportException.java b/src/main/java/swiss/fihlon/apus/conference/SessionImportException.java new file mode 100644 index 0000000..d44e03d --- /dev/null +++ b/src/main/java/swiss/fihlon/apus/conference/SessionImportException.java @@ -0,0 +1,26 @@ +/* + * Apus - A social wall for conferences with additional features. + * Copyright (C) Marcus Fihlon and the individual contributors to Apus. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +package swiss.fihlon.apus.conference; + +import org.jetbrains.annotations.NotNull; + +public class SessionImportException extends RuntimeException { + public SessionImportException(@NotNull final Exception e) { + super(e); + } +} diff --git a/src/main/java/swiss/fihlon/apus/conference/doag/ConferenceAPI.java b/src/main/java/swiss/fihlon/apus/conference/doag/ConferenceAPI.java new file mode 100644 index 0000000..3040584 --- /dev/null +++ b/src/main/java/swiss/fihlon/apus/conference/doag/ConferenceAPI.java @@ -0,0 +1,98 @@ +/* + * Apus - A social wall for conferences with additional features. + * Copyright (C) Marcus Fihlon and the individual contributors to Apus. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +package swiss.fihlon.apus.conference.doag; + +import org.jetbrains.annotations.NotNull; +import org.springframework.boot.configurationprocessor.json.JSONArray; +import org.springframework.boot.configurationprocessor.json.JSONException; +import org.springframework.boot.configurationprocessor.json.JSONObject; +import swiss.fihlon.apus.conference.Session; +import swiss.fihlon.apus.conference.SessionImportException; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.StandardCharsets; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public final class ConferenceAPI { + + private final String location; + + public ConferenceAPI(@NotNull final String location) { + this.location = location; + } + + public List getSessions() { + final ArrayList sessions = new ArrayList<>(); + try { + final String json = getJSON(); + final JSONObject jsonObject = new JSONObject(json); + final JSONObject schedule = jsonObject.getJSONObject("schedule"); + final JSONObject conference = schedule.getJSONObject("conference"); + final String acronym = conference.getString("acronym"); + final JSONArray days = conference.getJSONArray("days"); + for (int dayCounter = 0; dayCounter < days.length(); dayCounter++) { + final JSONObject day = days.getJSONObject(dayCounter); + final LocalDate date = LocalDate.parse(day.getString("date")); + final JSONObject rooms = day.getJSONObject("rooms"); + final Iterator roomKeys = rooms.keys(); + while (roomKeys.hasNext()) { + final String roomKey = roomKeys.next(); + final JSONArray slots = rooms.getJSONArray(roomKey); + for (int slotCounter = 0; slotCounter < slots.length(); slotCounter++) { + final JSONObject slot = slots.getJSONObject(slotCounter); + final String type = slot.getString("type"); + if (!"lecture".equalsIgnoreCase(type)) { + continue; + } + final LocalTime time = LocalTime.parse(slot.getString("start")); + final JSONArray persons = slot.getJSONArray("persons"); + final ArrayList speakers = new ArrayList<>(persons.length()); + for (int personCounter = 0; personCounter < persons.length(); personCounter++) { + final JSONObject person = persons.getJSONObject(personCounter); + final String publicName = person.getString("public_name"); + speakers.add(publicName); + } + final Session session = new Session( + String.format("%s:%d", acronym, slot.getInt("id")), + LocalDateTime.of(date, time), + slot.getString("title"), + String.join(", ", speakers)); + sessions.add(session); + } + } + } + } catch (IOException | URISyntaxException | JSONException e) { + throw new SessionImportException(e); + } + return sessions; + } + + private String getJSON() throws IOException, URISyntaxException { + try (InputStream in = new URI(location).toURL().openStream()) { + return new String(in.readAllBytes(), StandardCharsets.UTF_8); + } + } +} diff --git a/src/main/java/swiss/fihlon/apus/conference/doag/Schedule.java b/src/main/java/swiss/fihlon/apus/conference/doag/Schedule.java new file mode 100644 index 0000000..b860a91 --- /dev/null +++ b/src/main/java/swiss/fihlon/apus/conference/doag/Schedule.java @@ -0,0 +1,21 @@ +/* + * Apus - A social wall for conferences with additional features. + * Copyright (C) Marcus Fihlon and the individual contributors to Apus. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +package swiss.fihlon.apus.conference.doag; + +public record Schedule(String baseUrl) { +} diff --git a/src/test/java/swiss/fihlon/apus/conference/doag/ConferenceAPITest.java b/src/test/java/swiss/fihlon/apus/conference/doag/ConferenceAPITest.java new file mode 100644 index 0000000..53eb772 --- /dev/null +++ b/src/test/java/swiss/fihlon/apus/conference/doag/ConferenceAPITest.java @@ -0,0 +1,37 @@ +/* + * Apus - A social wall for conferences with additional features. + * Copyright (C) Marcus Fihlon and the individual contributors to Apus. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +package swiss.fihlon.apus.conference.doag; + +import org.junit.jupiter.api.Test; +import swiss.fihlon.apus.conference.Session; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class ConferenceAPITest { + + @Test + void importViaHttps() { + final String location = "file:src/test/resources/DOAG.json"; + final ConferenceAPI conferenceAPI = new ConferenceAPI(location); + final List sessions = conferenceAPI.getSessions(); + assertEquals(159, sessions.size()); + } + +} diff --git a/src/test/resources/DOAG.json b/src/test/resources/DOAG.json new file mode 100644 index 0000000..f2b3c25 --- /dev/null +++ b/src/test/resources/DOAG.json @@ -0,0 +1,5756 @@ +{ + "schedule": { + "base_url": "https://meine.doag.org/", + "conference": { + "acronym": "CL_2023", + "title": "CloudLand 2023 - Das Cloud Native Festival", + "start": "2023-06-20", + "end": "2023-06-23", + "daysCount": 4, + "timeslot_duration": "00:01", + "time_zone_name": "Europe/Berlin", + "days": [ + { + "index": 1, + "date": "2023-06-20", + "day_start": "2023-06-20T09:45:00+02:00", + "day_end": "2023-06-20T10:30:00+02:00", + "rooms": { + "Community Hall": [ + { + "id": 2706, + "date": "2023-06-20T09:45:00+02:00", + "start": "09:45", + "duration": "00:15", + "room": "Community Hall", + "title": "Warm Opening", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2706", + "track": "noMainfocus", + "language": "de", + "abstract": "Beim Warm Opening möchten wir allen die Gelegenheit geben, bei Kaffee und Snacks erstmal in Ruhe anzukommen und einen ersten Austausch mit alten und neuen Bekannten zu ermöglichen. Der Enthusiasmus und die Vorfreude werden bei den ersten Gesprächen spürbar. Die Energie und Dynamik, die beim Warm Opening entstehen, werden dann ins CloudCamp übertragen. Wir freuen uns über Gruppen, die über gemeinsame Interessen und Herausforderungen sprechen und Lösungen finden. ", + "persons": [ + { + "id": 17, + "public_name": "Fried Saacke" + }, + { + "id": 6970, + "public_name": "André Sept" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [], + "featureTags": [] + }, + { + "id": 2707, + "date": "2023-06-20T10:00:00+02:00", + "start": "10:00", + "duration": "00:30", + "room": "Community Hall", + "title": "Begrüßung und Eröffnung des CloudCamps", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2707", + "track": "noMainfocus", + "language": "de", + "abstract": "Fried Saacke, Geschäftsführer der DOAG Dienstleistungen GmbH und André Sept, Vorstand der DOAG und Leiter der Deutschsprachigen Cloud Native Community, werden mit ein paar einleitenden Worten das CloudCamp eröffnen. ", + "persons": [ + { + "id": 17, + "public_name": "Fried Saacke" + }, + { + "id": 6970, + "public_name": "André Sept" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [], + "featureTags": [] + } + ] + } + }, + { + "index": 2, + "date": "2023-06-21", + "day_start": "2023-06-21T10:30:00+02:00", + "day_end": "2023-06-21T23:00:00+02:00", + "rooms": { + "Schauspielhaus ": [ + { + "id": 2302, + "date": "2023-06-21T19:00:00+02:00", + "start": "19:00", + "duration": "00:45", + "room": "Schauspielhaus ", + "title": "KEYNOTE: Hack the world a better place", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2302", + "track": "noMainfocus", + "language": null, + "abstract": "

Wir sehen, dass junge Menschen heute zwar oft digitale Technik gut anwenden können, aber kaum wissen, wie sie hier steuernd aktiv werden können. Oft herrschen große Berührungsängste und die wenigsten – vor allem Mädchen - trauen sich zu, einfach zu versuchen, mal zu programmieren. Das wollen wir ändern – in Kooperation mit engagierten Unternehmen. Wir begeistern Kinder und Jugendliche für Programmieren und wecken ihr Interesse für Zukunftsberufe. Parallel vermitteln wir ihnen die nötigen skills. Die Zukunft ist das, was wir gemeinsam daraus machen.


“In unserer zunehmend digitaleren Welt ist es wichtig, die Jugend durch gemeinsames Engagement mit den skills für das 21. Jahrhundert zu versorgen.”


Über Frau Dr. Julia Freudenberg: 

​​​​​​​Nach langjähriger Erfahrung in der Wirtschaft übernahm Dr. Julia Freudenberg 2017 die Leitung der Hacker School. Vision der gemeinnützigen Organisation ist es, die Jugend für das Programmieren zu begeistern. Die überzeugte Netzwerkerin arbeitet an engmaschigen Kooperationen der Hacker School mit Unternehmen sowie ehrenamtlichen und hauptamtlichen Initiativen im IT-Bereich. Als Mitglied im “Beirat Junge Digitale Wirtschaft” berät sie das Wirtschaftsministerium, ist selbst ehrenamtlich aktiv und glückliche Mutter zweier Kinder.

", + "persons": [ + { + "id": 43522, + "public_name": "Julia Freudenberg" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + } + ], + "MediaMarktSaturn Lounge": [ + { + "id": 2324, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "MediaMarktSaturn Lounge", + "title": "JUG Oberland: CloudLand plays! - Einführung in das Spiel", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2324", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Auf einem Bildschirm lassen wir eine Anwendung laufen, die wir - inspiriert von \"Twitch plays Pokémon\" - geschrieben haben.

Das Prinzip von twitch plays basiert darauf, dass jede(r) Befehle an das Spiel (voraussichtlich ein Retro-Game wie Pokémon Rote Edition) senden kann und diese dann nacheinander abgearbeitet werden. Dadurch können alle Teilnehmenden der CloudLand über die gesamte Konferenz verteilt gemeinsam spielen.

Wer mitmachen möchte, scannt einen QR Code und gelangt auf eine Website, über die er Befehle an das Spiel schicken kann. Dies können beliebig viele Leute gleichzeitig und immer mal wieder machen - es bietet sich also zum Beispiel für Pausenzeiten an.
​​​​​​​
Die API wird öffentlich zur Verfügung gestellt, so dass die Teilnehmenden sogar eigene Bots oder ähnliches schreiben können.

Wollt ihr die CloudLand plays! während der CloudLand verfolgen, empfiehlt es sich an diesem Vortrag teilzunehmen, der euch in das Spiel einführt

", + "persons": [ + { + "id": 15054, + "public_name": "Igor Gutmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2544, + "date": "2023-06-21T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "MediaMarktSaturn Lounge", + "title": "Sponsored Session: DevOps im Enterprise Umfeld - Kultur, Tech, Orga, Teil 2", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2544", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Fortsetzungen (Ausdetaillierungen) zu: https://shop.doag.org/events/cloudland/2023/agenda/#agendaId.2325


DevOps in Enterprise-Umgebungen wird oft als \"AntiPattern\" dargestellt. Es heißt, DevOps in großen Umgebungen funktioniert einfach nicht, und teilweise stimmt diese Behauptung auch. Ich möchte euch in diesem Talk zeigen, wie jede Hierarchie in einer Enterprise-Umgebung ihren Teil zum Gelingen der DevOps-Strategie beitragen kann - mit einer Betrachtung der drei wesentlichen Säulen einer jeden DevOps-Strategie: Kultur, Organisation und Technologie.

", + "persons": [ + { + "id": 20932, + "public_name": "David König" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [ + "eventslot_cross-channel_topic_devops" + ], + "difficulty": [], + "featureTags": [] + }, + { + "id": 2326, + "date": "2023-06-21T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "MediaMarktSaturn Lounge", + "title": "JUG Nürnberg: Kubernetes-Deployment Step-by-Step", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2326", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Du benutzt in deinem Projekt kein Kubernetes oder hast schon länger keinen Blick mehr in das Deployment-Skript geworfen?

Im Alltag hat man oft nicht direkt mit Kubernetes zu tun, deshalb wollen wir uns in diesem Workshop die Zeit nehmen, um Schritt für Schritt eine Anwendung zu deployen und uns auf die Basics zu konzentrieren. Fast schon eine Cloud-Kata also, geeignet für alle, die Kubernetes einmal ausprobieren oder ihr Wissen auffrischen möchten.

Wir betrachten zuerst kurz die Komponenten von Kubernetes und einige Kubernetes-Objekte wie Pods, Deployments und Services. Anschließend erstellen wir einen lokalen Cluster, in den wir eine Demo-Anwendung deployen.

Das Ganze ist als Hands-on Übung gedacht, deshalb bring bitte einen Laptop mit installiertem Docker mit.

Und für die Unentschlossenen, hier unser ultimatives \"Ist dieser Workshop für mich?\"-Quiz:

Service, Pod, Deployment, Scheduler, Kubelet sagen dir etwas?
…. Nicht wirklich. -> Komm zum Workshop!
…. Ja, aber die genauen Zusammenhänge, ähm… -> Komm zum Workshop!
…. Aber klar doch, da kenn ich mich voll aus!
……. -> Hast du Lust, das Ganze mal wieder Hands-On zu nutzen?
…………. Ja klar, los geht’s. -> Komm zum Workshop!
…………. Nein, heute nicht so. -> Einer der anderen Beiträge taugt dir wahrscheinlich besser, beim nächsten Mal dann ;)


", + "persons": [ + { + "id": 39731, + "public_name": "Tanja Gallmann" + }, + { + "id": 15054, + "public_name": "Igor Gutmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2327, + "date": "2023-06-21T14:00:00+02:00", + "start": "14:00", + "duration": "00:105", + "room": "MediaMarktSaturn Lounge", + "title": "\"Don't Panik!\" - ein Hitchhiker's Guide durch das Requirement Engineering ", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2327", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "\"Es gibt nur eine Regel, wenn es um Anforderungsmanagement geht: habe immer ein Handtuch dabei!\" So oder so ähnlich sagt das Ford Prefect aus \"Per Anhalter durch die Galaxis\". In diesem Workshop werden wir uns mit Themen wie Requirement Management, Strukturieren von Tickets und der Erarbeitung von Anforderungen von der Initiative bis zur Umsetzung beschäftigen. Wie Arthur Dent sagt: \"Ich habe das Gefühl, dass ich in einem Alptraum gefangen bin\". Aber keine Angst, wir werden dir Methoden vermitteln, die dir helfen werden, deine Anforderungen erfolgreich zu verwalten und deine Fähigkeiten im Anforderungsmanagement zu verbessern.", + "persons": [ + { + "id": 24479, + "public_name": "Stephan Tönnies" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2329, + "date": "2023-06-21T16:00:00+02:00", + "start": "16:00", + "duration": "00:165", + "room": "MediaMarktSaturn Lounge", + "title": "IT-Security Capture the Flag: Hack den OWASP JuiceShop", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2329", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Der typische TV-Hacker sitzt im Dunkeln mit Hoodie vor dem Laptop und kann in wenigen Sekunden die NSA hacken. Aber wie sieht die Realität aus und warum solltest du als Cloud Native Entwickler das wissen?

Das Schlagwort „Hacken“ steht für das Finden und Ausnutzen von Schwachstellen in Software. Das Ziel ist der Zugriff oder die Manipulation sensibler Informationen und fremder Rechner, was schwerwiegende Folgen haben kann. Diese Session zeigt die kreative Sichtweise eines Hackers und sensibilisiert für typische Schwachstellen in Anwendungen.


Als Anschauungsobjekt dient der OWASP JuiceShop. Der Name “JuiceShop” ist eine wörtliche Übersetzung des deutschen “Saftladens”. Es ist eine moderne eCommerce Angular WebApp und einem node.js Backend die absichtlich jede Schwachstelle hat die man sich vorstellen kann.


Ablauf:

- Kurze Einführung in OWASP JuiceShop & Capture The Flag  
- Vorstellung von Pentesting-Tools, die beim Lösen der Challenges helfen

- Demo: Lösen der ersten Challenge
- Bilden von kleinen Teams, die miteinander im Wettbewerb stehen

- Betreutes lösen der Challenges


Die Teams können bis Freitag um 15:00 Uhr hacken. Dann ziehen wir Bilanz und um 16:00 werden die Gewinner geehrt.


Ihr habt Blut geleckt? Verpasst nicht unser Hack-Together am Folgetag.

", + "persons": [ + { + "id": 41911, + "public_name": "Daniel Klinger" + }, + { + "id": 41545, + "public_name": "Simon Trockel" + }, + { + "id": 42018, + "public_name": "Tobias Heide" + }, + { + "id": 26554, + "public_name": "Bernd Stübinger" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + } + ], + "Stage 2": [ + { + "id": 2541, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Cloud Native Customer Stories: Lerncoach - Kür oder Pflicht?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2541", + "track": "Customer Stories", + "language": "de", + "abstract": "

Lebenslanges Lernen ist in unserer Branche Standard, aber wir erleben gerade eine Beschleunigung des Transformationsprozesses, der das Thema Lernen nochmal ganz anders fordert. In der flexiblen Einheit, in der ich Lerncoach bin, toppen wir das Ganze nochmal, indem die Teams alle drei Monate ein neues Arbeitspaket aus dem Haus bekommen.

Sprich: Alle drei Monate neue Technologieanforderungen erfordern schnellen Kompetenzaufbau auch in bislang unbekannten Bereichen. Und zwar so, dass man innerhalb der drei Monate das neue Wissen wirksam anwenden kann.

Mein Job ist es, die Teams beim Erwerb der Skills zu unterstützen. Ihr bekommt einen Einblick wie ich in dieser Situation unterstütze und wie ich versuche, ein angenehmes Lernumfeld zu schaffen.

", + "persons": [ + { + "id": 21533, + "public_name": "Jürgen Latteyer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2542, + "date": "2023-06-21T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Enterprise-level Kubernetes Security mit Open Source Tools - geht das?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2542", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Ein Kubernetes Cluster ist heutzutage schnell aufgesetzt: ob mit Installationsplattformen wie Rancher oder in der Public Cloud als Managed Service wie AWS EKS. Doch die größten Probleme ergeben sich im aktiven Betrieb des Clusters. Im Enterprise-Umfeld hat die Konzern-Security sehr viele Anforderungen an den Cluster, ohne die ein Produktiveinsatz nicht möglich ist.


Es stellt sich nun die Frage: Brauche ich Enterprise-Versionen von Security Tools oder gibt es auch gute Open Source Tools, die all meine Anforderungen erfüllen?

In meinem Talk möchte ich eine Übersicht über die State-of-the-Art Open Source Tools für verschiedene Kubernetes-Security-Themen geben und zeigen, inwieweit sie allgemeine Enterprise-Anforderungen erfüllen.


Die Themen sind unter anderem:

- Signierung von Container Images
- Mutual TLS zwischen Microservices
- Container und Application Vulnerability Scanning
- Cluster Runtime Security
- Governance durch Policies
​​​​​​​
Dabei ergänze ich jede Vorstellung der Tools mit Erfahrungen und Best Practices aus dem Projektalltag und zeige die Limitierungen der Tools auf.

", + "persons": [ + { + "id": 41621, + "public_name": "Markus Zimmermann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2543, + "date": "2023-06-21T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Die Top Ten der Cloud Security Fails und wie man sie vermeidet", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2543", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Fehler in der Konfiguration von Cloud Services sind eine neue und noch zu wenige beachtete Quelle für Schwachstellen. Auch diese Schwachstellen können gravierende Folgen haben, dementsprechend benötigen Cloud-basierte Umgebungen eine regelmäßige und unabhängige Überprüfung. Im Rahmen dieser Cloud Security Audits prüfen wir seit vielen Jahren die Konfiguration der Cloud-Umgebungen unserer Kunden.

Wir wollen unsere Erfahrungen und Best Practices teilen und diskutieren. Was sind die häufigsten und wichtigsten Konfigurationsfehler bei AWS, Azure und GCP? Wie lassen sie sich vermeiden? Wir geben praxisnahe Tipps und einen Einblick in unsere Werkzeuge und wie wir arbeiten. Mit diesem Wissen lassen sich nicht nur Schwachstellen vermeiden, auch das nächste Audit bringt weniger Findings und damit weniger zusätzliche Arbeit.

", + "persons": [ + { + "id": 42051, + "public_name": "Kai Schubert" + }, + { + "id": 42158, + "public_name": "Phillip Ansorge" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2325, + "date": "2023-06-21T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Wir bauen gemeinsam einen Fragenkatalog, der uns hilft rauszufinden, wie DevOps wir sind", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2325", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "Wenn mit Teams über den \"DevOps Reifegrad\" gesprochen wird, dann sind das oft stundenlange Interviews. \r\nDiese Interviews und der persönliche Kontakt sind nach wie vor wichtig, aber lassen sich viele Informationen nicht standardisiert erheben? Das Nachhalten, Vergleichen und Prüfen von Veränderung sind weitere wichtige Aspekte.\r\n\r\nIn dieser Session wollen wir mit Euch zusammen das kollektive Wissen wie auch individuellen Erfahrungen nutzen, um einen Fragenkatalog zum Ermitteln des DevOps Reifegrades eines Teams zu erstellen. \r\n\r\nNatürlich existieren bereits DevOps Reifegrad Modelle, unser Arbeitsergebnis wird beim Einordnen helfen. \r\nVom Ergebnis des Workshops, das Euch im Anschluss als Conceptboard zur Verfügung steht, profitieren alle, der Austausch bereichert die Beteiligten.", + "persons": [ + { + "id": 41345, + "public_name": "David Koenig" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [], + "featureTags": [] + }, + { + "id": 2559, + "date": "2023-06-21T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 2", + "title": "A Hitchhikers Guide to the Cloud Friendly Migration of Apache Solr", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2559", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "This talk will cover the process of migrating a large-scale, multi-language Apache Solr infrastructure from on-premise servers to AWS cloud infrastructure. The presentation will detail the challenges and best practices involved in the migration, including considerations for instance sizing, data transfer, configuring autoscaling and load balancing, while maintaining optimal search performance. The talk will also highlight the benefits of the migration, including increased scalability, cost savings, and improved disaster recovery capabilities. Real-world examples will be used to illustrate the process, building blocks and tools used during the migration and the talk will conclude with a discussion of future optimizations.", + "persons": [ + { + "id": 16570, + "public_name": "Mario-Leander Reimer" + }, + { + "id": 42151, + "public_name": "Wolfgang Klimt" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2546, + "date": "2023-06-21T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Cloud Native CQRS", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2546", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

CQRS und Event Sourcing sind Muster, die zwar schon länger bekannt sind, aber gerade im Umfeld von Microservices und Cloud-native-Architekturen wieder populärer werden. Die Kombination aus CQRS und ES verspricht dabei eine hohe Skalierbarkeit und eine einfache Erweiterbarkeit des Systems.

Allerdings liegen gerade in der event-basierten Natur dieser Architektur einige Herausforderungen: Commands müssen konsistent und gegebenenfalls in der korrekten Reihenfolge verarbeitet werden. Die daraus resultierenden Änderungen sollten dann effizient abrufbar sein. Man ist also gut beraten, wenn man diese Muster nicht selbst implementiert, sondern sich auf etablierte Frameworks aus diesem Bereich verlässt, die einem viele Probleme aus den Bereichen Message Routing und Eventual Consistency abnehmen.

Trotzdem stellen sich viele Fragen, wenn man eine CQRS/ES-basierte Anwendung cloud-native umsetzen will: Wie könnte eine solche Anwendung in einer Cloud-native-Umsetzung aussehen? Auf was muss ich bei der Containerisierung achten? Kann ich meine Anwendung serverless betreiben? In dieser Session wollen wir von unseren Erfahrungen berichten, die wir bei der Umsetzung einer cloud-nativen Java-Anwendung mit einer CQRS/ES-basierten Architektur gemacht haben.

", + "persons": [ + { + "id": 38516, + "public_name": "Frank Steimle" + }, + { + "id": 24206, + "public_name": "François Fernandes" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2547, + "date": "2023-06-21T17:00:00+02:00", + "start": "17:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Idempotenz für Arme. Oder: Was machen wir nach 'Lift und Shift'?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2547", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

In vielen Fällen stellt für existierende Anwendungen das sogenannte 'Lift und Shift'-Verfahren den ersten Schritt in Richtung Cloud dar. Dabei wird durch die Installation der im Wesentlichen unveränderten Anwendung in einen Container zunächst die Cloud als Plattform erschlossen.


Nachdem die Marketing-Abteilung damit Cloud-Fähigkeit in der Featureliste aufführt, wird anschließend der Weg fortgesetzt in Richtung 'bessere Cloud-Eignung', denn das Prädikat 'Cloud-native' liegt noch in weiter Ferne.
Einer der nächsten Schritte ist dann in der Regel die Aufteilung der existierenden Logik in einzelne Services, was häufig einen kompletten Paradigmenwechsel bedeutet und mit einem großen strukturellen Umbruch verbunden ist.


Der Vortrag beschreibt eine evolutionäre Herangehensweise an die Umstrukturierung bestehender Anwendungen mit strikten Anforderungen an eine Revisions-sichere Datenhaltung. Dabei liegt ein besonderer Schwerpunkt auf dem Umgang mit dem - beim Übergang zu lose gekoppelten Services - immanenten Verlust der transaktionalen Kopplung sowie auf den dadurch in Systemen mit historischer Datenhaltung auftretenden Problemen. Der Lösungsansatz heißt 'Idempotenz für Arme' und wird detailliert beschrieben.

", + "persons": [ + { + "id": 24434, + "public_name": "Frank Werres" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2548, + "date": "2023-06-21T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Modern Linux CLI Tools", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2548", + "track": "CI / CD and automation", + "language": "en", + "abstract": "INFO: Session kann ich auch gern auf Englisch machen.
\r\n
\r\nDie Kommandozeile (CLI) ist eines der mächtigsten Werkzeuge, das uns Entwicklern zur Verfügung steht (und manchmal auch das einzige).
\r\n
\r\nGerade im Linux-Umfeld wurden in den letzten Jahrzehnten viele nützliche Tools entwickelt um uns das Leben zu erleichtern. Oder manchmal auch einfach nur um uns ein Schmunzeln auf die Lippen zu zaubern.
\r\n
\r\nIn dieser Session möchte ich euch ein Potpourri an Linux CLI Tools vorstellen: Von der Kategorie \"installiere ich auf jedem Server\" bis hin zu \"Pimp my Command Prompt\".
\r\n
\r\nWarum?
\r\n
\r\nEgal ob unter Windows mit WSL2 (oder einfach nur Git-Bash), auf dem heimischen Raspberry Pi, oder bei den meisten Cloud Anbietern: Die Linux CLI ist überall vorhanden!
\r\n
\r\nDie Session richtet sich auch bewusst an Linux und CLI Neulinge!", + "persons": [ + { + "id": 41385, + "public_name": "Patrick Drechsler" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "AUSY Lounge": [ + { + "id": 2355, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:165", + "room": "AUSY Lounge", + "title": "Pulumi Cloud Infrastructure Challenge (Vortrag und Challenge)", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2355", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Klickst Du noch oder automatisierst Du schon?

Pulumi bietet - dank Infrastructure-as-Code - automatisierte und reproduzierbare Infrastruktur-Setups mit gewohnten Programmiersprachen. Vom Container-Deployment über Service Accounts bis hin zu ganzen Cluster-Setups. Wagt euch an die Pulumi Challenge und findet heraus, welches Level ihr innerhalb von 3 Stunden erreichen könnt.

​​​​​​​Nach einem gemeinsamen Onboarding löst ihr in kleinen Teams verschiedene Infrastructure-as-Code-Aufgaben und lernt spielend Pulumi kennen. Jede Aufgabe bringt euch auf ein neues Level und zu den nächsten Herausforderungen. Den Siegern der Challenge winken Ruhm, Ehre, Know-How und ausgefallene Preise. 

Ihr bringt die Laptops; wir stellen Coaches, Cloud-Umgebungen und die Challenge.

", + "persons": [ + { + "id": 24226, + "public_name": "Benjamin Klatt" + }, + { + "id": 40680, + "public_name": "David Dasenbrook" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2359, + "date": "2023-06-21T15:00:00+02:00", + "start": "15:00", + "duration": "00:105", + "room": "AUSY Lounge", + "title": "Github Copilot vs. Amazon CodeWhisperer for Java Developers", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2359", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "

In this talk I will compare 2 services Github Copilot and Amazon CodeWhisperer from the perspective of the Java developers in terms of the quality of the given recommendations, IDE integration and pricing.

Both services are the machine learning-powered services that help improve developer productivity by generating code recommendations based on developers’ comments in natural language and their code. Based on natural language comments, these services also automatically recommend unit test code that matches your implementation code.


To join you will need the following set up:
Java 11 or 17 and Maven
AWS Toolkit Plugin e.g. for IntelliJ IDE (already includes AWS CodeWisperer) and AWS CodeWhisperer free registration with AWS Builder ID (no AWS account required, only private email address) and/or GitHub Copilot IntelliJ Plugin (60 days free use) For an optional AWS Serverless Demo you need your own AWS account and AWS CLI and AWS SAM installed locally.
Even without active participation, we will discuss the benefits and drawbacks of both solutions

", + "persons": [ + { + "id": 16623, + "public_name": "Vadym Kazulkin" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2361, + "date": "2023-06-21T17:00:00+02:00", + "start": "17:00", + "duration": "00:105", + "room": "AUSY Lounge", + "title": "Technology Radar", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2361", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Das Leben in den Wolken kann so schön sein. Regelmäßig erblicken neue Techniken das Licht der Welt, die uns versprechen, das Arbeitsleben leichter und schöner zu machen. Aber leistet diese Technik tatsächlich, was sie verspricht? Und bringt sie dabei ggf. Nachteile mit sich, durch die der Einsatz weniger zweckdienlich ist?


Um solche Fragen zu klären, ist es sinnvoll, dass wir uns mit Gleichgesinnten über unsere Erfahrungen austauschen. In einigen Unternehmen wird diese Erfahrung in einem sog. Technology Radar gesammelt, der Aufschluss darüber gibt, welche Technologien zu empfehlen sind und wovon man eher die Finger lassen sollte.

Im Rahmen dieser Session wollen auch wir die Erfahrungen der Teilnehmer sammeln und zu einem eigenen CloudLand Technology Radar zusammenstellen. Dabei werden wir uns neben der Methodik selbst in einem Rundumschlag intensiv mit verschiedensten Technologien aus dem Cloud-Umfeld beschäftigen.

", + "persons": [ + { + "id": 20734, + "public_name": "Michel Hartmann" + }, + { + "id": 38992, + "public_name": "Björn Raupach" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_expert" + ], + "featureTags": [] + } + ], + "REWE digital Lounge": [ + { + "id": 2386, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:225", + "room": "REWE digital Lounge", + "title": "Cloud-Workshop: Vom Cloud-Muffel zum Cloud-Native ", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2386", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Alle reden von der Cloud, nur man selbst scheint noch meilenweit davon entfernt. Zu viele offene Fragen, zu wenige konkrete Antworten. Und genau das soll sich in diesem Workshop ändern. Gemeinsam nehmen wir uns ein typisches Anwendungsszenario aus dem Enterprise-Umfeld vor und migrieren es Schritt für Schritt in die Cloud. Beginnend bei der Plattforminfrastruktur (DB, Storage etc.) über Standardservices (User Management) bis hin zur anwendungsspezifischen Businesslogik.

​​​​​​​Am Ende steht eine rein Cloud-basierte Lösung und natürlich die Diskussion, ob wir es nicht evtl. ein wenig übertrieben haben. Denn nicht alles, was technologisch möglich ist, macht auch für jeden Kontext Sinn. Getreu dem Motto \"mittendrin statt nur dabei\" darf jeder auch gerne selbst Hand anlegen.

", + "persons": [ + { + "id": 25816, + "public_name": "Renke Grunwald" + }, + { + "id": 43233, + "public_name": "Gabriel Winkler" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2391, + "date": "2023-06-21T16:00:00+02:00", + "start": "16:00", + "duration": "00:165", + "room": "REWE digital Lounge", + "title": "JUG Oberland: Kubernetes-Cluster auf Raspberry Pis aufsetzen", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2391", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Wir bringen in einem Hands-On-Workshop Kubernetes from Scratch zum Laufen – auf Raspberry Pis.

Wir werden das Netzwerk über einen OpenWRT-Router konfigurieren, das Betriebssystem der Rasps einrichten und
mit k3s einen Kubernetes-Cluster installieren. Der *etcd* wird verteilt aufgesetzt, womit er hochverfügbar ist: von *n* Nodes können *½n - 1* ausfallen, ohne dass der Cluster beeinträchtigt wird.

Auf dem OpenWRT-Router läuft ein externer Loadbalancer. Dieser verteilt über alle Nodes Zugriffe auf den Cluster, kann den Ausfall eines Nodes erkennen kann und somit Anfragen an tote Nodes verhindern.

Es werden vier Cluster mit jeweils drei Nodes für die Teilnehmer zur Verfügung gestellt (sofern diese bis dahin wieder erhältlich sind). Die Teilnehmer arbeiten daher in vier Teams.

", + "persons": [ + { + "id": 39483, + "public_name": "Max Harmathy" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Mayflower Lounge": [ + { + "id": 2417, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:225", + "room": "Mayflower Lounge", + "title": "Von der Domäne zur Implementierung mit Event Modeling", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2417", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Eventgetriebene Software-Architekturen sind ein Thema, von dem man derzeit immer häufiger hört. Frameworks, im JVM-Umfeld, z.B. das Axon Framework für CQRS & Event Sourcing, bieten Entwicklern die Möglichkeiten, solche Architekturen leicht und sauber umzusetzen.


Sie können jedoch nur dafür sorgen, dass man Dinge richtig implementiert - sie helfen nicht dabei zu erkennen, was die richtigen Dinge sind. Im Umfeld von Domain-Driven Design haben sich hierfür verschiedene kollaborative Modellierungsmethoden etabliert, mit denen Teams ihre Domäne erkunden können. Zu diesen Methoden zählen unter anderem Event Modeling, Event Storming und Domain Storytelling.


In diesem Workshop möchten wir vor allem auf Event Modeling eingehen, dessen Stärken und Schwächen mit den anderen genannten Methoden vergleichen und zeigen, warum das Event Modeling Blueprint eine perfekte Ausgangsbasis für die Implementierung von eventgetriebenen Applikationen ist.


Neben der Erklärung und Einordnung werden wir anhand eines leicht verständlichen Beispiels den kompletten Event-Modeling-Prozess Schritt für Schritt durchgehen. Die Teilnehmer lernen dabei die einzelnen Phasen der Methode kennen und lernen, worauf man bei diesen jeweils achten muss.


Anhand des konkreten Beispiels arbeiten wir heraus, wie dieses konkret für die Implementierung benutzt werden kann. Ihr erfahrt alles was nötig ist, um selbst im eigenen Projekt eine Event Modeling Session durchzuführen und von den Vorteilen zu profitieren.

", + "persons": [ + { + "id": 38516, + "public_name": "Frank Steimle" + }, + { + "id": 24439, + "public_name": "Florian Pfleiderer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2421, + "date": "2023-06-21T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Mayflower Lounge", + "title": "aufschlag.mörser.tulpe - Geodaten und ihre Verwendung", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2421", + "track": "Customer Stories", + "language": "de", + "abstract": "

Euch erwartet eine Einführung in das Thema Geodaten: Was sind Geodaten? Wo kann ich Geodaten abrufen? Welche Ausprägungen von Geodaten existieren? Wie werden Geodaten in der Praxis verwendet?

Mit einem Impulsvortrag \"Was man mit drei Worten alles finden kann?\" führen wir die Teilnehmer durch das Phantasialand und damit in die Welt der Geodaten ein. Daran anschließend stellen wir exemplarisch an einer Oracle-Datenbank die nutzbaren Geodaten und ihre Ausprägungen vor.

Abschließend ist eine kleine Debatte zum Pro und Contra von what3words als Alternative zu GPS-Koordinaten vorgesehen.

", + "persons": [ + { + "id": 14479, + "public_name": "Armin Wildenberg" + }, + { + "id": 3312, + "public_name": "Sven Bosinger" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2423, + "date": "2023-06-21T17:00:00+02:00", + "start": "17:00", + "duration": "00:105", + "room": "Mayflower Lounge", + "title": "AWS UG Nürnberg: Apps einfach deployen mit Cloud Foundry", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2423", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Um Anwendungen produktiv zu bekommen, muss man sich oft mit der komplexen Konfiguration von Umgebungen auseinandersetzen.

Dabei kann einem die Open-Source-Application-Plattform Cloud Foundry helfen, die es ermöglicht, Cloud-Native-Anwendungen mit wenig Overhead an die Infrastruktur zu übergeben.

In diesem Workshop werden wir anhand einer Beispielanwendung lernen, wie schnell man eine neue Applikation mit Cloud Foundry konfigurieren und deployen kann.

​​​​​​​Bitte bringt einen Laptop mit IDE und NodeJS mit.

", + "persons": [ + { + "id": 39979, + "public_name": "Robert Krul" + }, + { + "id": 41775, + "public_name": "Florian Roth" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Stage 1": [ + { + "id": 2479, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 1", + "title": "JUG Nürnberg: Keine Panik - die Cloud tut nicht weh", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2479", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Jeder kennt diese Situation: Ein typisches Thema bei der Migration oder der Schaffung neuer Anwendungen in der Cloud ist immer die Vorsicht der Entscheider vor der Cloud. \"Aber da hat der Cloud-Anbieter Zugriff auf meine Daten\", \"unser Datenschutz erlaubt nicht personenbezogene Daten in der Cloud zu speichern\", \"dann müssen die allgemeinen Geschäftsbedingungen aktualisiert und alle unserer Kunden informiert werden\" oder \"der Cloud-Anbieter ist ein Konkurrent zu unserem Geschäftsmodell\" sind oft gegebene Argumente dagegen, die Anwendung in der Cloud aufzubauen.

In diesem Beitrag werden Vorgehensweisen und Quellen beschrieben und gezeigt, was für und gegen diese Aussagen spricht und wie man damit bei der Beratung der Entscheider umgehen kann. Das Ganze wird abgerundet durch ein paar Praxisbeispiele für das Finden einer technische Lösung, die die Bedürfnisse der Verantwortlichen abdeckt. Anschließend gibt es einen offenen Austausch, um zu sehen, wie andere mit einer solchen Situation umgegangen sind.

", + "persons": [ + { + "id": 40633, + "public_name": "Ralph Löwe" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2480, + "date": "2023-06-21T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Semi-automatisierte Migration von Legacy Code zu Cloud-Native Microservices", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2480", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Es gibt viele Herausforderung zur Migration bestehender Services auf eine moderne Basis. Muss dies dann nicht nur einmal erfolgen, sondern wurde bisher zum Beispiel auf einem Application Server deployed, so kann der Copy & Paste-Ansatz im ersten Moment als eine brauchbare Vorgehensweise erscheinen. Die vorliegenden bestehenden Strukturen können aber auch automatisiert verarbeitet werden. Auf Knopfdruck kann damit eine solide Basis (oder auch mehr) zur Migration geschaffen werden.

Dieser Vortrag zeigt die Konzepte mit einem semi-automatisierten Ansatz zur Migration und berichtet von den Erfahrungen in Kundenprojekten. Dabei werden die Voraussetzungen für einen hohen Automatisierungsgrad und die daraus entstehenden Vorteile gezeigt. Außerdem gehen wir der Frage nach, wie eine geeignete Architektur dazu beitragen kann, dass Software-Erweiterungen mit der Zeit immer günstiger werden.

", + "persons": [ + { + "id": 41812, + "public_name": "Martin Kurz" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2481, + "date": "2023-06-21T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Living on the Edge - Ein Rechenzentrum im Reisekoffer", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2481", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Die Herausforderungen für die Cloud-Native-Community werden immer größer. Zum Glück werden auch die Tools und der Hardware-Support immer umfangreicher.

Edge ist ein Thema, das immer mehr nachgefragt wird - aus den verschiedensten Gründen. Hierbei sind die Herausforderungen ebenso groß wie die Anwendungsfälle.


Lasst uns gemeinsam auf die Reise gehen und ein tragbares Rechenzentrum bauen. Es muss leicht transportiert werden können und genug Leistung mitbringen. Ein Rechenzentrum, das in einen Koffer passt und überall auf der Welt die Leistung zur Verfügung stellt, die man braucht.


Wir nutzen eine Vielzahl von CNCF-Projekten, um dies zu realisieren. Die Basis ist ein MiniITX-Clusterboard mit mehreren ARM-basierten Nodes. Darüber hinaus verwenden wir KubeVirt und nutzen den Small-Control-Plane-Ansatz, um ein echtes Multi-Cluster-Rechenzentrum zu schaffen.

", + "persons": [ + { + "id": 38995, + "public_name": "Mario Fahlandt" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2482, + "date": "2023-06-21T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Tackling cross-cutting concerns within your architecture", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2482", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

In Microservice-basierten Architekturen gibt es mehrere Aspekte, die von allen (oder den meisten) Services gemeinsam genutzt werden. Querschnittsthemen, die sogenannten Cross-Cutting-Concerns, werden von bestimmten Komponenten innerhalb des Stacks behandelt. Zu diesen Komponenten zählen Container-Orchestrierung (Kubernetes), API-Gateways und Service/Event Meshes.

In diesem Vortrag zeige ich:


  • Das Konzept hinter Cross-Cutting Concerns
  • Die Anwendung von Kubernetes, API-Gateways und Service/Event Meshes im Bezug auf Cross-Cutting-Concerns
  • Wie sich der Einsatz von Komponenten für Querschnittsthemen auf die Geschwindigkeit im Entwicklungsprozess auswirkt
  • Wie Services durch die Verwendung von Cross-Cutting Concerns abgesichert werden können
", + "persons": [ + { + "id": 19080, + "public_name": "Daniel Kocot" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2483, + "date": "2023-06-21T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Eventual vs. Optimistic Consistency - Datenaustausch zwischen Domains", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2483", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "In Microservices hält man gerne ein Read Model von benötigten Daten anderer Services vor, um eine langsame und fehleranfällige Kopplung während der Laufzeit zu vermeiden. Insbesondere bei Services aus verschiedenen Domänen ist dies ein beliebtes Pattern. Aber bei einer optimistischen Implementierung laufen die Daten zwangsweise irgendwann auseinander - das Read Model bildet nicht mehr die Wahrheit der Single Source of Truth ab - und im schlimmsten Fall bekommt man das erst Jahre später durch krude Kundentickets mit.

\r\nIn diesem Talk möchte ich euch unsere Erfahrungen mit der Thematik vorstellen - wie viele Daten früher bei uns kaputt waren und was wir heute tun, um konsistente Datenbestände ohne strikte Kopplung herzustellen.", + "persons": [ + { + "id": 41714, + "public_name": "Krischan Dickel" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2555, + "date": "2023-06-21T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Mit der Zeit gehen – flexible Architekturen", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2555", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "In der agilen Softwareentwicklung gibt es die Rolle des Architekten eigentlich nicht mehr. Paradoxerweise sind die Herausforderungen an den Entwurf moderner Softwaresysteme höher als früher. Um die Digitalisierung voranzutreiben, sich von den Mitbewerbern abzuheben, sich möglichst auch einen Wettbewerbsvorteil zu erarbeiten und die sowohl technische als auch organisatorische Skalierbarkeit sicherzustellen, sind zu den altbekannten ganz neue Fragestellungen hinzugekommen:
\r\n
\r\n* Laufzeitmonolith oder irgendetwas Entkoppeltes?
\r\n* DevOps oder klassischer Betrieb?
\r\n* Serverless/Cloud oder On Premises?
\r\n* Relationale Datenhaltung oder NoSQL bzw. sogar In-Memory?
\r\n* Lang- oder Kurzlebigkeit?
\r\n
\r\n Je nach eingesetzten Architekturstilen und -mustern kommen heutzutage ganz neue Herausforderungen auf euch zu. Wir diskutieren in diesem Vortrag, wie agile Teams eine flexible und vor allem auch robuste Softwarearchitektur entwerfen, sie festhalten, kommunizieren und pflegen können. Und das auch, wenn von der grünen Wiese nach ein paar Monaten nicht mehr viel zu sehen ist.", + "persons": [ + { + "id": 11125, + "public_name": "Falk Sippach" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2485, + "date": "2023-06-21T17:00:00+02:00", + "start": "17:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Pimp my Cluster | Kubernetes Operators mit dem JOSDK", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2485", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Kubernetes ist ein sehr mächtiges Werkzeug, wenn es darum geht, komplexe Anwendungen in Cloud-Umgebungen zu betreiben. Von Haus aus werden dabei schon eine Vielzahl von nützlichen Ressourcen wie Deployments, Services und viele mehr geboten. Manchmal werden aber die Standard-Ressourcen nicht ausreichen, um sehr spezielle Use-Cases (wie die Kommunikation mit hauseigenen Systemen) über Kubernetes abbilden zu können.

Hier kommen Operators ins Spiel. Mit deren Hilfe ist es uns möglich, die API von Kubernetes mit eigenen Ressourcen und zugehöriger Business-Logik zu erweitern. In diesem Vortrag möchte ich euch zeigen, was ein Operator für Kubernetes ist und wie man mit dem JOSDK einen eigenen Operator erstellen kann. Wir werden uns dabei nicht nur die Theorie zu Operators ansehen, sondern werden auch im Code eines Beispiel-Operators sehen, wie man mit Hilfe des JOSDK den eigenen Cluster um neue Funktionen erweitern kann.


Ablauf der Session:

1. Einführung/Vorstellung

2. Was ist das Operator-Pattern?

3. Vorstellung des Fallbeispiels (fachlich)

4. Live-Demo inkl. Codebeispielen

5. Fragen

", + "persons": [ + { + "id": 38657, + "public_name": "Matthias Alt" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2486, + "date": "2023-06-21T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Die nächsten 100 Microservices", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2486", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Ein System wird heutzutage üblicherweise in Microservices geschnitten, die jedes für sich genommen ein alleinstehendes Projekt bilden.


Wie schafft man es, dass sich ein Entwickler in einem Microservice sofort zuhause fühlt, ohne ihn vorher je gesehen zu haben? Wie schafft man es, dass alle Microservices die gleiche Grundstruktur behalten und warum sollte man das überhaupt wollen? Wie vermeidet man Divergenzen in Setup und Struktur, während unterschiedliche Teams an den Microservices arbeiten? Wie setzt man schnell einen neuen Microservice auf, der in seinem Aufbau den bestehenden ähnelt?

​​​​​​​Wir wollen zeigen, welche Vorteile Templates für die Entwicklung von Microservices haben und welche Methoden in diesem Kontext nützlich sind. Dies ergänzen wir mit weiteren Tools, um das Setup für alle Entwickler gleichermaßen zu erleichtern und zu beschleunigen.

", + "persons": [ + { + "id": 42135, + "public_name": "Sascha Böhme" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + } + ], + "Stage 3": [ + { + "id": 2577, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 3", + "title": "DevOps in Enterprise-Umgebungen - Kultur, Organisation und Technologie", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2577", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

DevOps in Enterprise-Umgebungen wird oft als \"AntiPattern\" dargestellt. Es heißt, DevOps in großen Umgebungen funktioniert einfach nicht, und teilweise stimmt diese Behauptung auch.


Ich möchte euch in diesem Talk zeigen, wie jede Hierarchie in einer Enterprise-Umgebung ihren Teil zum Gelingen der DevOps-Strategie beitragen kann - mit einer Betrachtung der drei wesentlichen Säulen einer jeden DevOps-Strategie: Kultur, Organisation und Technologie.


Wer mag, kann den Vortrag auch schon mal spoilern unter https://frickeldave.de/it_dieu1, aber live entstehen dann hier erst die wirklich interessanten Diskussionen.

", + "persons": [ + { + "id": 41345, + "public_name": "David Koenig" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2578, + "date": "2023-06-21T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Machine Learning in der Cloud - die MLOps Plattform Kubeflow", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2578", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Die MLOps-Plattform Kubeflow hat sich zum Ziel gesetzt, die Bereitstellung von End-to-End Workflows für maschinelles Lernen (ML) einfach, portabel, reproduzierbar und skalierbar zu machen - und das gelingt nirgends besser als in Kubernetes in der Cloud!

Die modulare Multi-Architektur und Multi-Cloud setzt sich aus verschiedenen Best-of-breed-Open-source-Systemen zusammen und schlägt die Brücke zwischen den experimentierfreudigen Data Scientists und dem DevOps-Team.

In diesem Vortrag lernt ihr einige ML-spezifische Probleme kennen und erfahrt, wie Kubeflow sie adressiert. Mit einer beispielhaften Pipeline wird verdeutlicht, wie man einen Lebenszyklus mit Kubeflow-Pipelines abbildet und ihn dann auf Kubernetes ausführt.

", + "persons": [ + { + "id": 41243, + "public_name": "Verena Barth" + }, + { + "id": 14895, + "public_name": "Frank Köhne" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2579, + "date": "2023-06-21T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Tear Down this Wall! Tales From 3 Years Successful DevOps Collaboration.", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2579", + "track": "DevOps and methodology", + "language": "en", + "abstract": "

This talk will describe how two distinct companies formed a successful DevOps team during the COVID-19 pandemic. It will present many details on the implementation of our collaborative approach to software development and deployment, including the use of agile methodologies and a shared culture of automation and experimentation, all while adapting to remote work and other challenges brought by the pandemic.

\r\n

The results of this approach will be discussed, including increased efficiency, faster time-to-market, and improved communication and collaboration between teams. The talk will also highlight the positive impact on customer and end user satisfaction. Real-world examples will be used to illustrate the successes and challenges encountered during the implementation of our DevOps approach.

\r\n

The talk will conclude with a discussion of future opportunities for the companies to continue to improve and expand our joint venture through the use of DevOps methodologies, even in the face of unexpected challenges such as a global pandemic.

", + "persons": [ + { + "id": 16570, + "public_name": "Mario-Leander Reimer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2580, + "date": "2023-06-21T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Revolutionize Java DB App Dev with Reactive Streams and Java Virtual Threads", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2580", + "track": "Microservices and Domain-driven Design", + "language": "en", + "abstract": "With the advent of Reactive Programming and Virtual Threads, Java developers can scale Java database access using either option.
\n
\nUsing synchronous and asynchronous code, they will learn to take their Java database applications to the next level, using either Reactive Relational Database Connectivity (R2DBC), Reactive Streams Ingestion (RSI), or JDBC with Virtual Threads.
\n
\nThis session explores how they can make the right database connectivity choice per their specific requirements, focusing on performance, scalability, and simplicity.
\n", + "persons": [ + { + "id": 40807, + "public_name": "Juarez Barbosa Junior" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2581, + "date": "2023-06-21T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Clean Architecture und Microservices", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2581", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "Zur Strukturierung von Software existiert eine Vielzahl von Architekturmustern. Unter dem Begriff Clean Architecture lassen sich mehrere davon zusammenfassen, welche sich zwar im Detail unterscheiden, beim Ziel aber auf das Gleiche setzen: Trennung von Verantwortlichkeiten. Im Ideal wird dadurch eine Software erreicht, die sich langfristig einfach warten und erweitern lässt.
\r\n
\r\nFür Microservices wirken die Prinzipien der Clean Architecture allerdings teilweise übertrieben. Die Aufteilung in Schichten kann für kleine Microservices mehr Aufwand bedeuten und nur wenige Vorteile bringen. In diesem Vortrag wollen wir uns mit genau dieser Diskrepanz beschäftigen und daraus Best Practices für neue Microservices ableiten.", + "persons": [ + { + "id": 39918, + "public_name": "Roland König" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2582, + "date": "2023-06-21T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Kubernetes Operator in Rust", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2582", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "Operatoren sind Software-Erweiterungen für Kubernetes, die benutzerdefinierte Ressourcen zur Verwaltung von Anwendungen und deren Komponenten nutzen.
\r\n
\r\nIn diesem Vortrag untersuchen wir, wie diese Operatoren in Rust geschrieben werden können. Rust bringt Vorteile wie Leistung, Sicherheit und geringen Speicherbedarf mit sich. Wir werden die Grundlagen der Operator-Entwicklung in Rust erklären, eine konkrete Implementierung vorstellen und diskutieren, wie die Verwendung von Rust zu robusten und speichersparsamen Anwendungen führen kann.", + "persons": [ + { + "id": 41447, + "public_name": "Enno Boland" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2583, + "date": "2023-06-21T17:00:00+02:00", + "start": "17:00", + "duration": "00:45", + "room": "Stage 3", + "title": "A High-Speed Data Ingestion Solution in Java Using MQTT, AMQP, and STOMP", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2583", + "track": "Microservices and Domain-driven Design", + "language": "en", + "abstract": "Many solutions face challenges when streaming data from thousands of data sources. Smart cities operating IoT networks with sensors such as temperature, pressure, and flow meters are great examples of applications with devices that generate a massive amount of data in the scope of Microservices solutions supporting our cities nowadays.
\r\n
\r\nActiveMQ is a Java-based open-source message broker that supports REST API and wire-level protocols, such as MQTT, AMQP, and STOMP.
\r\n
\r\nIn this talk, we'll create a Java application with examples for each protocol. Then we'll use a public dataset, and ActiveMQ will support Message Oriented Middleware (MOM) to communicate between components and Reactive Streams Ingestion (RSI) to inject the data into a database efficiently, non-blocking way.", + "persons": [ + { + "id": 40807, + "public_name": "Juarez Barbosa Junior" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2584, + "date": "2023-06-21T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Moderne Service-zu-Service-Kommunikation mit gRPC", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2584", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Technologien zur Service-zu-Service-Kommunikation gibt es viele. SOAP Webservices galten lange Zeit als Standard. Heute haben sich in den allermeisten Anwendungsszenarien REST oder zumindest REST-artige Webservices durchgesetzt.


Das durch Google entwickelte gRPC ist eine jüngere Alternative zur Service-zu-Service-Kommunikation und ist in vielen Sprachen und Frameworks verfügbar. Das Protokoll basiert auf HTTP (mindestens Version 2), setzt auf ein Contract-first-Entwicklungsmodell, ermöglicht bidirektionale Kommunikation zwischen zwei Services, reduziert die Last auf dem Netzwerk mittels binärer Serialisierung und bringt noch viele weitere Vorteile.

In diesem Vortrag durchlaufen wir eine Einführung in gRPC und schauen uns die Unterschiede zu REST-Webservices und SOAP-Webservices an. Zudem diskutieren wir Vor- und Nachteile von gRPC, welche vor dem praktischen Einsatz von gRPC bekannt sein sollten. Die Beispiele werden überwiegend in C# sein.

", + "persons": [ + { + "id": 39918, + "public_name": "Roland König" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Stage 4": [ + { + "id": 2608, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Robuste Datenpipeline mit Open-Source-Software erstellen", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2608", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "Datenqualität ist seit Jahren ein viel diskutiertes Thema in den Bereichen Data Engineering und Data Science. Dabei steht die Validierung der Daten an erster Stelle, um die Zuverlässigkeit der von den Datenpipelines erzeugten Ergebnisse sicherzustellen.
\r\n
\r\nAber kann man das auch komplett mit Open-Source-Software umsetzen?
\r\n
\r\nApache Airflow und dbt (data build tool) gehören zu den bekanntesten Open-Source-Tools im Data-Engineering-Ökosystem. Während dbt einige Datentestfunktionen bietet, erweitert ein anderes Open-Source-Datentool, Great Expectations, die Pipeline um Datenvalidierung und kann zusätzliche Ebenen der Robustheit schaffen.
\r\n
\r\nSascha Dittmann stellt in dieser Demo-lastigen Session den \"dAG-Stack\" vor.
\r\nDabei zeigt er, wie ihr diese drei Open-Source-Tools kombinieren könnt, um komplette Datenpipelines erstellen, testen, validieren, dokumentieren und orchestrieren zu können.", + "persons": [ + { + "id": 39377, + "public_name": "Sascha Dittmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2609, + "date": "2023-06-21T12:00:00+02:00", + "start": "12:00", + "duration": "00:105", + "room": "Stage 4", + "title": "Distributed SQL on containers: YugabyteDB", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2609", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "

Join us for a hands-on lab where we'll explore the new generation of databases, known as Distributed SQL. In this workshop, we'll be installing YugabyteDB (Open Source and PostgreSQL-compatible) and testing its key features, such as elasticity and resilience, by adding new containers or simulating failures while the SQL application is running. Additionally, we'll explain the main concepts behind horizontal scalability, including sharding, replication, and distribution. We'll dive into the architecture and discuss the Raft algorithm, LSM-Tree, and clock skew.

Requirements:
You can decide to attend and follow the demo. If you want to run the lab, it's recommended that you bring your laptop with Docker installed, but other installation methods such as VMs with Vagrant or Kubernetes are also acceptable if you are comfortable with them. To connect, we'll use any PostgreSQL client, with psql being the simplest option. You can also try to run your PostgreSQL application to YugabyteDB and see how it works.

", + "persons": [ + { + "id": 12082, + "public_name": "Franck Pachot" + }, + { + "id": 43340, + "public_name": "Halil Dagli" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2611, + "date": "2023-06-21T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Ansible Ops mit Gitlab", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2611", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Die ganze Welt redet von GitOps und Automatisierung. Aber wie macht man das? Und WER macht sowas schon produktiv?

Wir haben einige unserer täglichen und wöchentlichen Arbeitsschritte mit Ansible und GitLab automatisiert, so dass sie entweder komplett ohne oder nur mit wenigem menschlichen Zutun ablaufen.


Die Vorteile für uns liegen auf der Hand: Konsistente Systeme. Automatische Change. Viel weniger Fehler.
UND mehr Zeit für Dinge, die unsere Konzentration benötigen und \"Spaß\" machen! :-)

Treu nach dem Motto: Wir sind faul! Und mit Automatisierung hat man mehr Zeit für die interessanten Dinge im Leben! :-D

", + "persons": [ + { + "id": 40354, + "public_name": "Christian Lorenz" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2612, + "date": "2023-06-21T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Wie baue ich eine skalierbare, ereignisgetriebene Architektur mit AWS?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2612", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Teams, die eine Microservices-Architektur aufbauen, stellen oft fest, dass die Integration mit anderen Anwendungen und externen Diensten ihre Workloads monolithischer und enger anstatt loser gekoppelt macht. Dazu kommt die Arbeit mit großen Datenmengen in verschiedenen Datastores und Services, die eine Herausforderung sein kann.


Solche und weitere schwierige Probleme in modernen Workloads können mit ereignisgetriebenen Architekturen gelöst werden. In dieser Session diskutieren wir, wie genau ihr mit AWS Services zu einer Event-driven-Architektur gelangen könnt, um eure Anwendungskomponenten zu entkoppeln und zu dezentralisieren.

", + "persons": [ + { + "id": 39711, + "public_name": "Ben Freiberg" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2613, + "date": "2023-06-21T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 4", + "title": "JUG Nürnberg: Meine Cloud ist kaputt - Troubleshooting in der Cloud", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2613", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Die Cloud-Anwendung läuft nicht. Wenn den Entwickler oder Architekten so eine Nachricht erreicht, steigt der Puls meistens und man wechselt in eine andere Rolle. Früher wurden dann Logfiles, Datenbankinhalte oder Shell-Kommandos ausgetauscht, welche die Probleme Stück für Stück aufdeckten. Das Ziel ist es immer, das Problem möglichst schnell einzugrenzen und möglicherweise einen Workaround oder einen Bugfix zu finden, damit der Prozess wie gewünscht weiter laufen kann.


In der Cloud ist das bei einem Cluster einer Anwendung nicht immer so leicht. Zwar ist die Methodik gleich, aber die Mittel und Wege unterscheiden sich. Auch die Protokollierung ist anders und die direkte Introspektion und Analyse sind nur mit Tricks möglich. In diesem Vortrag werden ein paar Fallbeispiele gegeben, was bei Betrieb einer Cloud-Anwendung unter AWS passieren kann. Jeweils wird aufgezeigt, wie man in den konkreten Fällen zur Ursache gekommen ist und was die jeweilige Lösung war. In der abschließenden Diskussion werden die beschriebenen Erfahrungen reflektiert und eigene Situationen geteilt.

", + "persons": [ + { + "id": 40633, + "public_name": "Ralph Löwe" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2614, + "date": "2023-06-21T17:00:00+02:00", + "start": "17:00", + "duration": "00:45", + "room": "Stage 4", + "title": "JUG Nürnberg: Methods and Approaches for Creating Distributed Systems", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2614", + "track": "Microservices and Domain-driven Design", + "language": "en", + "abstract": "This talk addresses the challenges teams face in creating distributed systems whose parts must yield business capabilities.
\r\nMethods and techniques for efficient collaboration between people with differing mental models will be shown.
\r\nA general approach to influencing ecosystems will be shown.
\r\nA fundamental pattern for steering/managing teams who create distributed systems will be shown; in the context of Cynefin.
\r\n
\r\nIn summary, attendees will be equipped with techniques and methods for designing distributed systems, as well as a perspective to their work situations which will help them find and select a suitable one.
\r\n", + "persons": [ + { + "id": 42060, + "public_name": "Markus Wagner" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2615, + "date": "2023-06-21T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Advanced Observability & Security for your Kubernetes with a modern Service Mesh", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2615", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Ein Service Mesh hilft in verteilten Systemarchitekturen dabei, die Service-Kommunikation sicherer, zuverlässiger und nachvollziehbarer zu machen. Im Zusammenhang mit dem Thema Service Mesh fallen uns häufig Begriffe wie Microservices, Container oder Kubernetes ein. Ein modernes Service Mesh ist jedoch auch in der Lage, Legacy-Workloads, bspw. auf VMs zu integrieren. Außerdem ist es möglich ein Service Mesh über mehrere Cluster und Netzwerke hinweg zu definieren, bspw. in einem Multi-Cloud Setup, oder aber in der Kombination aus On-Premises und Cloud.

Doch neben diesen Connectivity-Vorteilen bietet ein Service Mesh auch eine ganze Menge in Richtung Observability und Security. Diese Session beschäftigt sich damit, wie ein Service Mesh in der heutigen heterogenen Welt dazu beitragen kann, komplexe Herausforderungen aus diesen Bereichen zu adressieren. In diesem Zusammenhang werden Real-world-Szenarien aus Projekten vorgestellt und einzelne Aspekte in einer Demo präsentiert.

", + "persons": [ + { + "id": 13459, + "public_name": "Fabian Hardt" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "QAware Lounge": [ + { + "id": 2640, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:165", + "room": "QAware Lounge", + "title": "From Pets to Cattle in your Smarthome!", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2640", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Wer kennt es nicht: Über die Jahre haben sich im Haus unzählige Raspberry Pis mit verschiedenster Software angesammelt und dann wurde die kleine Kiste irgendwo sorgfältig (aus den Augen aus dem Sinn) verstaut und nie wieder angefasst. Das Betriebssystem und die Applikationen laufen dort weiterhin (also in der selben Version) seit Jahren #Security!

Jedes Team erhält 3 Raspberry Pis und wir gehen zusammen die großen Probleme an:

- Was war doch gleich die IP und mein Nutzername/Password?
- Wie installiere ich doch gleich nochmal das Betriebssystem?
- Wie halte ich meine Applikationen und mein Betriebssystem aktuell?

Wir werden hierfür Rancher, Fleet, k3s und Elemental verwenden, um alle Probleme cloud-native zu lösen.

Aber nicht nur zu Hause stellt sich die Frage von Kubernetes on the Edge, sondern auch im Unternehmensumfeld findet k3s mehr und mehr Zulauf, weswegen abschließend anspruchsvolle Themen wie Hardware Tampering auf dem selben Stack aufgezeigt werden.

Für den Workshop werden den Teilnehmern Raspberry Pis zur Verfügung gestellt, weswegen die Teilnehmerzahl leider beschränkt ist #BringYourOwnPi?

", + "persons": [ + { + "id": 39645, + "public_name": "Dominic Giebert" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2643, + "date": "2023-06-21T14:00:00+02:00", + "start": "14:00", + "duration": "00:165", + "room": "QAware Lounge", + "title": "Microservices mit Golang in der Nussschale", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2643", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

In diesem Workshop lernen wir zusammen die Essentials von Golang und bauen einen typischen Microservice mit dieser Programmiersprache. Während wir Stück für Stück in Golang einsteigen, implementieren wir einen typischen Microservice mit den essentiellen technischen Requirements, die ein solcher Service auch im Real-Life-Projekt haben würde.

Inhalte und Schritte in diesem Code Kata:

- Konfiguration nach 12-Factor Principles
- synchrones RESTful API Design inkl. Swagger-UI
- asynchroner Event Emitter mit NATS.io und ProtoBuf Messages
- Persistenz-Layer mit Postgres
- Metrics Export mit Prometheus
- Structured Logging
- Containerization

Unsere Services deployen wir am Ende unseres Code Katas auf einem Bare Metal Kubernetes Cluster. Dazu wird es für die Teilnehmer*nnen ein vorbereitetes CI/CD Scripting geben.

Zum Workshop gibt es ein Git Repo mit Beispielimplementierung. Ebenso kann jede/r Teilnehmer*n jederzeit wieder mit Hilfe des Git Repos einsteigen, falls man bei einem Schritt nicht ganz fertig geworden sein sollte. Das Git Repo wird dazu Sync-Punkte bereithalten.

Am Ende des Workshops habt ihr die Grundlagen von Golang gesehen und zudem ein praktisches Set an bekannten Golang Modules ausprobiert. Das Projekt-Setup dient euch als Einstieg für den weiteren Learning Path zu eurer neuen Karriere als Cloud Native Developer mit Golang.

", + "persons": [ + { + "id": 39468, + "public_name": "Alexander Troppmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2647, + "date": "2023-06-21T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "QAware Lounge", + "title": "Learning eBPF for better Observability ", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2647", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "Collecting Observability data with eBPF aims to help Dev, Ops, and SREs to debug and troubleshoot incidents. Getting started is hard - bytecode in the Kernel, a history of different tools and methods to learn for development, and the question mark about the “e” in “eBPF” can be confusing.
\r\n
\r\nIn this workshop, we’ll walk through the basic concepts of BPF, and look into CLI tools like bpftrace and BCC tools to learn about tracing events. We’ll expand our knowledge with eBPF compilers, and move from C/Python code to abstraction libraries available in Go, C/C++ and Rust. More real world use cases are explored with Kubernetes service maps, Prometheus exporters, SRE troubleshooting, and security observability.
\r\n
\r\nThe workshop provides hands-on examples to trace processes, capture observability metrics, expand into security observability to detect malicious activities, and find new ways to analyze and visualize cloud-native deployments. All tools and platforms are open-source.
\r\n", + "persons": [ + { + "id": 42091, + "public_name": "Michael Friedrich" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_expert" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Community Hall": [ + { + "id": 2683, + "date": "2023-06-21T10:30:00+02:00", + "start": "10:30", + "duration": "00:30", + "room": "Community Hall", + "title": "Begrüßung", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2683", + "track": "noMainfocus", + "language": "de", + "abstract": "", + "persons": [ + { + "id": 17, + "public_name": "Fried Saacke" + }, + { + "id": 6970, + "public_name": "André Sept" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [], + "featureTags": [] + }, + { + "id": 2684, + "date": "2023-06-21T13:00:00+02:00", + "start": "13:00", + "duration": "00:360", + "room": "Community Hall", + "title": "Innovation Hacking Showcases im Expo-Bereich", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2684", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Euch erwartet eine Anzahl an innovativen Showcases des Innovation Hacking Teams der TNG Technology Consulting GmbH, inklusive Realtime Deepfakes, Realtime Style Transfer, Music AI, PowerPoint GhostWriter AI und vielen mehr.

Erlebt das futuristische Potenzial von KI hautnah! Unser Innovation Hacking Team stellt auf der Konferenz atemberaubende Projekte vor, die ihr selbst ausprobieren könnt. Lasst euch von der Power der Künstlichen Intelligenz begeistern und erfahrt mehr über die Möglichkeiten und Herausforderungen dieser Technologie.

", + "persons": [ + { + "id": 38505, + "public_name": "Martin Förtsch" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Cloud Universe (virtuell)": [ + { + "id": 2689, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:720", + "room": "Cloud Universe (virtuell)", + "title": "JUG Oberland: Pixelflut", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2689", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Es wird ein über das Konferenz-Netzwerk erreichbarer Server aufgestellt, der über einen Beamer einen Canvas zur Verfügung stellt. Der Canvas kann von den Konferenzteilnehmern in nachfolgender Art und Weise befüllt werden.


Der Server ist über \"telnet\" erreichbar (unverschlüsselter Text ohne Authentifizierung).

Der Server versteht folgende Befehle (die tatsächlich verwendete Implementierung könnte weitere unterstützen):
​​​​​​​
- SIZE
- QUIT
- PX x y RRGGBB

SIZE liefert die Größe des Canvas in Pixeln zurück (z.B. 6000x4000).
QUIT beendet die Session ordentlich.
PX x y fragt die aktuelle Farbe des angegebenen Pixels ab.
PX x y RRGGBB setzt die Farbe des angegebenen Pixels auf die angegebene RGB-Farbe.

Da der Server innerhalb des Konferenz-Netzwerks erreichbar ist, können über die Befehle alle interessierten Teilnehmer den Inhalt des Canvas beeinflussen. Die Idee ist, dass die Teilnehmer kleine Programme schreiben, die programmatisch Bilder generieren oder Bilddateien auf den Canvas projezieren. 


Da die Teilnehmer Beiträge der anderen Teilnehmer auch überschreiben können, entsteht in Spitzenzeiten ein Wettkampf um den Canvas und dessen Inhalt.


Das System wird nicht weiter beschrieben, lediglich Serveradresse und Port sind sichtbar. Die Idee ist, dass sich die Methodik der Canvas-Befüllung unter den Teilnehmern rumspricht.

", + "persons": [ + { + "id": 40043, + "public_name": "Sandra Fischer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2693, + "date": "2023-06-21T12:00:00+02:00", + "start": "12:00", + "duration": "00:660", + "room": "Cloud Universe (virtuell)", + "title": "CloudLand plays!", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2693", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Auf einem Bildschirm lassen wir eine Anwendung laufen, die wir - inspiriert von \"Twitch plays Pokémon\" - geschrieben haben.


Die Einführung zum Spiel findet am Mittwoch, den 21.06.2023 um 11:00 Uhr in der Blue Lounge statt!


Let's play!

", + "persons": [], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Playground Floor": [ + { + "id": 2728, + "date": "2023-06-21T11:00:00+02:00", + "start": "11:00", + "duration": "00:420", + "room": "Playground Floor", + "title": "JUG Oberland: Interaktiver Hebocon ", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2728", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Wir veranstalten im Rahmen der CloudLand einen interaktiven Hebocon Workshop und jeder kann mitmachen.

Dabei geht es um kleine Roboter, die individuell aus verschiedenen Bauteilen wie u.a. Räder, Platine, Sensoren zusammengebaut werden und gegeneinander in kleinen Roboterkämpfen antreten.

Wir bieten den Teilnehmenden dabei die Möglichkeit aus den von uns mitgebrachten Bestandteilen einen eigenen, kleinen Roboter zu bauen und auch durch eigene, weitere Bestandteile zu erweitern. Zusätzlich stellen wir per GitHub eine Codebasis zur Verfügung, mit der es bereits möglich ist, den eigenen Roboter zu bedienen.

Sobald zwei Roboter gebaut und die Software angepasst wurde, können die beiden gegeneinander antreten. Dabei ist die Challenge entweder den anderen Roboter aus dem definierten Spielfeld drängen oder bewegungsunfähig machen.
Grundsätzlich kann tagsüber gebastelt und ausprobiert werden. Abends möchten wir kleine Turniere mit Siegerehrung und Preisen veranstalten.

Ziel des interaktiven Formats ist es, Teilnehmenden Spaß am Ausprobieren von Hardware und Code am eigenen Roboter zu bereiten. Darüber hinaus wird die Verzahnung und Interaktion zwischen Hardware und Software der Roboter dargestellt.

Workshop: 21.+22.06.
Turnier: 22.06., ab 19:30 Uhr

", + "persons": [ + { + "id": 41781, + "public_name": "Manuel Sauer" + }, + { + "id": 41960, + "public_name": "Jan Marthold" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ] + } + }, + { + "index": 3, + "date": "2023-06-22", + "day_start": "2023-06-22T10:45:00+02:00", + "day_end": "2023-06-22T23:00:00+02:00", + "rooms": { + "Schauspielhaus ": [ + { + "id": 2301, + "date": "2023-06-22T19:00:00+02:00", + "start": "19:00", + "duration": "00:45", + "room": "Schauspielhaus ", + "title": "KEYNOTE: Agile Transformation und Eheversprechen – warum ein „Ja ich will“ nicht ausreicht", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2301", + "track": "noMainfocus", + "language": "de", + "abstract": "

Jennifer und Stefan Latuski blicken gemeinsam zurück auf 30 Jahre Berufserfahrung und 10 Jahre Ehe. Während dieser Zeit haben beide unzählige Transformationsprojekte begleitet und auch private Höhen und Tiefen erlebt. In Ihrer gemeinsamen Keynote beleuchten die beiden, welche Dinge man besser weder in Transformationsprojekten noch im Eheleben tun sollte :)

", + "persons": [ + { + "id": 40024, + "public_name": "Stefan Latuski" + }, + { + "id": 43172, + "public_name": "Jennifer Latuski" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + } + ], + "MediaMarktSaturn Lounge": [ + { + "id": 2336, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:105", + "room": "MediaMarktSaturn Lounge", + "title": "MediaMarktSaturn Technology Backstage", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2336", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Wir lassen für euch die Hosen runter;

Werft mit uns einen Blick hinter die Kulissen der Systeme von MediaMarkt und Saturn. \r\nIn dieser Session zeigen wir Euch unsere Interna: Mikro- und Makroarchitektur, Integrationsmuster, Technologien und Infrastruktur.\r\n\r\nWir werden mit einem Überblick über unsere Systemlandschaft beginnen und haben unsere Experten zu diversen Themen am Start. Je nachdem, ob Euch konkrete Implementierungen, API- oder Messagingmuster, Security- oder Plattformlösungen interessieren, werden wir spezifisch darauf eingehen. \r\n\r\nEuch erwarten keine Hochglanz-Folien, vieles werden wir direkt in der Versionsverwaltung, am Live- oder Test-System zeigen. Gerne erörtern wir mit Euch unsere Umsetzungen und Konzepte oder lassen Euch auch an unseren Ideen und Visionen für die Zukunft teilhaben. \r\n", + "persons": [ + { + "id": 40250, + "public_name": "Kevin Fritz" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2338, + "date": "2023-06-22T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "MediaMarktSaturn Lounge", + "title": "Ein Blick hinter die Kulissen eines Kubernetes-Operators - Code-Reading-Session", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2338", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "Kubernetes-Operatoren helfen dabei, komplexe Aufgaben beim Betrieb von Anwendungen auf Kubernetes-Clustern zu lösen. Insbesondere zustandsbehaftete Systeme wie Datenbanken erfordern spezifische Kenntnisse, um diese zu skalieren, neue Versionen einzuspielen oder die Konfiguration zu ändern. Solche Funktionalitäten können in einem Operator kodiert und über eine Erweiterung der Kubernetes-API bereitgestellt werden. So können neben den gängigen Ressourcen wie Deployments oder Services weitere spezialisierte Ressourcen in einem Kubernetes-Cluster verwendet werden. In dieser Code-Reading-Session werfen wir einen Blick hinter die Kulissen eines Operators und erarbeiten uns gemeinsam dessen Funktionsweise.", + "persons": [ + { + "id": 41801, + "public_name": "Jan Weyrich" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2339, + "date": "2023-06-22T14:00:00+02:00", + "start": "14:00", + "duration": "00:105", + "room": "MediaMarktSaturn Lounge", + "title": "Diverses Kubernetes-Anwendungs-Konfigurationsmanagement", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2339", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Mit euch zusammen erarbeiten und studieren wir verschiedene Möglichkeiten zur Konfiguration von Anwendungen auf Kubernetes.

In Kleingruppen deployen wir eine Beispielanwendung mit Helm und Kustomize sowie auch ganz ohne Werkzeuge.
Die verschiedene Setups stellen wir gegenüber und überlegen wie das Wiederverwenden und Propagieren über verschiedene Stages funktionieren.

Macht euch auf jede Menge YAMLellei gefasst. Hier bleibt kein Auge trocken, medizinische Betreuung zur Behandlung verrenkter Finger ist gewährleistet.

Anforderungen: Ihr braucht eure Laptops mit Git und ausreichend Zeit.

", + "persons": [ + { + "id": 26443, + "public_name": "Florian Heubeck" + }, + { + "id": 40250, + "public_name": "Kevin Fritz" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2341, + "date": "2023-06-22T16:00:00+02:00", + "start": "16:00", + "duration": "00:165", + "room": "MediaMarktSaturn Lounge", + "title": "Microservices aus dem Monolithen schneiden mit Domain Storytelling", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2341", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Damit eine Microservices-Architektur erfolgreich sein kann, ist es elementar, die richtigen Grenzen zwischen den Microservices zu ziehen. Aber wo sind die richtigen Grenzen? Ich möchte eine Methodik präsentieren, das uns hilft, diese Frage zu beantworten. Domain Storytelling heißt, dass wir unsere Anwender uns Geschichten über ihre Domäne erzählen lassen. Während wir zuhören, zeichnen wir die Domain Stories vor den Augen der Fachexperten mit einer Bildsprache auf. Dadurch können alle Beteiligten unmittelbar sehen, ob sie richtig verstanden wurde. Schon nach wenigen Domain Stories verstehen wir die Sprache unser Anwender und finden unterschiedliche Bereiche in unserer Fachlichkeit. Jeder dieser Bereiche (eine sog. Subdomain) ist ein guter Kandidat dafür, ein Microservice in unserer Architektur zu werden.

In diesem Workshop lernen die Teilnehmer:innen, wie Domain Storytelling funktioniert, wie man damit Subdomänen findet und welche Heuristiken dabei helfen.


Es sind keine technischen Voraussetzungen und keine Vorkenntnisse erforderlich.

", + "persons": [ + { + "id": 43383, + "public_name": "Stefan Hofer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2345, + "date": "2023-06-22T20:00:00+02:00", + "start": "20:00", + "duration": "00:180", + "room": "MediaMarktSaturn Lounge", + "title": "GAMING NIGHT - Ask the Jura Bot AI", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2345", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "Lasst uns gemeinsam den neuen Jura Bot im Dialog rechtliche Fragen umgangssprachlich klären, Verträge prüfen und das Verhalten bei möglichen skurillen oder realistischen Fälle testen. \r\nWas wolltet Ihr einen Juristen schon immer mal fragen? - Hilft uns nun künstliche Intelligenz.", + "persons": [ + { + "id": 41900, + "public_name": "Johann-Peter Hartmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + } + ], + "AUSY Lounge": [ + { + "id": 2367, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:105", + "room": "AUSY Lounge", + "title": "Security Lab: OIDC in der Praxis", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2367", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Wenn Benutzer und Services authentifiziert werden sollen, kommt immer öfter OpenID Connect (OIDC) zum Einsatz. Im einfachsten Fall reicht es schon, das eingesetzte Framework richtig zu konfigurieren. Dann spricht die UI mit einem OIDC-geschützen Backend. Oder man schützt einen Service und authentifiziert mit OIDC die Benutzer. Doch meistens gibt es nicht nur ein einziges Integrationsszenario.

In diesem Workshop setzen wir an einer Single Page App, einem Backend-Service und einer Mobile bzw. Desktop App die möglichen Integrationsszenarien um und lernen so die Vor- und Nachteile der Szenarien kennen. Zum Abschluss probieren wir, den Zugriff auf den API-Server eines Kubernetes Cluster mittels OIDC zu schützen und zu personalisieren.

Voraussetzungen:
Laufendes Kubernetes (vorzugsweise Minikube) inkl. kubectl, Git, Helm, ggf. Flux CD

", + "persons": [ + { + "id": 39928, + "public_name": "Christian Fritz" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2569, + "date": "2023-06-22T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "AUSY Lounge", + "title": "Nachhaltige Software-Architektur im Cloudzeitalter", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2569", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

In Deutschland existieren über 53.000 Server und Rechenzentren (2017). Das Borderstep Institut hat errechnet, dass diese ca. 13.2 Mrd. kWh Strom jährlich benötigen. Und der Bedarf wird weiter steigen. Bis 2030 sollen allein 13 % des gesamten Strombedarfes auf das Konto von Server- und Rechenzentren gehen. Dies entspricht dem gesamten Flugverkehr weltweit und somit in etwa 33 Mio. Tonnen Kohlendioxid-Emissionen (Borderstep Institut – aktueller Strommix DE).

Die zugrundeliegende Hardware wird zwar immer effizienter in der Nutzung von Energie, jedoch wird dieser Vorteil durch einen immer weiter steigender Bedarf an Softwareprodukten aufgefressen. Somit spielt die Software eine nicht unerhebliche Rolle bei der Generierung des CO2-Fußabdrucks.

Zwei Thesen und eine Frage stehen im Raum:

- \"Software, die nie geschrieben wird, verbraucht am wenigsten Strom!\"
- \"Software, die nicht läuft, verbraucht am zweitwenigsten Strom!\"

und: \"Was können wir als Software-Architekten dazu beitragen?\"

", + "persons": [ + { + "id": 39499, + "public_name": "Uwe Neukam" + }, + { + "id": 39498, + "public_name": "Noah Neukam" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2371, + "date": "2023-06-22T15:00:00+02:00", + "start": "15:00", + "duration": "00:225", + "room": "AUSY Lounge", + "title": "Serverless Survical Guide", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2371", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Eine einzelne Serverless Function zu schreiben und produktiv zu stellen ist dank NoOps-Ansatz denkbar einfach. Nur leider macht eine Schwalbe noch keinen Sommer und eine einzelne Serverless Function noch keinen sinnvollen Anwendungsfall! Wie also konzipiert man eine Anwendung als Zusammenspiel von mehreren Serverless Functions und diversen weiteren Cloud-Komponenten? Gibt es spezielle Architektur-Pattern, die sich im Serverless-Umfeld anbieten? Und wie wirken sich diese auf den Software-Lifecycle aus? Was, wenn die niedlichen kleinen Funktionen sich zur Laufzeit nicht so verhalten, wie gewünscht? Wie sieht das Monitoring der einzelnen Funktionen und des Systems als Ganzes aus? Und was ist mit Testen? Muss die Funktion dazu immer in der Cloud deployt werden oder kann man das produktive System auch lokal emulieren? Diesen und vielen anderen Herausforderungen wollen wir uns in dem CloudLand-Workshop stellen - Aha-Effekte garantiert!


Vorkenntnisse

Es sind keine besonderen Vorkenntnisse notwendig. Ein Teil der Übungen werden wir in der Programmiersprache Java implementieren. Entsprechende Kenntnisse in der Programmiersprache sind sinnvoll aber nicht zwingend erforderlich.


Technische Voraussetzungen

Die Teilehmer:innen sollten einen eigenen AWS-Account besitzen, damit sie die Ergebnisse des Workshops auch im Nachgang noch einmal in Ruhe durchspielen und nachvollziehen können. Ein kostenloses Konto (https://aws.amazon.com/de/free) reicht für den Workshop vollkommen aus.


Für die Java-basierten Übungen sollte Java 11 oder höher auf dem Rechner installiert sein. Für diejenigen, die kein Java installiert haben, werden die fertigen Artefakte bereitgestellt.


Anmerkung

Um einen möglichst reibungslosen Ablauf des Workshops zu gewährleisten, steht ab Sonntag vor der Cloudland ein „rundum-sorglos“-Paket unter https://github.com/mobileLarson/serverless-workshop zum Auschecken bzw. Herunterladen bereit. Dort finden sich auch detaillierte Installationshinweise.


Bei Fragen zum Workshop bitte einfach melden: lars.roewekamp@openknowledge.de

", + "persons": [ + { + "id": 32011, + "public_name": "Lars Röwekamp" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2376, + "date": "2023-06-22T20:00:00+02:00", + "start": "20:00", + "duration": "00:120", + "room": "AUSY Lounge", + "title": "GAMING NIGHT - Musikalische Experimente mit SonicPi in der Cloud", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2376", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "Das Open Source Projekt Sonic Pi (https://sonic-pi.net) macht \"music as code\" möglich. Seine Ruby DSL ermöglicht das programmatische Erstellen von einfachen Geräuschkulissen bis hin zu komplexen Musikstücken. Dazu bietet die DSL Konstrukte wie synchronisierte Loops, das Nutzen eingebauter und externer Samples, ein großes Instrumentarium von Transformationen der Töne bzw. Samples (Ausschnitte, Attack und Sustain, diverse Veränderungen der Wellenmuster ...) und noch viel mehr an. Seit Jahren wird Sonic Pi daher auch für professionelle Live Performances verwendet, Beispiele finden sich auf der o.a. Webseite.
\r\nIn diesem Workshop wollen wir zunächst denjenigen, die Sonic Pi noch nicht kennen, einen kleinen Überblick über die Konzepte und Möglichkeiten geben. Anschließend schauen wir uns ein erweitertes Setup an, mit dem Sonic PI-Instanzen über verschiedene Rechner - prinzipiell weltweit - miteinander verknüpft werden und mit \"Musik-Code\" versorgt werden können, und lassen unserer Kreativität und Experimentierfreude freien Lauf.
\r\nIdealerweise sollte zum eigenen Experimentieren ein Rechner (mit vorinstalliertem Sonic Pi) mitgebracht werden, aber das ist keine unbedingte Voraussetzung. Wichtiger ist es, Spaß an der Musik und ein bisschen Kreativität mitzubringen - und vielleicht noch (rudimentäre) Programmierkenntnisse.", + "persons": [ + { + "id": 475, + "public_name": "Andreas Badelt" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "REWE digital Lounge": [ + { + "id": 2398, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:225", + "room": "REWE digital Lounge", + "title": "Create your Pipeline - Ein GitOps Workshop mit Kubernetes und Flux", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2398", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

In diesem Workshop wird Schritt für Schritt der Aufbau einer CI/CD Pipeline in Kubernetes im GitOps-Betriebsmodell durchgeführt, welches eine komplette Umgebung zum Build, Deploy und Betrieb von Applikationen bereitstellt, inklusive Monitoring, Ingress-Controller.


Folgende Tools werden dabei deployed:
- Flux mit FluxUI (von Weave)
- Tekton (ggf. Jenkins)
- Prometheus
- Loki
- Grafana
- Ingress-Nginx (kann auch anderer gewählt werden)
- cert-manager
- ggf. noch linkerd, vault, trivy und externalsecrets

Als Anwendung verwenden wir mysql und Keycloak, Kong und Testapplikationen (oder auch eigene Anwendungen).

Während des Workshops werden Schritt für Schritt alle notwendigen Artefakte konfiguriert, ein Repository für die cluster-config erstellt und in einem gitrepo abgelegt, von wo dann der Cluster provisioniert wird. Auch eine Notification, Alerting und eine ImageUpdateAutomation werden eingerichtet.

Voraussetzungen:
- Laptop mit laufendem Kubernetes Cluster (Minikube, Kind, Docker Desktop, RancherDesktop, eigene Cloudumgebung, usw.)
- Evtl. eigenes Github, ansonsten wird ein Public-Repository temporär zur Verfügung gestellt
- Grundwissen zu Kubernetes, kubectl und verteilten Systemen

", + "persons": [ + { + "id": 8120, + "public_name": "Thorsten Wussow" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2403, + "date": "2023-06-22T16:00:00+02:00", + "start": "16:00", + "duration": "00:165", + "room": "REWE digital Lounge", + "title": "Well Architected? Architektur-Ratgeber in der Cloud.", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2403", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Technologie- und Designentscheidungen in der Cloud sind komplex. Die Breite und Vielfalt der Cloud-Dienste führen zu vielen \"unknown unknowns\", die es schwierig machen, die Vor- und Nachteile von Entscheidungen abzuwägen und sie mit euren Zielen in Einklang zu bringen. Oft liegen Probleme nicht daran, dass wir Fehler gemacht haben, sondern daran, dass uns gute Lösungsansätze einfach nicht bewusst waren. Vielleicht ist es sogar der erste Kontaktpunkt eures Teams mit Cloud-Umgebungen.

An dieser Stelle geben uns die großen Cloud-Anbieter ein interessantes Werkzeug als Ratgeber an die Hand: Amazon und Microsoft mit ihren \"Well-Architected Frameworks\" und Google mit dem \"Architecture Framework\". Sie ermöglichen es uns, unsere entscheidenden Lösungsansätze anhand gängiger Good Practices und etablierter technischer und methodischer Grundsätze zu überprüfen.

In diesem Workshop lernt ihr die drei Architektur-Frameworks und die darin enthaltenen Erfahrungsschätze kennen. Wir diskutieren Gemeinsamkeiten und Unterschiede. Wir üben mit euch gemeinsam anhand eines Fallbeispiels, wie ihr die Frameworks zur Bewertung von Cloud-Lösungen heranziehen könnt. Ihr könnt damit schon am nächsten Tag eure eigene Anwendung beleuchten!

Für die Teilnehmer gibt es keine Voraussetzungen, um an dem Workshop teilzunehmen.

", + "persons": [ + { + "id": 40892, + "public_name": "Alexander Kaserbacher" + }, + { + "id": 40894, + "public_name": "Stefan Zörner" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2407, + "date": "2023-06-22T20:00:00+02:00", + "start": "20:00", + "duration": "00:180", + "room": "REWE digital Lounge", + "title": "GAMING NIGHT - Hack-Together: IT-Security Capture the Flag: Hack den OWASP JuiceShop", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2407", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "Ihr wollt noch in die Capture The Flag Challenge einsteigen?\r\nOder seid schon voll dabei und habt Fragen? Oder wollt sehen wie weit die anderen sind?\r\nDann kommt vorbei bei unserem Hack-Together.\r\nIn lockerer Atmosphäre nehmen wir zusammen den „Saftladen“ auseinander und diskutieren über typische Schwachstellen in Webapplikationen und wie man sie verhindert.\r\n\r\nDu willst von Anfang an mit dabei sein? Dann solltest du bereits am Mittwoch um 16:00 Uhr dabei sein! ", + "persons": [ + { + "id": 41545, + "public_name": "Simon Trockel" + }, + { + "id": 41911, + "public_name": "Daniel Klinger" + }, + { + "id": 42018, + "public_name": "Tobias Heide" + }, + { + "id": 26554, + "public_name": "Bernd Stübinger" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Mayflower Lounge": [ + { + "id": 2429, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:105", + "room": "Mayflower Lounge", + "title": "JUG Oberland: Retro chic mit Pixel-art", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2429", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

„Hinter dir! Ein dreiköpfiger Affe!“ Wer diesen Ausruf kennt, fühlt sich direkt in die Vergangenheit der Computerspiele und Point and Adventures zurückversetzt und damit auch in Spielewelten, die noch deutlich kantiger waren als heute.

Ob für Spiele, Anwendungen, Logos oder auch einfach nur zur Deko: Pixel-art liegt wieder voll im Trend. Doch wie kann man selbst Pixel-art erstellen, in einer digitalen Welt, mit einer Pixeldichte, die alles andere als kantig ist? Wie fängt man an? Welche Tools kann man nutzen? Wie kann ich meine Pixel womöglich auch noch in Bewegung bringen?

In dieser Session wollen wir uns das gemeinsam anschauen und zusammen eine Pixelfigur erstellen.

", + "persons": [ + { + "id": 22096, + "public_name": "Nina Körner" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2431, + "date": "2023-06-22T13:00:00+02:00", + "start": "13:00", + "duration": "00:165", + "room": "Mayflower Lounge", + "title": "Weniger Angst vorm Vendor Lock-In mit Hexagonaler Architektur", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2431", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Unter Vendor Lock-In versteht man laut Wikipedia \"in den Wirtschaftswissenschaften [...] die enge Kundenbindung an Produkte/Dienstleistungen oder einen Anbieter, die es dem Kunden wegen entstehender Wechselkosten und sonstiger Wechselbarrieren erschwert, das Produkt oder den Anbieter zu wechseln\".

In diesem Workshop wollen wir uns gemeinsam anschauen, wie wir diese Wechselkosten gering halten können - zumindest, was unsere eigenen Services und Functions betrifft. Dabei werden wir auch sehen, welche positiven Eigenschaften die Hexagonale Architektur auf die Testbarkeit hat.

Wir werden die Grundkonzepte der Hexagonalen Architektur vorstellen, um dann gemeinsam eine bestehende Codebase zu refactoren.
Das Format wird ein gemeinsames Ensemble (aka Mob/Team Programming) sein, d.h. alle Teilnehmenden können die gelernten Konzepte direkt anwenden.

Voraussetzungen für Teilnehmer:

Grundlegend Programmierkentnisse in Java- oder Kotlin

Teilnehmer brauchen KEINEN Laptop, dieser wird gestellt.


maximale Teilnehmerzahl: 30 Personen.

", + "persons": [ + { + "id": 41359, + "public_name": "Ferdinand Ade" + }, + { + "id": 42156, + "public_name": "Christian Franzen" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2434, + "date": "2023-06-22T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Mayflower Lounge", + "title": "Sponsored Session: Web Assembly goes Cloud – was kann das und was kommt noch?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2434", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "“If WASM+WASI existed in 2008, we wouldn’t have needed to created Docker.” Mit diesem enthusiastischen Tweet fasste der Gründer Solomon Hykes 2019 seine Einschätzung der Bedeutung von Web Assembly auf dem Server zusammen. Wie sieht es 2023 aus? In diesem Vortrag gebe ich einen Überblick über die Technologie, ihre Versprechungen und Vorteile und über den aktuellen Stand des Ökosystems.", + "persons": [ + { + "id": 39356, + "public_name": "Christian Speckner" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2435, + "date": "2023-06-22T17:00:00+02:00", + "start": "17:00", + "duration": "00:105", + "room": "Mayflower Lounge", + "title": "Distributed tracing in practice workshop", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2435", + "track": "DevOps and methodology", + "language": "en", + "abstract": "

The benefits of Node.js to develop real-time applications at scale are very well known. As Node.js architectures get more and more complex, visualization of your microservices-based architecture is crucial. However, the visualization of microservices is incredibly complex given the scale and the transactions across them. In this workshop, you will learn how to leverage service maps to instantly understand your architecture and troubleshoot any API error.

We will write a simple Express application, and integrate it with OpenTelemetry & Jaeger - two popular open-source tools for distributed tracing. We will learn how to use distributed tracing, and the benefits we can get by implementing it.

Who should attend? DevOps, Engineers, Cloud Architects, IT, Software Developers, Solution Architects and Engineers, SREs, and anyone who is running microservice-based applications (Kubernetes, containers, serverless functions, and more) in the cloud.


limit of participants: 30-40



Prerequisites

  • We prefer to use VSCode for a better experience (other IDEs are fine)
  • Preinstall npm and node
  • basic knowledge in javascript
  • a running docker (optional. if you don't have we'll use a hosted one you can access by a regular URL).
", + "persons": [ + { + "id": 42147, + "public_name": "Haddas Bronfman" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2438, + "date": "2023-06-22T20:00:00+02:00", + "start": "20:00", + "duration": "00:45", + "room": "Mayflower Lounge", + "title": "GAMING NIGHT by Modern Software Development: Stille Post mit AWS Lambdas", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2438", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "Für Leute, die gerade erst mit Serverless und Lambdas einsteigen, biete ich für Teilnehmer einen interaktiven Workshop an, bei dem man spielerisch AWS CDK, Lambdas und DynamoDB ausprobieren kann.
\r\n
\r\nEs gibt ein CDK-GitHub-Projekt, in dem die Teilnehmer per Pull Request ihre eigenen Lambdas hinzufügen können (Referenz wird vorliegen).
\r\n
\r\nJedes Lambda hat einen Text als Input, modifiziert ihn, und ruft danach einen Endpunkt auf, der wieder ein zufälliges Lambda auswählt. Dadurch entsteht wie beim Kinderspiel \"Stille Post\" aus einer Ausgangsnachricht immer etwas anderes. Jeder Zwischenschritt wird in eine DynamoDB-Tabelle geschrieben.
\r\nÜber AWS X-Ray und einen Beamer visualisieren wir in Echtzeit, wie die Nachrichten verändert werden, wenn sie durch die Lambdas der Teilnehmer geschleust werden.", + "persons": [ + { + "id": 39255, + "public_name": "Max Tharr" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Stage 1": [ + { + "id": 2491, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 1", + "title": "JUG Nürnberg: Anwendung, Laufzeitumgebung, Low-Code-Plattform? - Die gleiche Frage, wieder mal!", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2491", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Wir programmieren eine Application, indem wir eine Unmenge an Codezeilen schreiben, welche dann in einer zurückhaltenden Laufzeitumgebung ausgeführt werden. Wenn wir die Laufzeitumgebung überhaupt wahrnehmen. Wer weiß schon, was die main()-Funktion in C-Programmen alles leistet?

Wir programmieren eine App, indem wir einer übergriffigen Laufzeitumgebung eine Beschreibung der App überlassen und hoffen, dass die kuschelige und beschützende Laufzeitumgebung unsere App behütet, zur rechten Zeit anstupst und ein paar Dinge erledigen lässt. Wird die App zu lästig, wird sie schlafen gelegt.

Wir beschreiben mit schönen mehrdimensionalen Bildern einer Low-Code-Plattform was wir wollen, die artige Plattform legt los und übernimmt die Umsetzung. Magisch!

Und als ob das nicht genug wäre, kommt jetzt noch die Cloud daher. Sie bringt Microservices mit. Lauter kleinteiliges Zeug. Wie soll das Probleme lösen?


Ich habe doch nur EIN Problem und brauche daher auch nur EINE Lösung! EINEN Ansprechpartner! EINE Rechnung! EINE Verantwortung!

Wie können wir dem Management erklären, dass sich der etwas komplexer erscheinende Ansatz für aktuelle Szenarien durchaus lohnt? Was sind denn die Vor- und Nachteile der verschiedenen Ansätze? Gerne nicht nur auf der technischen Ebene.

Und natürlich hat es die gleiche Situation schon vor 30 Jahren gegeben! Was aber haben wir daraus gelernt?

Ich freue mich, ein paar Denkanstöße geben zu dürfen und diese dann mit euch zu diskutieren.

", + "persons": [ + { + "id": 19956, + "public_name": "Frank Schuetz" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2492, + "date": "2023-06-22T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "Stage 1", + "title": "JUG Nürnberg: Plug and pray", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2492", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Die Vorgaben von außen beginnen immer mit \"ich will aber, dass es so gemacht wird\" und \"wir benötigen Transaktionen\" - das Paradox der unabhängigen Microservices, die auf ihre Abhängigkeiten warten, schlägt zu.


Asynchrone Ereignisbehandlung bezieht sich eher auf unerwartet eintreffende Fehler, als dass sie Teil eines Event Storming sind. bei Produktivsetzung stellt man fest, dass alles ja auch zusammen laufen muss und man Schnittstellen besser gemanaged hätte. Außerdem ist da schon ein Microservice live, der das Gleiche tut - bloß anders.


Bei \"die einzige Konstante im Universum ist die Veränderung\" wird nicht an Heraklit von Ephesos gedacht, sondern an Schätzungen und Planungen und kontinuierliche Neubewertungen im Projekt. Trifft Gleiches oder Ähnliches zu, wenn man die Legacy-Welt der Monolithen verlässt und sich in den Nebel der Agilität und Cloud verliert, ist es eventuell Zeit für einen radikalen neuen Ansatz: agile and pray, manage and pray, code and pray, plug and pray!

", + "persons": [ + { + "id": 6423, + "public_name": "Oliver Szymanski" + }, + { + "id": 7954, + "public_name": "Ralf Ernst" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_expert" + ], + "featureTags": [] + }, + { + "id": 2493, + "date": "2023-06-22T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "Stage 1", + "title": "K8s-native Daten-Pipelines mit Quarkus und Argo et al.", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2493", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "Daten sind der neue Brennstoff für moderne digital Produkte. Aber auch Daten müssen zunächst gefördert und anschließend aufwändig raffiniert und angereichert werden bevor sie wirklich nutzbringend verwendet werden können. Die hierfür verwendeten ETL und ELT Ansätze und Tools sind dabei häufig entweder proprietär oder extrem individuell. Die Wartbarkeit und Skalierbarkeit solcher Ansätze ist leider beschränkt.
\r\n
\r\nDieser Vortrag beschreibt die Evolution und Migration einer monolithischen Datenversorgung, hinzu flexibel orchestrierbaren Daten-Services und k8s-nativen Daten-Pipelines auf Basis von Quarkus und einer Kombination verschiedener Projekte aus dem Argo Ökosystem: ArgoCD, Workflows und Events.", + "persons": [ + { + "id": 16570, + "public_name": "Mario-Leander Reimer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2494, + "date": "2023-06-22T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 1", + "title": "502 Bad Gateway: Warum Zero Downtime mehr braucht als eine Config", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2494", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

In modernen Cloudumgebungen werden Anwendungen deutlich öfter gestoppt und gestartet, als in klassischen Deployment-Szenarien. Dies liegt zum einen an immer kürzer werdenden Release-Zyklen, aber auch daran, dass Cloudarchitekturen aus mehr Deployment-Einheiten bestehen, die unabhängig voneinander deployed werden.


Noch mehr Anwendungsstopps und -starts lösen die Cloudplattformen selbst aus, da sie selbstständig die Anwendung skalieren oder Last auf ihren Knoten umverteilen. Damit bei all dem die Verfügbarkeit des Gesamtsystems stets gewährleistet ist, müssen auch wir Entwickler verstehen, was passiert, wenn unsere Anwendung in der Cloud neu gestartet wird, so dass wir wo immer nötig exakt kontrollieren können, wie der Anwendungsneustart durchgeführt wird.

In unserer Session analysieren wir am Beispiel einer Spring-Boot-Anwendung, die in einem Kubernetes-Cluster betrieben wird, wie ein Deployment/Neustart einer Anwendung abläuft. Dabei zeigen wir insbesondere auf, welche Hindernisse für Zero Downtime – allen Einstellungen für Rolling Deployments zum Trotz – nicht nur in der Anwendung, sondern auch im Zusammenspiel mit Kubernetes und weiteren Komponenten, wie Loadbalancern, Ingress etc., lauern und wie ihr dennoch echte Zero-Downtime-Deployments erreicht.

", + "persons": [ + { + "id": 38512, + "public_name": "Nikolai Neugebauer" + }, + { + "id": 24206, + "public_name": "François Fernandes" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2495, + "date": "2023-06-22T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Modernes und flexibles Identity- und Access-Management mit Keycloak", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2495", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Der effektive Umgang mit Identitäten sowie die wirkungsvolle und gleichzeitig flexible Zugriffskontrolle sind Kernanforderungen an IT-Systemlandschaften. Nicht jeder kann dabei auf die Services großer Cloudanbieter zurückgreifen, z.B. weil Datenschutzbedenken bestehen.


Wir stellen in diesem Vortrag mit der Open-Source-Lösung Keycloak von RedHat eine umfangreiche, vielfach bewährte, einfach zu nutzende und vor allem flexible IAM-Lösung vor. Dabei gehen wir zunächst auf die Kernanforderungen an ein IAM-System ein und erläutern, wie diese in Keycloak abgebildet werden. Neben den theoretischen Grundlagen vermitteln wir anhand von Beispielen eines realen Projekts, wie sich diese Konzepte in die Praxis überführen lassen.

Keycloak befindet sich gerade in einer Transformation zu einem Cloud-Native-Projekt. Wir stellen diese aktuell noch im Preview-Stadium befindlichen Änderungen vor und zeigen, wie wir sie in unserem Projekt bereits heute nutzen, um Keycloak an unsere spezifischen Anforderungen (u.a. 20 Mio. Accounts, 1000 Req/s) anzupassen.

Die in diesem Vortrag präsentierten Lösungen umfassen die Anbindung einer Apache-Cassandra-Datenbank, die Eliminierung von Infinispan als Caching-Lösung, die Umsetzung eines Configuration-as-Code-Ansatzes, sowie die Integration in fachliche Prozesse. Insbesondere gehen wir auch auf Entwicklungs- und Deploymentprozesse, die eine Menge voneinander unabhängiger Keycloak-Extensions zu einem kohärenten Ganzen zusammenfügen, ein.

", + "persons": [ + { + "id": 40726, + "public_name": "Dominik Schlosser" + }, + { + "id": 40738, + "public_name": "Stefan Klein" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2496, + "date": "2023-06-22T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Container Vulnerability Management in Kubernetes", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2496", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Mit der zunehmenden Verbreitung von Kubernetes und der Container-Technologie steigt auch der Bedarf an einem effektiven Schwachstellenmanagement.

  • Wie kann so ein Schwachstellenmanagement konkret aussehen?
  • Wie integriere ich Schwachstellenscans in meine Pipelines?
  • Wie verhindere ich, dass Schwachstellen in meine Kubernetes Umgebung deployed werden?
  • Wie behalte ich den Überblick über zur Laufzeit bekanntgewordene Schwachstellen?
  • Welche Prozesse muss ich etablieren, um die Schwachstellen zu beheben?


Ich möchte teilen, wie wir Container-Schwachstellen in Kubernetes-Umgebungen für unsere Kunden handhaben, welches Tools wir dafür nutzen und welche Prozesse wir etabliert haben, um die Priorisierung und Behebung identifizierter Schwachstellen anzugehen.

", + "persons": [ + { + "id": 41360, + "public_name": "Kevin Schu" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2497, + "date": "2023-06-22T17:00:00+02:00", + "start": "17:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Kubernetes Security - Supply-Chain-Security und Zero-Trust von Containern", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2497", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Container in Kubernetes sind ebenso anfällig für Angriffe, Exploits oder Insider-Bedrohungen wie herkömmliche Applikationsumgebungen. Damit wird das Ökosystem Kubernetes potentiell Gegenstand von ausführbarer Schadsoftware wie Ransomware, Datendiebstahl oder Cryptojacking.

Im Januar 2020 wurde zum ersten Mal eine kritische Cloud-Vulnerabilität einer Major-Cloud-Infrastruktur registriert.
Die Möglichkeiten eines Angriffs sind vielfältig und Kubernetes bietet out-of-the-box wenig relevante Sicherheitsfeatures, um Cluster, Netzwerk oder Workloads zu schützen. So kann beispielsweise über die Container-Supply-Chain Schadsoftware in Cloudanwendungen installiert und ausgeführt werden. 


Obwohl Container im Gegensatz zu herkömmlichen Anwendungen allgemein als sicherer betrachtet werden, entwickeln sich Angriffe und Angriffstechniken weiter und es gibt fortwährend neue Angriffstechniken, um Code und Infrastruktur, einschließlich Container, anzugreifen.


Um die Infrastruktur von Cloud-Anwendungen im Rahmen von Kubernetes-Applikationen besser zu sichern, sollen ein Supply-Chain-Security-Ansatz und das eigentliche Attack-Surface von Kubernetes vorgestellt werden.


Obwohl das Konzept von Zero-Trust-Sicherheit schon seit seit Jahrzehnten bekannt ist, ist seine praktische Anwendung auf Container-Umgebungen relativ neu. Zero Trust soll dabei helfen, das Vertrauenskonzept aus der Container-basierten Infrastruktur zu eliminieren. Ein Lösungsansatz wird in dieser Session vorgestellt.

", + "persons": [ + { + "id": 39497, + "public_name": "Benjamin Bajorat" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2498, + "date": "2023-06-22T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Distributed system state management: when transactions are long and SLA is high", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2498", + "track": "Microservices and Domain-driven Design", + "language": "en", + "abstract": "Distributed systems are notoriously difficult to build and manage, with a host of challenges related to transactions, state management, availability, and more. In this talk, I will share my experiences building a distributed system that is designed to be highly available, resilient to outages and disasters, and able to handle long-running processes and overcome interruptions. I will discuss how I tackled the challenges of implementing transactions and managing the state in a distributed environment, and how I was able to overcome the limitations of traditional approaches to achieving 99.99% uptime. I will also share how I was able to ensure correct error handling and avoid domain leakages, and how I made my distributed processes observable and transparent. This talk will be of interest to anyone looking to build and manage data and processes in distributed systems that are reliable and resilient.", + "persons": [ + { + "id": 41289, + "public_name": "Ilya Kaznacheev" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_expert" + ], + "featureTags": [] + }, + { + "id": 2500, + "date": "2023-06-22T20:00:00+02:00", + "start": "20:00", + "duration": "00:45", + "room": "Stage 1", + "title": "GAMING NIGHT by JUG Oberland: Wer sind wir?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2500", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Dies ist ein Beitrag zur Unterhaltung in aufgelockerter Atmosphäre zu fortgeschrittener Stunde. Das Auditorium versammelt sich um einen leeren Stuhlkreis in der Mitte. Die Moderation begrüßt die Anwesenden und stellt vor, was nun passieren wird.

Freiwillige aus dem Auditorium nehmen auf den Stühlen des Stuhlkreises Platz. Die Moderation platziert auf jeder Stirn einen Zettel mit dem Namen einer einschlägig bekannten großen IT-/Software-/Computer-Firma derart, dass der Name für den Träger nicht einzusehen, für alle anderen einschließlich Auditorium aber gut zu lesen ist.


Diese Firma ist für die Dauer der Runde die Identität des Trägers, dessen Ziel es ist, diese Identität herauszufinden.
Reihum stellen die Mitspieler im Stuhlkreis nun jeweils eine Ja/Nein-Frage zu ihrer Identität. Die Frage wird vom Rest des Stuhlkreis entsprechend beantwortet – »irrelevant« ist als Antwort zulässig, falls die Frage nicht mit der Identität in Zusammenhang steht.

Wer sich sicher ist, seine Identität zu kennen, darf eine entsprechende Vermutung äußern. Ist sie korrekt, ist das Rundenziel erreicht. Ist sie nicht korrekt, darf zu einem späteren Zeitpunkt eine andere Vermutung geäußert werden; ist diese ebenfalls nicht korrekt, scheidet der Mitspieler aus der Runde aus.

Weitere Runden können nach Gusto gespielt werden.

", + "persons": [ + { + "id": 40044, + "public_name": "Andreas Schrogl" + }, + { + "id": 40393, + "public_name": "Heiko Krämer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2734, + "date": "2023-06-22T21:00:00+02:00", + "start": "21:00", + "duration": "00:80", + "room": "Stage 1", + "title": "GAMING NIGHT - Das Cabinet des Dr. Caligari - Stummfilm-Vorführung mit Pianobegleitung", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2734", + "track": "noMainfocus", + "language": "de", + "abstract": "Für diejenigen, denen am Donnerstag-Abend der Kopf vor lauter Cloud-Themen schwirrt, haben wir etwas Entspannendes im Angebot: Das Cabinet des Dr. Caligari ist ein expressionistischer Stummfilm aus dem Jahr 1920. Der deutsche Horrorfilm gilt als ein Meilenstein der Filmgeschichte. Begleitet wird der Streifen von jemandem, der sowohl die Computer-Tastatur als auch die Klaviertasten beherrscht: Meik Kraft ist Informatik-Student und studierter Master of Music, und die Stummfilmbegleitung ist sein Steckenpferd. Freuen wir uns auf ein besonderes Erlebnis, das den Festival-Tag abrundet.", + "persons": [ + { + "id": 43513, + "public_name": "Meik Kraft" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [], + "featureTags": [ + "eventslot_feature_community_activity" + ] + } + ], + "Stage 2": [ + { + "id": 2553, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 2", + "title": "JUG Nürnberg: Modernisierung des Identity- und Access-Managements in einer großen Behörde", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2553", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Die digitale Welt ist seit längerem im Umbruch - insbesondere bei dem Thema Cloud-Architektur sowie der Abbildung von digital handelnden Personen. Einher geht, dass Software-Produkte ihre bestehenden Lösungen auf Cloud-Native ausrichten oder diese nur noch als Service in der Cloud anbieten.


Zudem treffen fachliche Anforderungen von außen auf die Organisation, die konzeptionell bisher nicht im gleichen Sonnensystem kreisten. Im privatwirtschaftlichen Bereich stellt sich diese Problematik vielleicht nicht als allzu große Nummer dar, bedeutet aber im Kontext einer öffentlichen Verwaltung eine umso größere Herausforderung.


Dieser Vortrag erläutert, welche Herausforderungen unter behördlichen Rahmenbedingungen gelöst werden müssen, um ein bestehendes Identitäts- und Access-Management-System abzulösen und dieses während des Betriebs in eine neue Cloud-Architektur zu überführen.


Dabei werden die strategische Architekturausrichtung sowie die notwendigen Veränderungen erläutert. Am Beispiel der Bundesagentur für Arbeit wird eine mögliche Lösungsarchitektur für ein neues, modernisiertes IAM-System präsentiert.
Dabei werden Einflussfaktoren, wie BSI-Richtlinien, sowie die Integration von behördlich als vertrauenswürdig eingestuften Identitäts- und Authentifizierungsverfahren eines KRITIS-Systems dargestellt.


Die Produktentscheidung für die Kernfunktionen in Form von Keycloak und die daraus folgenden weiterreichenden technischen Herausforderungen runden den Vortrag ab.

", + "persons": [ + { + "id": 2638, + "public_name": "Ulrich Gerkmann-Bartels" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2554, + "date": "2023-06-22T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "Stage 2", + "title": "How to Understand Cloud Environments (fast)", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2554", + "track": "Customer Stories", + "language": "de", + "abstract": "

Die Behörde eines der heiligsten Konstrukte des deutschen Staates, wird, auch wenn man es kaum glauben mag, immer digitaler – hierbei stellt sich die Frage, welche Personen stehen hinter dieser Umsetzung und kennt das „Arbeitsamt“ (Neusprech: Arbeitsagentur!) überhaupt den Begriff „Cloud Environment“?


In diesem Vortrag dreht sich somit alles um diese rudimentäre Frage – erläutert und ausgearbeitet wird ein Erklärungsversuch von zwei jungen Kollegen des „Cloud Infrastruktur Service Teams“ (kurz: CIST). Doch was ist die BA Private Cloud und wer sind wir eigentlich? Die Bundesagentur für Arbeit (kurz: BA) hat mit dem hausinternen IT-Systemhaus einen der größten IT-Dienstleister im öffentlichen Dienst der Welt an seiner Seite.


In diesem Konstrukt des IT-Systemhausen der BA findet sich auch das „Cloud Infrastruktur Service Team“ wieder. Das CIST ist hierbei das zentrale Glied für die Bereitstellung einer private Cloud-Lösung und fungiert somit als Cloud Service Provider innerhalb der Bundesagentur für Arbeit.

", + "persons": [ + { + "id": 40319, + "public_name": "René Wagner" + }, + { + "id": 41461, + "public_name": "Tim Heß" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_newcomer" + ] + }, + { + "id": 2556, + "date": "2023-06-22T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Präsentation ohne Aufwand: Die Magie von GPT und anderen generativen KI-Modellen", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2556", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Wie gut kann eine KI-generierte Powerpoint-Präsentation sein? Wir haben es ausprobiert und festgestellt: Gar nicht so schlecht.

Im Zeitalter von Digitalisierung und KI lassen sich viele Tasks unseres Alltags sehr einfach automatisieren. Doch das größte Joch des gemeinen Business-Kaspers, die Powerpoint-Präsentation, musste bis vor kurzem noch mühsam händisch erstellt und vorgetragen werden. Doch damit ist jetzt Schluss!


Das TNG Innovation Hacking Team präsentiert den Powerpoint Ghostwriter. Dieses KI-System benötigt lediglich einen Titel und generiert damit vollautomatisch ein komplettes Slidedeck, von den Überschriften bis zu passenden Bildern. Selbst das Vortragen wird von der künstlichen Intelligenz übernommen: Ein täuschend echter Deepfake-Avatar - trainiert mit dem Wissen des gesamten Internets - führt den Zuhörer eloquent durch die Folien.

In ihrem Vortrag geben die Vortragenden einen technischen Überblick über den Powerpoint Ghostwriter und die zugrundeliegende Künstliche Intelligenz. Anhand von anschaulichen Live-Demos wird gezeigt, wie GPT-3 Überschriften und Inhaltstexte auf Deutsch und Englisch generieren kann, Dall-E Mini die Folien mit ansprechenden Bildern füllt und wie man einen Deepfake-Avatar dazu bringt, mithilfe von Amazon Polly Folieninhalte vorzulesen.

", + "persons": [ + { + "id": 38505, + "public_name": "Martin Förtsch" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2557, + "date": "2023-06-22T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Resilient Software Design - The Past, the Present and the Future", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2557", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Resilient software design is a topic that became popular in recent years. But it is a much older and much bigger topic than most people think. In this session, we will first look at the past, from the origins of resilient software design to today.

Then we will look at resilience today: what it means and how it affects us in our professional lives way beyond just software design. How the tool landscape changed. What we can delegate to the infrastructure level and why we cannot delegate everything to the infrastructure level. How our functional design decisions affect how resilient our applications can be.

Finally, we will look at the unsolved challenges of resilient software design. We will look at emerging concepts that will become more relevant in the future and explore the resilience road ahead of us.

Be prepared for lots of interesting insights into a fascinating and more and more vital topic!

", + "persons": [ + { + "id": 11564, + "public_name": "Uwe Friedrichsen" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2558, + "date": "2023-06-22T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Geo-Analytics - Räumliche Analyse digitaler Zwillinge in der Cloud", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2558", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Das Streckennetz der Deutschen Bahn unterliegt im Betrieb und im Managements mannigfaltigen Auflagen. Um eine einen zielgerichteten und schonenden Einsatz der begrenzten Ressourcen zu ermöglichen, werden das Streckennetz und relevante Einflussfaktoren digitalisiert.


Dazu werden digitale Zwillinge mithilfe von Oracle Spatial erzeugt und diese dann räumlich zueinander in Beziehung gesetzt, um so die zu berücksichtigenden Auflagen entlang des Streckennetzes der Deutschen Bahn zu ermitteln. Anhand dieser Ergebnisse kann ein genauerer und effektiverer Einsatz von Streckenmanagement-Aktivitäten geplant werden.

Im Vortrag wird anhand des obigen Business Case gezeigt, wie aus einer Reihe von Services unter Einsatz von Oracle Spatial in einer Cloud-basierten Lösung interaktive Karten und geo-analytische Funktionen erzeugt und genutzt werden.

", + "persons": [ + { + "id": 3312, + "public_name": "Sven Bosinger" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2502, + "date": "2023-06-22T17:00:00+02:00", + "start": "17:00", + "duration": "00:45", + "room": "Stage 2", + "title": "DATEV im Wandel zur Cloud-Native-Company", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2502", + "track": "Customer Stories", + "language": "de", + "abstract": "

Die DATEV als einer der größten Softwarehersteller Deutschlands hat 2015 den konsequenten Weg eingeschlagen, sich zu einem Cloud-Native-Unternehmen zu wandeln. Die Veränderung findet auf allen Ebenen des Unternehmens statt, dies betrifft weit mehr als die Einführung von Cloud-Native-Technologien und den Aufbau eines Cloud-Native Rechenzentrums.


Neben den technischen Themen verändert sich die Art und Weise, wie das gesamte Unternehmen arbeitet. Auf diesem Weg der Transformation hat DATEV erkannt, dass die grundlegende Organisationsstruktur nicht zu einem am Wertstrom orientierten Unternehmen noch DevOps-Prinzipien passt. Somit wurde in 2019 die komplette Organisationsstruktur geändert, um im Unternehmen die Voraussetzungen für einen erfolgreichen Weg in die Cloud-Native-Welt zu schaffen.


Die Session beleuchtet, welche Herausforderungen in einem Unternehmen mit über 8.000 Mitarbeitern bewältigt werden müssen, um eine erfolgreiche Transformation von einem klassischen IT-Unternehmen zu einem kundenzentrierten Cloud-Native-Unternehmen zu bewältigen.


Die Herausforderungen sind vielfältig und reichen vom konsequenten Wandel der eingesetzten Frameworks, über Veränderung der Kundenkommunikation, um Countinous Delivery zu unterstützen, bis hin zur Portfoliosteuerung und zum Verhalten der Führungskräfte. Ich möchte über Erfolge und Hindernisse berichten sowie harte Nüsse, die wir noch knacken müssen.

", + "persons": [ + { + "id": 42110, + "public_name": "Michael Schmidt" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_expert" + ], + "featureTags": [] + }, + { + "id": 2560, + "date": "2023-06-22T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Refuctoring [sic!] - Spielerisch den Wert von Code-Qualität erleben!", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2560", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Refactoring ist eine nützliche Methode, um durch Code-Verbesserungen möglichst lange die Wartbarkeit einer Software sicherzustellen. Aber habt ihr schon mal erlebt, was mit einer Codebase passiert, wenn man alle guten Techniken weglässt und den Code vorsätzlich verschlechtert? Wie lange dauert es wohl, bis der Code bis zur Unkenntlichkeit verunstaltet ist und man nicht mal seinem schlimmsten Feind das Maintaining wünscht?

Genau darum wird es bei dieser Session gehen! Wir fangen mit einer einfachen Coding-Übung (Fizz-Buzz) an, die vollständig mit Tests abgedeckt ist. Im Mob Programming gebt ihr mir Tipps, wie ich den Code schlechter machen kann. Solange die Tests alle grün bleiben und sich die öffentliche API nicht ändert (wir wollen ja unter dem Radar bleiben ;-)), ist alles erlaubt!

Am Ende haben wir mindestens Spaß gehabt und evtl. auch etwas über den Wert von Refactoring und guter Code-Qualität gelernt. Hinweis: dieser Beitrag funktioniert besser mit Bier!

", + "persons": [ + { + "id": 40148, + "public_name": "Christoph Welcz" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2562, + "date": "2023-06-22T20:00:00+02:00", + "start": "20:00", + "duration": "00:45", + "room": "Stage 2", + "title": "GAMING NIGHT - Jeopardy in den IoT-Wolken", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2562", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Die durch Mitarbeiter:innen hergestellte Buzzer-Hardware und die dazu individuell entwickelte Software, auf Basis eines ESP32, ermöglichen ein interaktives Showformat mit mehreren Teilnehmern auf einer Bühne.

Rätsel, Fragen und Herausforderungen im spielerischen Format zu erleben, motiviert Zuschauer und Teilnehmer gleichermaßen, sich mit spezifischen Themen auseinanderzusetzen.

Mit bis zu vier Teilnehmer:innen kann eine Quiz-Show im Format von z.B. Jeopardy (oder anderen bekannten Shows) gespielt werden. Geleitet wird das Format durch einen Moderator der viadee, der auch Inhalte und Themen über die Fragen und Antworten hinaus vermittelt. Für die Teilnehmer:innen können zur Motivation kleinere Preise ausgegeben werden.

", + "persons": [ + { + "id": 39768, + "public_name": "Markus Pepping" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2563, + "date": "2023-06-22T21:00:00+02:00", + "start": "21:00", + "duration": "00:45", + "room": "Stage 2", + "title": "GAMING NIGHT by JUG Oberland: The Original CloudLand Jeopardy", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2563", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "- vier Leute
\r\n- vier unkaputtbare? Buzzer
\r\n- 5 Kategorien
\r\n- 5 Antworten pro Kategorie
\r\n- 2 oder 4 Runden (je nach Bedarf)
\r\n- abschließend eine zusätzliche Runde mit den Erst- und Zweitplatzierten der Vorrunde
\r\n- 2 Moderatoren
\r\n- Mitfiebern inbegriffen: Gesucht sind die Fragen zu den Antworten! Nicht gefundene Fragen werden vielleicht durch das Publikum erraten.
\r\n
\r\nGeboten wird: Eine Bühnenshow in Anlehnung an das Fernsehquiz Jeopardy! mit Teilnehmern aus dem Publikum.
\r\n
\r\nDie Antworten (und Fragen) sind aus den Bereichen Allgemeinwissen, Allgemeines Nerdtum, Cloud-Technologien und IT.", + "persons": [ + { + "id": 40393, + "public_name": "Heiko Krämer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + } + ], + "Stage 3": [ + { + "id": 2589, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Make Developers Fly: Principles for Platform Engineering", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2589", + "track": "DevOps and methodology", + "language": "en", + "abstract": "How can your company help developers to fly, but not crash down? The answer is platform engineering, which is the discipline of building and operating self-service internal developer platforms (IDPs) to simplify software delivery and life cycle management for product teams. \r\n\r\nIn this talk, you will learn how platform engineering evolved from the DevOps movement and what principles and best practices make a good implementation. Finally, we take a look at reference architectures that can power your platform.", + "persons": [ + { + "id": 42101, + "public_name": "Robert Hoffmann" + }, + { + "id": 40139, + "public_name": "Alex Krause" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2590, + "date": "2023-06-22T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Aufbau eines Digital Service Catalog mit Backstage.io", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2590", + "track": "Customer Stories", + "language": "de", + "abstract": "

Wir berichten euch über unsere Erfahrungen mit Backstage.io beim Aufbau eines digitalen Service-Katalogs.

Mit Backstage.io (CNCF Incubation Projekt, siehe https://backstage.io für Details) lassen sich Applikationen im Unternehmen sammeln und an einer zentralen Stelle für alle zur Verfügung stellen. Dabei bietet Backstage.io weitaus mehr Features als die typischen Developer Portals. Nicht nur REST und GraphQL APIs können exposed und via Swagger-UI dokumentiert und konsumiert werden. Auch eine direkte Integration und Sichtbarkeit von beispielsweise Metriken direkt aus Deployments ist möglich.

Über zahlreiche Add-ons und Plugins werden diverse Plattformen, Tools und Technologien unterstützt. Die Konfiguration liegt dabei in der Ownership der Scrum Teams, welche an den Services arbeiten und diese implementieren. Backstage.io nutzt direkt das jeweilige Git Repo und lädt von dort Konfiguration und Elemente für den Service-Katalog. Mittels Templates lassen sich initiale Setups beschreiben und bereitstellen, mit deren Hilfe die Entwickler mit wenigen Klicks eine lauffähige neue Instanz mit eigenem Git Repo inkl. CI/CD Support generieren können. Von dort aus startet dann die Implementierung. Im Unternehmen lassen sich so Standards etablieren und Wissen in die Teams verteilen.

", + "persons": [ + { + "id": 39468, + "public_name": "Alexander Troppmann" + }, + { + "id": 42103, + "public_name": "Bastian Heilemann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2622, + "date": "2023-06-22T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Building Reliable Serverless Applications with AWS CDK and Testing", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2622", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "AWS CDK is an IaC (Infrastructure as Code) Framework that allows developers to easily create and manage serverless applications by combining various AWS resources such as Lambda, API Gateway, and DynamoDB tables with just a few lines of code. While CDK greatly simplifies the process of building and deploying these types of applications, it is still important to verify that they are functioning as expected.
\r\n
\r\nIn this talk, we will delve into the different ways of testing CDK apps to ensure their reliability, using a real-world example to illustrate the concepts discussed. This will include a discussion of unit testing Lambda functions, snapshot testing, and fine-grained assertion testing of CDK stacks. We will also explore the importance of integration testing in gaining confidence in your application, and demonstrate how to split an application into smaller, more manageable components that can be deployed and tested individually.
\r\n
\r\nBy the end of this talk, attendees will have gained a thorough understanding of the various testing techniques available when working with CDK, and will be equipped with the knowledge and skills to confidently ensure the reliability of their serverless applications through effective testing practices.", + "persons": [ + { + "id": 41837, + "public_name": "Raphael Manke" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2592, + "date": "2023-06-22T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Zero Trust: Wie die Cloud sicherer als der eigene Rechner wurde", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2592", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Viele von uns erinnern sich noch gut an die Zeiten von Firewalls, DMZs und Intranets. Damals reichte es aus, wenn die Einbrecher nicht auf die eigenen Server kamen.


Das ist heute, in den Zeiten von Cloud, verteilten Applikationen und eigenen Lösungen, die viele fremde NPMs und Docker-Container anziehen, längst nicht mehr genug. Wenn ich 100 fremde NPMs, 20 Docker-Container und 10 externe Services auf 20 fremden Rechnern laufen lasse - wie kann ich dann meiner eigenen Software noch trauen?

Wie sorge ich mit Werkzeugen wie SigStore dafür, dass in meiner Supply Chain nur Software läuft, der ich tatsächlich vertraue? Und wie sorgen Protokolle wie SPIFFE dafür, dass ich bei jeder Kommunikation immer sicher weiß, dass ich der anderen Seite meiner API voll vertrauen kann? 

In dieser Session erfahrt ihr, warum es fahrlässig wäre, die eigenen Lösungen unsicher On-Premises und nicht in der Sicherheit der Cloud zu nutzen.

", + "persons": [ + { + "id": 41900, + "public_name": "Johann-Peter Hartmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2593, + "date": "2023-06-22T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Sovereign Cloud Stack: Converting the vision into action", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2593", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "The still young Sovereign Cloud Stack project from the Open Source Business Alliance and funded by the BMWK presented its vision in a keynote in CloudLand 2022.
\r\nThe project staff, the community and the partners have been working very hard to deliver on the plan. A good time to analyze what works and what does not.
\r\nThe project is full of challenges: A small team, trying to lead a motivated, but diffuse community to agree on standards. A infrastructure-focused community, standing on the shoulders of Open Source giants (Linux, OpenInfra, CloudNative communities), yet competing for attention with VC-funded \"open source companies\". A small team, trying to establish a new level of sharing with the Open Operations movement.
\r\nKurt Garloff will lead the audience through the progress, the ups and downs and learnings.
\r\nThe audience will learn about some technical aspects of the standards, the reference implementation and the operations practices, but these are mainly the illustration around the more general theme how trying to reconcile a vision with a plan that was good enough to receive public funding with working with an open source community of companies and individuals that all follow their own goals and yet somehow contribute to the project.", + "persons": [ + { + "id": 40079, + "public_name": "Kurt Garloff" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2594, + "date": "2023-06-22T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Die Cloud im Entwickleralltag der Bundesbehörde BAMF", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2594", + "track": "Customer Stories", + "language": "de", + "abstract": "Aus der Entwickler-Rolle heraus, möchte ich einen Überblick über das entwickeln auf einer On-Premise-Cloud des BAMF geben.
\r\nVorgestellt wird der agile Entwicklungsprozess, sowie die Organisation in die er eingebettet ist. Weiter zu eigentlichen Applikation und deren Komponenten-Sicht.
\r\nBesonderer Aufmerksamkeit erhalten die Entwicklertätigkeiten um ein Feature zu implementieren - der Weg einer User Story im ALM-System bis zum ausgerollten Feature. Über den Quellcode in git, den Review des Pull-Requests, die Verwendung von Sonraqube für Qualität und Aqua für Security, bis zu den automatischen Pipelines die die Applikation auf mehrere Zielsysteme verteilen, durch die Nutzung von Gitops, Tekton & ArgoCD.
\r\n", + "persons": [ + { + "id": 41120, + "public_name": "Martin Möbius" + }, + { + "id": 42649, + "public_name": "Thomas Miederer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2595, + "date": "2023-06-22T17:00:00+02:00", + "start": "17:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Unsere \"Karte des Herumtreibers\": Dokumentation und Monitoring von Microservices", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2595", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Stellt euch vor, ihr habt Zugang zu einer \"Karte des Herumtreibers\" für eure Systemlandschaft - genau wie Harry Potter in der Schule von Hogwarts. Diese Karte zeigt nicht nur, wo sich jeder einzelne Microservice befindet, sondern gibt euch auch wichtige Informationen darüber, wie diese miteinander interagieren.

Genauso wie Harry und seine Freunde die Karte des Herumtreibers verwenden, um die Geheimnisse von Hogwarts zu entdecken, könnt ihr diese Karte verwenden, um die Leistung und Sicherheit eurer Microservices zu überwachen und zu optimieren.


Wir werden euch durch die Anfänge unserer Reise zu einer solchen Karte führen, beginnend mit ersten Versuchen mit Tools wie OpenTracing und Jaeger. Dabei erkannten wir schnell, dass diese Lösungen nicht alle unsere Anforderungen erfüllten. Daraufhin haben wir uns tiefer mit Azure Monitor und weiteren Konzepten beschäftigt, um die Überwachung von Microservices besser zu verstehen und zu dokumentieren.


Hierfür haben wir unser eigenes Visualisierungskonzept entwickelt, das wir euch in dieser Session zeigen - genauso wie Harry und seine Freunde Gefahren auf der Karte des Herumtreibers erkennen und meistern, können wir mit unserer Karte Microservices in unserer Landschaft überwachen und Fehler schneller erkennen.

", + "persons": [ + { + "id": 41400, + "public_name": "Michaela Kreipl" + }, + { + "id": 41459, + "public_name": "Merlin Becker" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2596, + "date": "2023-06-22T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Evolution zu einer On-Premises Cloud aus Bausteinen (in einer Behörde)", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2596", + "track": "Customer Stories", + "language": "de", + "abstract": "

In vielen größeren Institutionen gibt es noch jede Menge Software, die eher monolithisch aufgebaut ist und häufig in Applikation-Servern auf dedizierten virtuellen Maschinen von einem eher klassisch aufgestellten und organisatorisch separierten IT-Betrieb betrieben wird.

In Fachzeitschriften, Online-Artikeln und auf Konferenzen wird vorgeführt, wie einfach es doch ist, einen Hello-World Spring Boot Microservice mit mehreren Instanzen auf Kubernetes zu deployen. Doch zurück im Unternehmen wird klar: Sollte man es tatsächlich schaffen, alle notwendigen Personen davon zu überzeugen, ab sofort Kubernetes einzuführen, wird das für einen (meist auch personell am Limit arbeitenden) IT-Betrieb schnell zu einem Projekt mit vermutlich ein bis zwei Jahren Laufzeit (je nach Erfahrung) - verbunden mit möglichen Seiteneffekten wie reduzierter Handlungsfähigkeit für das laufende Geschäft und dem Zurückstellen anderer Modernisierungsmaßnahmen.

In diesem Vortrag werden wir die sich kontinuierlich entwickelnde (evolving) Architektur einer Anwendungslandschaft hin zu Cloud Native betrachten und dabei (Open-Source) Werkzeuge für die schrittweise Anpassung der On-Premises-Infrastruktur - ohne Kubernetes oder OpenShift - kennenlernen.

", + "persons": [ + { + "id": 12172, + "public_name": "Stephan Kaps" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2598, + "date": "2023-06-22T20:00:00+02:00", + "start": "20:00", + "duration": "00:45", + "room": "Stage 3", + "title": "What you always wanted to know about SRE * but were afraid to ask", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2598", + "track": "DevOps and methodology", + "language": "en", + "abstract": "If you approach Site Reliability Engineering (SRE) for the first time you might be asking yourself a lot of questions:
\r\n
\r\n* What exactly is SRE?
\r\n* How are the major companies doing it?
\r\n* Does this work for me too?
\r\n* Can I only pick certain parts or do I need to go all-in?
\r\n
\r\nI asked myself these and many other questions over the past years while doing, leading and scaling SRE.
\r\nNot everything was the same way you read it in the books. And even if, sometimes reality throws a wrench into your efforts.
\r\n
\r\nThis talk will look at examples that did and did not work for me in the past years and how this time has shaped my views on SRE.", + "persons": [ + { + "id": 39030, + "public_name": "Bastian Spanneberg" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + } + ], + "Stage 4": [ + { + "id": 2620, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:105", + "room": "Stage 4", + "title": "Kong 101 – Einstieg in die Welt der API Gateways", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2620", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

APIs begegnen uns täglich und sind fast in allen Aspekten unseres täglichen Lebens präsent. Wenn wir zum Beispiel im Supermarkt mit einer Karte bezahlen, erfolgt die für die Transaktion erforderliche Kommunikation im Hintergrund über APIs. Dies birgt Sicherheitsrisiken und es müssen Maßnahmen ergriffen werden, um sicherzustellen, dass nur berechtigte Verbraucher auf die APIs zugreifen können und dass die APIs rund um die Uhr verfügbar sind.


Ein API-Gateway kann hierbei helfen, indem es als zentraler Zugriffspunkt für APIs fungiert und dabei hilft, einen gemeinsamen Policy-Layer zu etablieren, der API-Consumer und -Provider voneinander entkoppelt. Kong ist eine Open-Source-API-Gateway-Implementierung, die für Geschwindigkeit, Skalierbarkeit und Flexibilität ausgelegt ist. Sie ist plattform- und systemunabhängig und eignet sich daher ideal für den Aufbau von verteilten API-Umgebungen.


In diesem Workshop werden wir die Grundkonzepte von Kong, die Gateway-Architektur, Möglichkeiten zur Einrichtung einer Kong-Umgebung sowie das Deployment und die Konfiguration von APIs behandeln. Durch praktische Übungen haben die Teilnehmer die Möglichkeit, selbst zu erleben, wie einfach und intuitiv die Arbeit mit APIs unter Verwendung von Kong sein kann.


Voraussetzungen für Teilnehmer:

  • Laptop
  • Installierte Software: Docker, Docker-compose
", + "persons": [ + { + "id": 7931, + "public_name": "Sven Bernhardt" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2591, + "date": "2023-06-22T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Datenschutz in der Cloud - Löst Confidential Computing das Problem?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2591", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Möchte man die Cloud-Dienste von AWS, Azure oder Google nutzen, stellt sich unmittelbar die Frage nach dem Datenschutz. Dürfen die Daten bei amerikanischen Anbietern gespeichert und verarbeitet werden? Dem könnte man relativ einfach zustimmen, wenn die Daten at Rest und at Runtime zu jedem Zeitpunkt vollständig verschlüsselt wären, so dass weder der Cloud-Anbieter noch die amerikanischen Behörden etwas mit den Daten anfangen könnten.


\r\n\r\n

Und genau diese Möglichkeit bietet Confidential Computing insbesondere beim Einsatz von Secure-Enclave! In dieser Fishbowl-Session wollen wir mit Datenschutz-, Cloud- und Security-Expert:innen diskutieren, inwieweit die juristischen und technischen Probleme heute schon lösbar sind und wie durch die Cloud mehr Sicherheit erreicht werden kann.

", + "persons": [ + { + "id": 41992, + "public_name": "Florian Kretschmer" + }, + { + "id": 41999, + "public_name": "Victoria Neiazy" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2623, + "date": "2023-06-22T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Clean Code für DevOps und SysAdmins", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2623", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Softwareentwickler kennen Clean Code bereits seit vielen Jahren. Es gehört zu ihrem täglich Brot und Butter. SysAdmins hingegen, vor allem im Windows-lastigen Deutschland, können nicht von sich behaupten, bereits Kontakt mit dem Clean-Code-Ansatz gehabt zu haben. Aber gerade heute, wo Software-Entwicklungs-Skills durch Tools wie Terraform, Ansible und auch Powershell immer mehr beim SysAdmin vorausgesetzt werden, wird auch Clean Code in ehemals GUI-lastigen Gebieten wichtig.

Der Vortrag gibt einen Überblick, wie man sauberen und lesbaren Code schreibt, speziell mit Fokus auf SysAdmins. Dies wird an Beispielen mit Terraform und Powershell gezeigt. 

Im ersten Teil behandeln wir typische Maßnahmen, die zu Clean Code führen, wie Convention over Configuration. Im zweiten Teil geht es um Software-Tools, die dabei unterstützen. Wie auch einige andere Sprachen bringt Terraform ein eigenes Tool zur Formatierung mit. Auch ist es möglich, mit dem Editorconfig-Projekt einen konsistenten Coding Style in Projekten zu implementieren.

Übrigens: Wie in der typischen Software-Entwicklung gilt auch bei Terraform oder Powershell, dass Code länger gelesen als entwickelt wird.

", + "persons": [ + { + "id": 40245, + "public_name": "Janno Tjarks" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2624, + "date": "2023-06-22T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Quarkus on Azure", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2624", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "Quarkus is the framework of choice for cloud-native, open standards based Java solutions. Join Java Champion and Microsoft Principal Architect Ed Burns for a breadth-first, comprehensive tour of all the ways to run Quarkus on Azure. This overview session covers Quarkus on Azure {Functions, Container Apps, Kubernetes Service, Red Hat OpenShift}.
\r\nAfter the tour comes the analysis. Ed will examine why companies are using Quarkus on Azure and explore the scenarios where Quarkus is a good fit, when it is not, and how Quarkus compares to Spring Boot. The session will close by exploring migration strategies to evolve your existing cloud-based workloads into Quarkus.", + "persons": [ + { + "id": 38565, + "public_name": "Sandra Ahlgrimm" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2625, + "date": "2023-06-22T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Optimization of CI/CD pipelines", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2625", + "track": "CI / CD and automation", + "language": "en", + "abstract": "In this talk we take a detailed look at several optimization techniques to speed up CI/CD pipelines in platforms like GitLab or Azure DevOps. Pipelines need to finish as quickly as possible, because fast feedback is important for development teams. If a pipeline takes longer than a few minutes to run, development productivity drops: developers can often not use the waiting time, and switching to a different task for just 15 minutes is inefficient.
\r\n
\r\nTo reduce the total pipeline execution time, we present various tricks to \"cut corners\". We look at optimizing the job dependency graph to parallelize jobs, job tuning, and caching, comparing the CI/CD platform's integrated caching with Docker's layer/mount caching. We also look at self-hosted CI/CD agents that run in Kubernetes, which offers autoscaling and has lower maintenance overhead, compared to running agents on manually-managed VMs. For the Azure DevOps platform, which does not officially offer Kubernetes-based agents, we present a self-made approach based on KEDA that efficiently provisions build agents. That approach was built by our customer, an international logistics group based in Bonn.
\r\n
\r\nAbout the speaker: Marius Shekow is a DevOps and cloud engineer at SprintEins in Bonn, Germany. At SprintEins he strengthens the company's skills in cloud-related software engineering practices, such as Continuous Integration, Delivery & Deployment (CI/CD), testing, or Infrastructure as Code.", + "persons": [ + { + "id": 39354, + "public_name": "Marius Shekow" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2626, + "date": "2023-06-22T17:00:00+02:00", + "start": "17:00", + "duration": "00:45", + "room": "Stage 4", + "title": "JUG Oberland: Scrum und OPS / Scrum vs. OPS - Eine Diskussionsrunde", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2626", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

In dieser  interaktiven Fishbowl-Session beschäftigen wir uns u.a. mit folgenden Fragen:


- Ist Scrum etwas für Betriebsteams oder nicht?
- Passen die Scrum-Methodik und operationaler Betrieb zusammen?
- Kann Scrum den DevOps-Prozess unterstützen?
- Ist eine Rahmen-Vorgabe (Scrum) etwas für die täglich wechselnden Anforderungen des Betriebs?
- Welche alternativen Möglichkeiten gibt es?

Diskutiert mit uns ergebnisoffen - bringt eure Argumente in die Diskussion ein und helft dabei, den Meinungsbildungsprozess zu unterstützen!

Organisiert ist das Format als Fishbowl-Diskussion mit maximal vier Diskussionsteilnehmern auf einer Bühne. Dort gibt es fünf Stühle, von denen einer immmer unbesetzt bleiben muss.

Die Teilnehmer kommen aus dem Publikum. Jeder kann an der Diskussion teilnehmen, indem er auf die Bühne
geht und den leeren Stuhl belegt. Ist hiernach kein weiterer Stuhl frei, wird die Diskussion kurz unterbrochen,
bis ein Teilnehmer die Bühne verlässt (weil er z.B. nichts mehr beizutragen hat). Sobald ein Stuhl wieder frei ist,
kann weiter diskutiert werden. Weitere Teilnehmer aus dem Publikum können auf die Bühne kommen und den freien Stuhl belegen.

Es gibt dabei keine gesetzten Teilnehmer, sprich keine Teilnehmer, die initial starten oder die Bühne nicht verlassen sollen.

", + "persons": [ + { + "id": 42088, + "public_name": "Nadine Süß" + }, + { + "id": 40393, + "public_name": "Heiko Krämer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2627, + "date": "2023-06-22T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Vom Monoliten zur Cloud: Eine Modernisierung mit Quarkus und Kubernetes", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2627", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "In unserem Vortrag beschreiben wir die Umwandlung unseres Reporting-Servers, des Jasper4Oracle-Servers, von einem Standalone Monoliten zu einer Cloudnative Applikation.
\r\nWir werden die Gründe erläutern, die uns dazu veranlasst haben, diesen Schritt zu gehen und welche Anforderungen an Skalierbarkeit und Ausfallsicherheit wir erfüllen wollten.
\r\n
\r\nEin wichtiger Teil unseres Vortrags wird sich auf die Technologie Quarkus mit Ausflügen in den Bereich Kubernetes konzentrieren. Quarkus als hat es uns ermöglicht unsere Anwendung nach modernen Software-Architekturpattern umzustellen.
\r\nWir werden erläutern, wie Quarkus uns geholfen hat, sowohl die Entwicklung als auch den Betrieb der Anwendung zu beschleunigen und die Anwendung leichter zu skalieren.
\r\n
\r\nWir werden erläutern, wie wir Kubernetes nutzen, um die Verfügbarkeit und Skalierbarkeit der Anwendung zu garantieren.
\r\n
\r\nEine der Herausforderungen bei der Migration zu einer Cloudnative Applikation ist die Synchronisation von mehreren Pods, die über mehrere Instanzen verteilt sind. Dazu stellen wir sicher, dass alle Instanzen die gleichen Daten haben und dass die Daten in Echtzeit synchronisiert werden.
\r\n
\r\nInsgesamt werden wir unsere Erfahrungen und Herausforderungen bei der Umwandlung des Jasper4Oracle-Servers in eine Cloudnative Applikation teilen und die Vorteile der cloudnative Architektur gegenüber der klassischen monolitischen Architektur darlegen.", + "persons": [ + { + "id": 22035, + "public_name": "Philipp Ostmeyer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2629, + "date": "2023-06-22T20:00:00+02:00", + "start": "20:00", + "duration": "00:45", + "room": "Stage 4", + "title": "Mein Code ist meine Dokumentation... nur ist der nicht immer Zielgruppengerecht", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2629", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "Dokumentation ist in der Regel nicht das Lieblingsthema von Entwicklern. Häufig fällt es bei der täglichen Arbeit auch ganz unter den Tisch. Wenn es jedoch darum geht sich als Entwickler in ein bestehendes Projekt einzufinden oder außenstehenden einen Überblick zu verschaffen, ist eine gute Dokumentation ein wichtiger Faktor.
\nLeider ist eine bestehende Dokumentation daher häufig nur bedingt aktuell und hilfreich oder im schlechtesten Fall abweichend zur Realität. Die Wahrheit steckt daher immer noch im Code... nur ist der nicht immer Zielgruppengerecht.
\nIn diesem Vortrag werden Techniken und Best-Practices für Java gezeigt, um eine Dokumentation aus dem Programmcode und Annotations abzuleiten und damit auf den vorhandenen Informationen aufzusetzen und diese aufzubereiten.", + "persons": [ + { + "id": 38526, + "public_name": "Michael Twelkemeier" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + } + ], + "QAware Lounge": [ + { + "id": 2652, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "QAware Lounge", + "title": "From Zero to Hero – Best Practices aus cloud-native GitOps-Projekten", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2652", + "track": "Customer Stories", + "language": "de", + "abstract": "Die Migration einer bestehenden IT-Infrastruktur Landschaft hin zu einem cloud-native GitOps Ansatz ist für die meisten CloudOps/DevOps Teams eine große Herausforderung. Wir sehen immer wieder Teams, die das Rad neu erfinden wollen oder sich an simple Prinzipien wie z.B. https://12factor.net oder KISS nicht halten. Das hat teilweise katastrophale Folgen. Doch wo fängt man am besten an? Wo sind die Pitfalls? \r\n\r\nAntworten auf solche Fragen werden wir euch in diesem Talk liefern. Wir zeigen euch unser OpenSource Setup welches Cloud unabhängig funktioniert und wir für alle unsere Kunden einsetzen. \r\nIn der Live-Demo während des Talks werden wir bei 0 anfangen und anschließend mehrere Services (z.B. traefik, kafka, nextcloud etc.) mithilfe von ArgoCD aufsetzen. \r\n\r\nFalls euch das Setup gefällt, könnt ihr es direkt auch hier auf der CloudLand in unserem nachfolgenden Workshop “From Zero to Hero – GitOps Workshop mit K8s/Terraform/ArgoCD auf Open Telekom Cloud” ausprobieren. \r\n", + "persons": [ + { + "id": 40105, + "public_name": "Victor Getz" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2653, + "date": "2023-06-22T12:00:00+02:00", + "start": "12:00", + "duration": "00:165", + "room": "QAware Lounge", + "title": "Policy Driven Microservices mit Open Policy Agent", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2653", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "Robustes und sicheres Continuous Deployment braucht getestete Konfigurationen. Manuelle Review-Prozesse sind langsam und eklig. Werkzeuge gibt es viele, alle mit eigenen Konzepten und begrenzten Einsatzbereichen. Genauso schaut es bei Autorisierung und Anwendungskonfiguration aus. Es wäre doch schön, wenn es ein kleines, schlankes Werkzeug gäbe, um Policies überall einheitlich umzusetzen.
\n
\nDer Open Policy Agent (OPA) ist eine generische, cloud-native Open Source Policy Engine. OPA ermöglicht es, Policies einheitlich zu definieren und an vielen Stellen im Betriebs-, Deployment- und Entwicklungs-Stack umzusetzen, unter anderem für Autorisierung, Prüfung von Konfigurationen, Admission Control oder jeder anderen Art von Policies.
\nIn diesem Workshop lernst du OPA Hands-on kennen und erwirbst die Kompetenz, OPA produktiv einzusetzen.
\n
\nInhalte:
\n- Was ist OPA, wie funktioniert es und was kann es leisten?
\n- Hands-On:Policies in Rego definieren
\n- Hands-On:Autorisierung in einer (Java-)Anwendung mit OPA
\n- Hands-On:Anwendungsunabhängige Autorisierung mit dem OPA Envoy Plugin
\n- Hands-On:Konfigurationen und andere strukturierte Daten automatisiert mit OPA conftest prüfen
\n- Hands-On:Kubernetes Admission Control mit OPA Gatekeeper
\n
\nVoraussetzungen: Zielgruppe für den Workshop sind Techniker im weiteren Sinn. Ihr solltet programmieren können, braucht aber keine speziellen Vorkenntnisse.
\nIhr braucht keine spezielle Software auf euren Rechner, wir wollen gitpod.io nutzen.", + "persons": [ + { + "id": 21587, + "public_name": "Andreas Zitzelsberger" + }, + { + "id": 40139, + "public_name": "Alex Krause" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2656, + "date": "2023-06-22T15:00:00+02:00", + "start": "15:00", + "duration": "00:105", + "room": "QAware Lounge", + "title": "Cloud Simplified: Unser Weg zur Developer-Plattform", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2656", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "Wir alle wissen, dass Cloud geil ist. Aber wir wissen auch, dass Cloud kompliziert ist. Wie bekomme ich es also hin Entwicklern, die heute bereits alle Themen von der Fachlichkeit, über Backend & Frontend, bis zu FinDevSec…Ops abdecken sollen, nicht mit weiteren Tools und Frameworks zu erschlagen?\r\nWie andere Firmen auch sind wir bei FLYERALARM zu dem Schluss gekommen, dass wir eine Developer-Plattform aufbauen wollen. Unsere Vision ist, dass diese durch eine passende Abstraktion die Entwickler kognitiv entlastet und uns dabei gleichzeitig unterstützt unsere Standards im Bereich Security, Verfügbarkeit und Wartbarkeit zu erhöhen. In der Realität stehen wir noch recht am Anfang, aber fertige Dinge kann ja jeder zeigen. :)\r\nIn dieser Session wollen wir euch nicht nur erzählen und zeigen, was wir bisher aufgebaut haben und was uns dabei geritten hat, sondern gerne auch eure Meinung dazu hören und den einen oder anderen Punkt durchdiskutieren der uns selber noch nicht klar ist.\r\n", + "persons": [ + { + "id": 43417, + "public_name": "Daniel Hauck" + }, + { + "id": 43403, + "public_name": "Jan Schürmann" + }, + { + "id": 20734, + "public_name": "Michel Hartmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2659, + "date": "2023-06-22T18:00:00+02:00", + "start": "18:00", + "duration": "00:45", + "room": "QAware Lounge", + "title": "JUG Oberland: Let's Read Code Together", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2659", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

In einer kleinen Runde kommen 10 bis 15 Leute zusammen und lesen zusammen Source-Code. Zu Beginn der Veranstaltung wird aus einer Reihe von vorgegebenen Source-Codes einer für diese Session ausgewählt. Auf einem Beamer wird der Source-Code für alle sichtbar präsentiert. Teilnehmer dürfen gerne auf einem eigenen Laptop mitlesen und recherchieren.


Einer der Teilnehmer wird als Leser bestimmt. Er liest eine Code-Zeile vor und sagt kurz, was diese Code-Zeile bedeutet/implementiert. Die nicht vorlesenden Teilnehmer ergänzen und tragen ihr Wissen zur Bedeutung dieser Code-Zeile bei. Wenn keine weiteren Anmerkungen zur Code-Zeile aus dem Teilnehmer-Kreis vorliegen, wird die nächste Zeile vorgelesen.


Nach einiger Zeit wird der Vorlesende gewechselt. Dies geschieht, bis vom Vortrags-Slot noch ca. 10 Minuten übrig sind.
Abschließend gibt es eine kleine Feedback-Runde, in der die Erfahrungen der Teilnehmer zusammengefasst werden.


Ziel ist es nicht, den kompletten Source-Code zu lesen, sondern ein gemeinsames Verständnis für den gelesenen Code zu erlangen. Vorwissen wird nicht benötigt. Es ist natürlich hilfreich, wenn ein paar Teilnehmer schon einmal Code gesehen haben, aber theoretisch geht es auch ganz ohne Vorwissen.

", + "persons": [ + { + "id": 40045, + "public_name": "Jan Klippel" + }, + { + "id": 42028, + "public_name": "Florian Haftmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + } + ], + "Community Hall": [ + { + "id": 2743, + "date": "2023-06-22T10:45:00+02:00", + "start": "10:45", + "duration": "00:10", + "room": "Community Hall", + "title": "Begrüßung", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2743", + "track": "noMainfocus", + "language": "de", + "abstract": "", + "persons": [ + { + "id": 17, + "public_name": "Fried Saacke" + }, + { + "id": 6970, + "public_name": "André Sept" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [], + "featureTags": [] + }, + { + "id": 2685, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:480", + "room": "Community Hall", + "title": "Innovation Hacking Showcases im Expo-Bereich", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2685", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Euch erwartet eine Anzahl an innovativen Showcases des Innovation Hacking Teams der TNG Technology Consulting GmbH, inklusive Realtime Deepfakes, Realtime Style Transfer, Music AI, PowerPoint GhostWriter AI und vielen mehr.

Erlebt das futuristische Potenzial von KI hautnah! Unser Innovation Hacking Team stellt auf der Konferenz atemberaubende Projekte vor, die ihr selbst ausprobieren könnt. Lasst euch von der Power der Künstlichen Intelligenz begeistern und erfahrt mehr über die Möglichkeiten und Herausforderungen dieser Technologie.

", + "persons": [ + { + "id": 38505, + "public_name": "Martin Förtsch" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Cloud Universe (virtuell)": [ + { + "id": 2690, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:720", + "room": "Cloud Universe (virtuell)", + "title": "JUG Oberland: Pixelflut", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2690", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Es wird ein über das Konferenz-Netzwerk erreichbarer Server aufgestellt, der über einen Beamer einen Canvas zur Verfügung stellt. Der Canvas kann von den Konferenzteilnehmern in nachfolgender Art und Weise befüllt werden.


Der Server ist über \"telnet\" erreichbar (unverschlüsselter Text ohne Authentifizierung).

Der Server versteht folgende Befehle (die tatsächlich verwendete Implementierung könnte weitere unterstützen):
​​​​​​​
- SIZE
- QUIT
- PX x y RRGGBB

SIZE liefert die Größe des Canvas in Pixeln zurück (z.B. 6000x4000).
QUIT beendet die Session ordentlich.
PX x y fragt die aktuelle Farbe des angegebenen Pixels ab.
PX x y RRGGBB setzt die Farbe des angegebenen Pixels auf die angegebene RGB-Farbe.

Da der Server innerhalb des Konferenz-Netzwerks erreichbar ist, können über die Befehle alle interessierten Teilnehmer den Inhalt des Canvas beeinflussen. Die Idee ist, dass die Teilnehmer kleine Programme schreiben, die programmatisch Bilder generieren oder Bilddateien auf den Canvas projezieren. 


Da die Teilnehmer Beiträge der anderen Teilnehmer auch überschreiben können, entsteht in Spitzenzeiten ein Wettkampf um den Canvas und dessen Inhalt.


Das System wird nicht weiter beschrieben, lediglich Serveradresse und Port sind sichtbar. Die Idee ist, dass sich die Methodik der Canvas-Befüllung unter den Teilnehmern rumspricht.

", + "persons": [ + { + "id": 40043, + "public_name": "Sandra Fischer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2695, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:720", + "room": "Cloud Universe (virtuell)", + "title": "CloudLand plays!", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2695", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Auf einem Bildschirm lassen wir eine Anwendung laufen, die wir - inspiriert von \"Twitch plays Pokémon\" - geschrieben haben.


Die Einführung zum Spiel findet am Mittwoch, den 21.06.2023 um 11:00 Uhr in der Blue Lounge statt!


Let's play!

", + "persons": [], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Playground Floor": [ + { + "id": 2711, + "date": "2023-06-22T11:00:00+02:00", + "start": "11:00", + "duration": "00:480", + "room": "Playground Floor", + "title": "JUG Oberland: Interaktiver Hebocon ", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2711", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Wir veranstalten im Rahmen der CloudLand einen interaktiven Hebocon Workshop und jeder kann mitmachen.

Dabei geht es um kleine Roboter, die individuell aus verschiedenen Bauteilen wie u.a. Räder, Platine, Sensoren zusammengebaut werden und gegeneinander in kleinen Roboterkämpfen antreten.

Wir bieten den Teilnehmenden dabei die Möglichkeit aus den von uns mitgebrachten Bestandteilen einen eigenen, kleinen Roboter zu bauen und auch durch eigene, weitere Bestandteile zu erweitern. Zusätzlich stellen wir per GitHub eine Codebasis zur Verfügung, mit der es bereits möglich ist, den eigenen Roboter zu bedienen.

Sobald zwei Roboter gebaut und die Software angepasst wurde, können die beiden gegeneinander antreten. Dabei ist die Challenge entweder den anderen Roboter aus dem definierten Spielfeld drängen oder bewegungsunfähig machen.
Grundsätzlich kann tagsüber gebastelt und ausprobiert werden. Abends möchten wir kleine Turniere mit Siegerehrung und Preisen veranstalten.

Ziel des interaktiven Formats ist es, Teilnehmenden Spaß am Ausprobieren von Hardware und Code am eigenen Roboter zu bereiten. Darüber hinaus wird die Verzahnung und Interaktion zwischen Hardware und Software der Roboter dargestellt.

Workshop: 21.+22.06.
Turnier: 22.06., ab 19:30 Uhr

", + "persons": [ + { + "id": 41781, + "public_name": "Manuel Sauer" + }, + { + "id": 41960, + "public_name": "Jan Marthold" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2712, + "date": "2023-06-22T19:30:00+02:00", + "start": "19:30", + "duration": "00:120", + "room": "Playground Floor", + "title": "GAMING NIGHT Turnier by JUG Oberland: Interaktiver Hebocon", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2712", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Wir veranstalten im Rahmen der CloudLand einen interaktiven Hebocon Workshop und jeder kann mitmachen.


Dabei geht es um kleine Roboter, die individuell aus verschiedenen Bauteilen wie u.a. Räder, Platine, Sensoren zusammengebaut werden und gegeneinander in kleinen Roboterkämpfen antreten.


Wir bieten den Teilnehmenden dabei die Möglichkeit aus den von uns mitgebrachten Bestandteilen einen eigenen, kleinen Roboter zu bauen und auch durch eigene, weitere Bestandteile zu erweitern. Zusätzlich stellen wir per GitHub eine Codebasis zur Verfügung, mit der es bereits möglich ist, den eigenen Roboter zu bedienen.


Sobald zwei Roboter gebaut und die Software angepasst wurde, können die beiden gegeneinander antreten. Dabei ist die Challenge entweder den anderen Roboter aus dem definierten Spielfeld drängen oder bewegungsunfähig machen. Grundsätzlich kann tagsüber gebastelt und ausprobiert werden. Abends möchten wir kleine Turniere mit Siegerehrung und Preisen veranstalten.


Ziel des interaktiven Formats ist es, Teilnehmenden Spaß am Ausprobieren von Hardware und Code am eigenen Roboter zu bereiten.


Darüber hinaus wird die Verzahnung und Interaktion zwischen Hardware und Software der Roboter dargestellt.


Workshop: 21.+22.06.

Turnier: 22.06., ab 19:30 Uhr

", + "persons": [ + { + "id": 41781, + "public_name": "Manuel Sauer" + }, + { + "id": 41960, + "public_name": "Jan Marthold" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ] + } + }, + { + "index": 4, + "date": "2023-06-23", + "day_start": "2023-06-23T09:00:00+02:00", + "day_end": "2023-06-23T17:00:00+02:00", + "rooms": { + "MediaMarktSaturn Lounge": [ + { + "id": 2347, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:165", + "room": "MediaMarktSaturn Lounge", + "title": "Azure Quantum & Microsoft Q#", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2347", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "

You've probably heard about quantum computing, but it still remains a mystery? In this introductory session, I will explain important concepts like qubits, superposition and entanglement and how quantum computing can hopefully help us to solve exponentially difficult problems. In the first part of this session, some theoretical knowledge about quantum physics, quantum gates and quantum algorithms will be combined with examples using a simulated environment on a local PC and on real quantum hardware using Azure Quantum. Most of these examples will use the new quantum language Q# from Microsoft, available as an installable extension to Visual Studio Code. After this introduction, the second part of this session will guide you through the implementation of an existing quantum algorithm, step by step, while I explain all the details. This will be a more technical and interactive code-heavy part. If you'd like to participate, bring a laptop that has the following pre-installed: • Windows, Mac or Linux • .NET 6 or .NET 7 • Visual Studio Code • C# for Visual Studio Code (extension in Visual Studio Code) • Microsoft Quantum Development Kit for Visual Studio Code (extension in Visual Studio Code)


Requirements:

laptop with Visual Studio Code, .NET 6 runtime, Microsoft Quantum Development Kit (for Visual Studio Code)

", + "persons": [ + { + "id": 41334, + "public_name": "Johnny Hooyberghs" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2350, + "date": "2023-06-23T13:00:00+02:00", + "start": "13:00", + "duration": "00:105", + "room": "MediaMarktSaturn Lounge", + "title": "Resilience Patterns mit Istio", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2350", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

In diesem praxisorientierten Workshop werdet ihr tiefer in das Thema Resilience & Fault Tolerance Patterns in Microservice-Architekturen eintauchen. Wir werden uns auf das Erkennen von möglichen Failure-Szenarien und deren effektive Behandlung konzentrieren. Um dies zu erreichen, werden wir uns auf Kubernetes als bevorzugte Orchestrierungsplattform und Istio als Service-Mesh konzentrieren.

Zu Beginn des Workshops werdet ihr einen Einblick in die Grundlagen von Kubernetes und Istio erhalten. Ihr werdet lernen, wie man einfache Microservices auf einem Kubernetes-Cluster bereitstellt und die Installation von Istio als Service-Mesh durchführt. Anschließend werden wir verschiedene Resilience & Fault Tolerance Patterns durchspielen, um zu verstehen, wie sie in Kubernetes und Istio implementiert werden können. Ihr werdet die Möglichkeit haben, diese Patterns in einem Sandbox-Setup auszuprobieren und ihr Verhalten anhand von Metriken zu beobachten.


Durch die Teilnahme an diesem Workshop werdet ihr nicht nur ein besseres Verständnis für Resilience & Fault Tolerance Patterns in Microservice-Architekturen erlangen, sondern auch lernen, wie man diese Muster in einer realen Produktionsumgebung implementiert.

Um das Beste aus diesem Workshop herauszuholen, empfehlen wir die Einrichtung eines lokalen Kubernetes-Setups (z.B. mit Minikube oder kind). Falls erforderlich, stellen wir euch jedoch auch Installations- und Konfigurationsskripte zur Verfügung.


Vorkenntnisse in

  • Kubernetes
  • Docker

Laptop mit minikube erforderlich.

", + "persons": [ + { + "id": 41504, + "public_name": "Sofia Weiler" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2352, + "date": "2023-06-23T15:00:00+02:00", + "start": "15:00", + "duration": "00:105", + "room": "MediaMarktSaturn Lounge", + "title": "Dev(Ops) Productivity starts at $HOME", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2352", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Ihr müsst gemeinsam mit eurem Team einen Cloud-Account (oder gleich mehrere) betreuen. Ihr verantwortet das initiale Setup, richtet regelmäßig Services ein und führt reproduzierbar Änderungen durch. Alles ist als Infrastructure-as-Code (IaC) in euren Git-Repositories hinterlegt. Die effektiven Änderungen in allen Stages jenseits von Development werden durch CI/CD-Pipelines oder geeignete Operatoren deployt.

Dazu nutzt ihr die üblichen Tools, entwickelt wird auf der Command Line oder in der IDE, gelegentlich direkt über eine WebConsole beim Cloud-Provider. Aber am Ende muss die Pipeline laufen!

Euer Monitoring findet so gut wie jedes Problem, bevor es auftritt? Vielleicht nicht ganz. Dann müsst ihr auch mal direkt in die Logs schauen oder einem Container bei der Arbeit auf die Finger gucken. Vielleicht auch in Produktion?

Euer Team muss für die Entwicklung die gleichen Werkzeuge (in der gleichen Version) verwenden, wie eure Pipeline Engines. Im Zweifelsfalle braucht ihr performanten und direkten Zugriff auf alle Systeme - und zwar von euren Laptops aus.

Das lokale Setup eurer Arbeitsumgebung erledigt ihr also auch per IaC, mit genügend Einheitlichkeit, aber auch Freiheitsgraden für alle (z.B. bzgl. Hot-Keys in der IDE).

In diesem Workshop bauen wir gemeinsam ein solches Setup, lernen Tools und Tricks kennen und diskutieren Vor- und Nachteile. Am Ende könnt ihr es für euer Team mit nach Hause nehmen und dort weiterentwickeln.


Vorkenntnisse & benötigte Hardware:

  • Allgemeine Entwicklungskenntnisse nötig
  • Shell/CLI-Kenntnisse hilfreich

Laptop mit:

Git, Bash und typischer Package-Manager sollte vorhanden sein, z.B.

  • Linux: In der Regel alles vorhanden, z.B. git, bash + deb/apt/yum/zipper/rpm/…
  • MacOS: git und bash per Default vorhanden, bitte noch Homebrew vorinstallieren
  • Windows: Git installieren (bringt bash mit) + Chocolatey; bevorzugte Alternative: WSL2 (Windows Linux Subsystem)


Teilnehmerbegrenzung: maximal 30 Teilnehmer

", + "persons": [ + { + "id": 11124, + "public_name": "Gerd Aschemann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Mayflower Lounge": [ + { + "id": 2440, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:45", + "room": "Mayflower Lounge", + "title": "Guerilla Organisation Enablement - Developer-driven Transformation", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2440", + "track": "DevOps and methodology", + "language": "en", + "abstract": "Occasionally, we hear an inspiring story of how a leader so revolutionised a work environment, that the organisation was transformed, causing it to produce massively increased value.
\n
\nUnfortunately, there are no stories of people like you and I changing organisations from the bottom up. People tell me that it’s impossible. In spite of that, this is my mission: to revolutionise the workplace around me, starting at the technical core and expanding across teams and up to management, until the entire organisation is changed. I want to achieve the impossible.
\n
\nThis journey is underway at a number of organisations. In this talk I’ll share some of the methods we’re using and the results we’ve already experienced. So far we are enabling IT teams with best practices, creating a culture of cross-team collaboration, reducing time to market by 90% and moving from continual delays to delivering products before management expects them.
\n
\nI’m on a journey, I know the goal, but only part of the way. I hope to inspire you, and I hope that your feedback and ideas will also help me to find the next steps!
\n", + "persons": [ + { + "id": 24441, + "public_name": "John Fletcher" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2441, + "date": "2023-06-23T11:00:00+02:00", + "start": "11:00", + "duration": "00:105", + "room": "Mayflower Lounge", + "title": "Mein k8s DevOps Cluster in der Tasche", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2441", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Es gibt tausend Möglichkeiten, Kubernetes Cluster in Eigenregie oder als Managed Service in der Cloud zu betreiben. Aber manchmal muss es einfach das eigene Laptop sein oder vielleicht auch ein Raspberry Pi. Beispielsweise um auch offline nach Herzenslust experimentieren zu können oder nicht nachts aufzuwachen mit dem Gedanken: \"Ich habe vergessen, das Cluster herunterzufahren - der Geldzähler läuft!\"

In diesem Workshop schauen wir uns an, wie wir schnell ein minimales (One-Node) Cluster hochfahren können, und werden dann schrittweise komplexer, hin zu einem vollständigen DevOps Setup, das sich für Experimente und Demos der neuesten Technologien nutzen lässt: Ein Multi-Node Cluster, ein komplettes GitLab mit Build Pipelines und Demo-Applikationen, Datenbanken, Messaging, ein vollständiger Observability Stack usw. (die Grenzen sind nur durch die Hardware gesetzt). Und das Ganze möglichst automatisiert und damit jederzeit reproduzierbar.

", + "persons": [ + { + "id": 10372, + "public_name": "Muthiah Chidambaram" + }, + { + "id": 475, + "public_name": "Andreas Badelt" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2369, + "date": "2023-06-23T13:00:00+02:00", + "start": "13:00", + "duration": "00:180", + "room": "Mayflower Lounge", + "title": "GraalVM Native Images in K8s", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2369", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Die GraalVM hat sich in den letzten zwei Jahren bereits einen Namen gemacht. Mit schnelleren Startzeiten, geringeren Payloads und besserer Speichernutzung ist in vielen Anwendungsfällen ein Incentive für die Nutzung der GraalVM gegeben.

Aber wie kommt man eigentlich zu einem native Image? Und wie kriegt man es in Kubernetes zum Laufen? Was sind die Herausforderungen? Kann man Function as a Service aufsetzen? Wir stellen für den Workshop ein Java-Artefakt zu Verfügung. Die Teilnehmer lernen nach einer kurzen Einführung in die GraalVM wie ein Java-Projekt mithilfe von GraalVM (inklusive Installation) ausgeführt werden kann.

Danach beginnt der Weg zum native Image. Ziel ist es zu lernen, was zu einem Java-Artefakt benötigt wird, um es mit GraalVM lokal nativ ausführen zu können. Anschließend wird das erzeugte native Image auf einem Container zum Laufen gebracht und die Gestaltung von Buildprozessen illustriert. Am Ende des Workshops hat jeder Teilnehmer ein natives Image mit GraalVM erzeugt und deployed und dabei gelernt, was dafür notwendig.

", + "persons": [ + { + "id": 39498, + "public_name": "Noah Neukam" + }, + { + "id": 39499, + "public_name": "Uwe Neukam" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "AUSY Lounge": [ + { + "id": 2378, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:105", + "room": "AUSY Lounge", + "title": "Rock, Paper, Scissors Cloud Competition - Go vs. Java", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2378", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Wir implementieren \"Rock, Paper, Scissors\" als Cloud-Anwendung. Das Frontend stellen wir, ihr implementiert das Backend gegen eine vorhandene REST API Definition. Dazu nutzt ihr entweder Go (betreut von Jan Stamer) oder Java (betreut von Lena Grimm). Zum Abschluss tauschen wir die gewonnenen Erfahrungen in einer Fishbowl Session aus.

Die \"Rock, Paper, Scissors\"-Anwendung fängt klein an wird immer weiter ausgebaut:


Stufe 1: Einfache REST API, über die gegen den Computer gespielt wird. Das Backend wird von Beginn an cloud-native aufgesetzt, gemäß den 12 Prinzipien der \"Twelve-Factor-App\".


Stufe 2: Wir erstellen ein Spiel, das wir per Link mit einem anderen Spieler teilen. Dazu muss das Backend die laufenden Spiele verwalten. Wir fangen an und halten die Spiele im Hauptspeicher. Danach persistieren wir die Spiele in einer Datenbank. Die Verwaltung der Spiele muss skalierbar und auf den Betrieb in dynamischen Cloud-Umgebungen eingestellt sein.

Stufe 3:  Wer noch mehr schafft, kann in Echtzeit gegen andere spielen und bspw. ein Leaderboard mit Highscores umsetzen.


Es sind keine Vorkenntnisse erforderlich.

benötigte Hardware:

Laptop mit Code Editor wie VisualStudio Code und Go Compiler (kann auch vor Ort gemeinsam installiert werden)

max. 20-25 Teilnehmer

\r\nhttps://crossnative.github.io/cloudland-rps/", + "persons": [ + { + "id": 41122, + "public_name": "Jan Stamer" + }, + { + "id": 43656, + "public_name": "Fynn Jaspar Stempel" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2380, + "date": "2023-06-23T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "AUSY Lounge", + "title": "Rock, Paper, Scissors Cloud Competition - Diskussion (FishBowl)", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2380", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Offene Diskussion der Erfahrungen aus dem vorherigen Workshop \"Rock, Paper, Scissors Competition - Go vs. Java“. Auch diejenigen, die am Workshop nicht teilnehmen konnten, sind herzlich eingeladen: Hört euch einfach die Diskussion an oder teilt eigene Erfahrungen aus Cloud-Native-Implementierungen mit diesen Sprachen.

", + "persons": [ + { + "id": 41122, + "public_name": "Jan Stamer" + }, + { + "id": 43656, + "public_name": "Fynn Jaspar Stempel" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2381, + "date": "2023-06-23T13:00:00+02:00", + "start": "13:00", + "duration": "00:225", + "room": "AUSY Lounge", + "title": "Kubernetes von 0 auf 100 in einem Tag", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2381", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Moderne Anwendungsbereitstellung muss schnell und konsistent sein, um mit den Geschäftszielen Schritt halten zu können. Deshalb sind Container-basierte Anwendungen in den letzten Jahre immer beliebter geworden. Um diese im Cluster sicher und skalierbar betreiben zu können, hat sich Kubernetes als Quasi-Standard etabliert.

Fall ihr euch - genauso wie viele meiner Kunden - die Frage stellt, wie ihr mit diesem Toolset starten könnt, ist dieser Workshop genau das Richtige für euch.

Wir beginnen mit den Grundlagen zu Docker und Containern und setzen unser erlerntes Wissen dann gleich in die Tat um. Anschließend verschaffen wir uns einen architektonischen Überblick über Kubernetes-Cluster und schauen, wie diese bei den verschiedenen Cloud-Providern umgesetzt werden.

Wenn unser eigenes Cluster dann in Betrieb ist, lernen wir, wie wir damit interagieren können, und rollen dann auch gleich unsere ersten Anwendungen aus. Zum Schluss steigen wir noch tiefer in die Entwicklung von Container-basierten Lösungen ein und lernen, wie wir diese sicher und skalierbar im Cluster betreiben können.

", + "persons": [ + { + "id": 39377, + "public_name": "Sascha Dittmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "REWE digital Lounge": [ + { + "id": 2409, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:45", + "room": "REWE digital Lounge", + "title": "IMC Kubernetes - Day 2 Operations / Part 1", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2409", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Dieser Workshop zeigt weiterführende Themen nach einer ersten Installation von Kubernetes auf und besteht aus drei Teilen. Diese sind zeitlich variabel und können entsprechend des Feedbacks angepasst werden.

Nach einer allgemeinen Einführung in Security in Kubernetes wird in diesem ersten Teil auf folgende Punkte eingegangen:
​​​​​​​
- Einführung, Umsetzung und Überprüfung Security/Governance und Compliance
- CIS Kubernetes Benchmark
- kube-bench

", + "persons": [ + { + "id": 6910, + "public_name": "Matthias Fuchs" + }, + { + "id": 5713, + "public_name": "Borys Neselovskyi" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2410, + "date": "2023-06-23T11:00:00+02:00", + "start": "11:00", + "duration": "00:105", + "room": "REWE digital Lounge", + "title": "IMC Kubernetes - Day 2 Operations / Part 2", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2410", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Im zweiten Teil des Workshops \"IMC Kubernetes - Day 2 Operations\" widmen wir uns den Themen RBAC und Authentication in Kubernetes.


Zugriffssteuerung und -kontrolle sind essentielle Aufgaben im Kubernetes-Umfeld. Kubernetes verwendet Client- Zertifikate, Inhaber-Tokens oder einen Authentifizierungs-Proxy für API-Anforderungen. Kubernetes RBAC ist eine wichtige Sicherheitskontrolle, um sicherzustellen, dass Cluster-Benutzer und -Workloads nur den Zugriff auf Ressourcen erhalten, der für die Ausführung ihrer Aufgaben erforderlich ist.


Es ist wichtig, dass der Cluster-Administrator beim Entwurf von Berechtigungen für Cluster-Benutzer die Bereiche kennt, in denen es zu einer Eskalation von Berechtigungen kommen könnte, um das Risiko eines übermäßigen Zugriffs, der zu Sicherheitsvorfällen führt, zu verringern.


Im Workshop geben wir eine Einführung in Authentikationsmethoden/RBAC mit anschließender Umsetzung und Demo.

", + "persons": [ + { + "id": 6922, + "public_name": "Heiko Stein" + }, + { + "id": 6910, + "public_name": "Matthias Fuchs" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2412, + "date": "2023-06-23T13:00:00+02:00", + "start": "13:00", + "duration": "00:105", + "room": "REWE digital Lounge", + "title": "IMC Kubernetes - Day 2 Operations / Part 3", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2412", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Im dritten Teil von \"IMC Kubernetes - Day 2 Operations\" widmen wir uns folgenden Themen:
​​​​​​​
- Datenbanken (im speziellen Postgres)
- K8s Postgres Majorupgrade - Minimal Downtime
- K8s Postgres Desaster Recovery
- CD mit Argo / Flux
- K8s Lifecycle

", + "persons": [ + { + "id": 5713, + "public_name": "Borys Neselovskyi" + }, + { + "id": 6922, + "public_name": "Heiko Stein" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2414, + "date": "2023-06-23T15:00:00+02:00", + "start": "15:00", + "duration": "00:105", + "room": "REWE digital Lounge", + "title": "GitOps in der Anwendungsentwicklung: Die Missing Links", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2414", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Gestählt durch die reichlich vorhandenen Einsteigerartikel hat sich inzwischen so mancher DevOps-Engineer hochmotiviert daran gemacht, die Release-Pipeline seines Softwareprojektes um ein GitOps-gesteuertes Deployment zu erweitern.


Und in der Regel ist er dabei über die typischen Fragestellungen gestolpert, die erst dann auftauchen, wenn man die Technologie wirklich produktiv einsetzen will: Wie ist die Beziehung zwischen dem Infrastruktur-Code aus den Entwicklungs-Repositories und jenem im GitOps? Wie bilde ich meine Deployment-Stages im Repository ab und wie bewege ich mich von Stage zu Stage? Wie genau verträgt sich das mit Konfigurationstechniken wie Kustomize und Helm? Wie erlaube ich meinem Betrieb bei aller Automation weiterhin den spontanen Feuerwehr-Einsatz? Und vielleicht am wichtigsten: Wie spielen all diese Teilaspekte am besten zusammen?


Es gibt zwar Empfehlungen und Best Practices. Diese befinden sich aufgrund der Neuheit des Themas aber wohl eher noch auf dem Prüfstand und passen vielleicht nicht für alle Situationen.

In diesem interaktiven Talk wollen wir den Status Quo beleuchten. Wir stellen abzubildende Use Cases, einige der verfügbaren Konzepte und ihre Fallstricke vor. Die Teilnehmer sind herzlich eingeladen, ihre eigenen Erfahrungen einzubringen und gemeinsam zu diskutieren, was für Lösungen machbar und empfehlenswert sind.


Vorkenntnisse in Kubernetes und GitOps. Laptop ist nicht erforderlich.

", + "persons": [ + { + "id": 42111, + "public_name": "Oliver Weise" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + } + ], + "Playground Floor": [ + { + "id": 2443, + "date": "2023-06-23T13:00:00+02:00", + "start": "13:00", + "duration": "00:225", + "room": "Playground Floor", + "title": "AWS GameDay", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2443", + "track": "CI / CD and automation", + "language": "en", + "abstract": "

The AWS GameDay is a light-hearted adventure into the world of cloud technology and a parody of start-up culture. The content is intended to be humorous and playful in nature. The game consists of five core Quests plus an icebreaker one.


Participants can expect a wide variety of technical challenges related to AI/ML, data consolidation, data stream processing, security, IoT, CI/CD and more.

Quests Overview:


1. Cornhuf Translator - The Mythical Research division located ancient unicorn texts and we think it’s written in Cornhuf language.
2. Finding Monoceros - The Resourcing Department is trying to locate new mana sites in outer space.
3. Mine Analyzer - The Data and Analytics Department is working on ways to process the vast amount of mana data being gathered.
4. Mana Processing - The Processing Department is responsible for handling the materials from the manufacturing operations.
5. Rucinon Space Taste - The Unicorn Farm Department protects and develops the future fleet.

", + "persons": [ + { + "id": 8517, + "public_name": "Paul Enno Schulte" + }, + { + "id": 43611, + "public_name": "Diana Cheng Abusabal" + }, + { + "id": 43612, + "public_name": "Tim Huettemeister" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + } + ], + "Stage 1": [ + { + "id": 2735, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Staying in Control Of Your Companies Kubernetes Adoption – How Platform Engineer", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2735", + "track": "Customer Stories", + "language": "de", + "abstract": "Wie bei Aldi zentrales Platform Engineering die Adaption von Kubernetes beschleunigt
\r\nViele Fragen, genauso viele Antworten – Aldis Einschätzung, welche wirklich wichtig sind
\r\nDay 2 Operations einfach gemacht: ein Erfahrungsbericht
\r\n
\r\n---
\r\nIm August 2020 startete ALDI SÜD das \"Cloud Adoption Program\", um Cloud Native-Technologien einzuführen und gleichzeitig die IT des Unternehmens zu modernisieren.
\r\nIn diesem Vortrag werden wir ein zentrales und wiederverwendbares Muster dieses Programms vorstellen: eine Referenzarchitektur für Kubernetes. Referenzarchitekturen sind zentral entwickelte und versionierte Blueprints nach dem GitOps-Ansatz, die ein schnelles Deployment von Clustern ermöglichen und gleichzeitig die Kontrolle über Wartung und Compliance behalten. Wir werden zeigen, welche CNCF-Säulen in einem Blueprint enthalten sein sollten, wie sie das Plattformteam und die Kunden bei ihren jeweiligen Aufgaben unterstützen und wie man zentrale Automatisierungen zur Lösung komplexer Day-2-Operationen entwickelt.
\r\nSie werden erfahren, wie ein relativ kleines Plattformteam, das auf Projekten aufbaut, die von der CNCF-Community unterstützt werden, die Cloud-Native-Einführung eines ganzen Unternehmens fördern kann.", + "persons": [ + { + "id": 43529, + "public_name": "Tim Urlaub" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2484, + "date": "2023-06-23T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Entertaining the Masses with AWS AppSync and Serverless Technologies", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2484", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "In this talk, we aim the spotlight on our truly serverless architecture that serves millions of viewers with our TV broadcast offering. We will show you how AWS AppSync helps us to respond to sudden prime time traffic peaks, keeping viewers engaged and our pagers silent. Security is key while engaging with our customers, hence we will unwrap how we use a variety of authentication methods to satisfy a diverse set of use cases. We also want to share how we build our development and testing pipeline to deploy to production in minutes without fear.", + "persons": [ + { + "id": 41314, + "public_name": "Joachim Aumann" + }, + { + "id": 43205, + "public_name": "Fabian Desoye" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2503, + "date": "2023-06-23T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Challenge Startup: Entwurf belastbarer Cloud-native-Architekturen", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2503", + "track": "Customer Stories", + "language": "de", + "abstract": "

Die größten technischen Challenges in Start-ups sind heute: Schnelligkeit in der Weiterentwicklung der Features, stetige Veränderungen der Anforderungen, skalierbare Software, die weiteren Wachstumspläne nicht im Weg steht, und natürlich darf die Sicherheit darunter nicht leiden.

In meinem Vortrag soll es darum gehen, wie Cloud-Architekten und Developer all diesen Anforderungen heutzutage gerecht werden können. Ich bringe eine Handvoll der besten Architekturen von Top-Startups aus der ganzen Welt mit. Wir tauchen in deren Designentscheidungen ein, um zu verstehen, was diese Architekturen modern macht, was wir daraus lernen können und welche Fehler am besten vermieden werden sollen.

Das Ganze wird untermauert durch meine eigene Erfahrung als CTO in einem HR Start-up.

", + "persons": [ + { + "id": 42143, + "public_name": "Niklas Mengele" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2504, + "date": "2023-06-23T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Neue Programmiersprache „Ubiquitous“ - Ein DDD Projekt-Erfahrungsbericht", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2504", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Event, Command, Boundary, Aggregate, … Zusätzlich zu Java, Kotlin, TypeScript etc. muss ein Fullstack-Developer jetzt eine weitere – und noch dazu unaussprechliche – Sprache beherrschen: „Ubiquitous“!

Die Sprache ist nicht typ-sicher. Der Compiler verschluckt Ubiquitous-Befehle einfach. Doch in IntelliJ haben wir eine kleine Hilfe: Das Sprachpaket Deutsch, weil – man glaubt es kaum – dieses deckt die Sprache Ubiquitous ab: Eine entzaubernde Sachlichkeit, die in mancherlei Kontext ihren Witz offenbart. Oder scheut sich der Softwaredeveloper, mit Ubiquitous-Language eine Kläranlagen-Software zu programmieren?

In diesem Vortrag gehe ich auf Domain-Driven Design (DDD) und den – darin unerlässlichen – Einsatz von Ubiquitous-Language ein. Wie kommt man von einer Fachlichkeit über die passende Softwarearchitektur zu der entsprechenden Code-Implementierung?


Ich berichte aus einem Projekt, welche DDD-Methoden gut ankamen, wie Event-Storming über Skype funktioniert und was wir in der Entwicklung davon haben. Ich zeige auf, wo und wie wir nach Boundary-Control-Entity (BCP)-Pattern im Code die DDD-Artefakte verorten. Ich zeige aber auch die Problematiken auf – die Schattenseiten von DDD. Fallstricke, die man – wenn man sich auf DDD einlassen möchte – kennen sollte.

", + "persons": [ + { + "id": 18769, + "public_name": "Azmir Abdi" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2505, + "date": "2023-06-23T13:00:00+02:00", + "start": "13:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Strategien, Taktiken und Muster der Legacy-Ablösung", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2505", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "Für die Ablösung von Legacy-Anwendungen existieren verschiedene Strategien und eine komplette Neuimplementierung \"auf der grünen Wiese\" ist nicht immer ratsam. Der Vortrag wird die verschiedenen 5R-Strategien (Retire, Replace, Rehost, Retain, Reengineer) zur Legacy-Migration vorstellen und mit ihren Vor- und Nachteilen vergleichen. Dabei werden die Strategien auch in ihren besonderen Ausprägungen für die Migration in die Cloud (z.B. Lift&Shift) betrachtet.
\r\n
\r\nEine Strategie allein wird den Herausforderungen der Legacy-Ablösung selten gerecht, da die Abhängigkeiten zu anderen Anwendungen bei der Wahl der Strategie oft ausgeblendet werden und die Voraussetzungen zur Migration erst geschaffen werden müssen. An der Stelle kommen häufig konkrete Taktiken oder Muster ins Spiel, um die Strategie in ein erfolgreiches Projekt zu überführen. Das kann die Nutzung von Brückentechnologien sein, die Anwendung des Strangler Fig Patterns zur schrittweisen Ablösung der Legacy-Anwendung oder die schichtenweise Modernisierung des Gesamtsystems. Für diese und andere Taktiken und Muster werden konkrete Erfolgsbeispiele aus der Praxis vorgestellt.", + "persons": [ + { + "id": 14886, + "public_name": "Tobias Voß" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2506, + "date": "2023-06-23T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Platform Engineering for a Greener Tomorrow: The Deutsche Bahn's Path to digital sustainability", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2506", + "track": "Customer Stories", + "language": "en", + "abstract": "Deutsche Bahn (DB), an international mobility and logistics company, is pursuing a long-term strong rail strategy that is system relevant: unless we shift traffic – on a massive scale – to a strong rail network, we will not be able to achieve our climate targets. The building blocks of the strong rail strategy include various aspects of digitalisation, such as digital rail or digital platforms, combined with the building blocks of environment and 100% green electricity. As data centres have a significant impact on global energy consumption and carbon emissions, and their contribution is expected to grow in the coming years, it is crucial that we understand, measure and address the environmental impact of digitalisation at Deutsche Bahn. \r\n \r\nIn this session we will explore the importance of Green IT and the role of IT in reducing carbon emissions. We will discuss how Deutsche Bahn's digital partner DB Systel is taking a platform engineering approach to addressing this issue, specifically by implementing GreenOps practices that enable developers to see the environmental impact of their actions and reduce their carbon footprint.\r\n \r\nWe will highlight the double-win aspect of enabling GreenOps, as it supports sustainability efforts while contributing to FinOps practices and reducing costs. In addition, we will focus on the importance of platform engineering, with a particular emphasis on the potential of Kubernetes to scale the impact of GreenOps practices and reduce energy consumption and carbon emissions.\r\n \r\nJoin us in this session to explore how DB Systel is taking a bold step towards sustainability through its digital platforms, and to gain the tools and knowledge necessary to reduce carbon emissions and achieve cost savings in your own organisation.", + "persons": [ + { + "id": 39969, + "public_name": "Gualter Baptista" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [], + "featureTags": [] + }, + { + "id": 2507, + "date": "2023-06-23T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Von der Leichtigkeit des Seins - Theorie und Wahrheit in der Cloud", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2507", + "track": "Customer Stories", + "language": "de", + "abstract": "Im Dezember haben wir unsere Sales Digital Workstation in die Cloud deployed. Alles geht automatisch und Weihnachten ist für niemanden gefährdet - so dachten ich als Architektin. Aber meine Kollegen mussten mich von meiner Wolke holen. Und der Aufschlag war ziemlich hart - nichts mit Zwischenlandung auf Wolke 4. Nichts ging so wie geplant - die Pipelines funktionierten nicht, Zertifikate haben gefehlt, das API Gateway war nicht vorhanden. Der Beitrag berichtet aus der Sicht einer Architektin wie schön man in der Cloud produktiv gehen kann und aus der Sicht eines Praktikers, wie schmerzhaft es ist, in der Cloud zu deployen.", + "persons": [ + { + "id": 39978, + "public_name": "Annegret Junker" + }, + { + "id": 42097, + "public_name": "Ingo Battenfeld" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2508, + "date": "2023-06-23T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 1", + "title": "Patterns of Sustainability - Going Green in IT", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2508", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "Sustainability - especially reducing our carbon footprint - has become a huge topic in many areas of our lives. And as software is eating the world, we are responsible for the growing ecological impact of the solutions we create.
\r\n
\r\nIn this session, we will look at more and less intuitive IT sustainability patterns at various levels that can help us to reduce our carbon footprint, including trade-offs and practical tips for implementation.
\r\n
\r\nAfter this session you will have a better understanding how you can create greener IT systems and what it means in practice.", + "persons": [ + { + "id": 11564, + "public_name": "Uwe Friedrichsen" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + } + ], + "Stage 2": [ + { + "id": 2564, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Testen einer Cloud – wie geht man vor?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2564", + "track": "Customer Stories", + "language": "de", + "abstract": "

Im IT-Systemhaus der Bundesagentur für Arbeit (BA) werden Cloudtechnologien eingesetzt und stetig erweitert. Hierbei kommt an vielen Stellen die on Premises-Plattform BApC (BA private Cloud) zur Bereitstellung der Cloud-Services aus den eigenen Rechenzentren zum Einsatz.

In diesem Vortrag soll es um den Testprozess der BApC gehen. Die Aufgaben des Test-Teams, insbesondere im Bezug auf die individuellen Herausforderungen beim Testen von Cloud-Systemen, sowie die Anforderung nach durchgängiger und ganzheitlicher Bereitstellung der Ressourcen werden besprochen. Hier kommen sowohl verschiedene Testarten und -methoden als auch das eigens entwickelte Testautomatisierungsframework „TAMARA“ zum Einsatz. 

", + "persons": [ + { + "id": 39947, + "public_name": "Nathalie Kuczewski" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + }, + { + "id": 2565, + "date": "2023-06-23T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Webhooks in CIs - Schnee von gestern - Pipelines ereignisbasiert triggern", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2565", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Die agile, cloud-native Softwareentwicklung erfordert vollständige Automatisierung der Build- und Deployment-Prozesse (CI/CD). Diese Automatisierung erfolgt in den CI/CD-Pipelines durch Unterteilung des Build-Prozesses in mehrere Schritte.

Offen bleibt die Frage: Wann und wie wird eine Pipeline an sich ausgelöst? 

Typsche Trigger-Quellen sind:

- Code-Änderungen
- Aktualisierungen des darunterliegenden Container-Images
- Ereignisse im Entwicklungsprozess, z.B. Pull Requests

Das Triggern erfolgt dann oft durch Nutzung von WebHooks (Push-Prinzip). Das Konzept von WebHooks als Pipeline Trigger datiert allerdings aus der primär synchronen Pre-Cloud-native-Zeit. Es entspricht nicht den architektonischen Aspekten von Cloud-nativen Anwendungen - nämlich reaktiv und ereignisbasiert zu sein.

In diesem Vortrag wird eine Methode hands-on vorgestellt, um die Kern-Aspekte der Cloud-nativen Software-Entwicklung auch in dem CI/CD-Prozess anwenden zu können (also Umstellung auf Pull Prinzip).

Für die Umwandlung der Trigger-Quellen zu Kubernetes-Events wird das Zusammenspiel mehrerer Kubernetes-Controller in einer Demo für den Build eines Microservices vorgestellt:

- Flux Source Controller - Tracken von Code-Änderungen in der Anwendung
- Flux Image Reflector Controller - Tracken von Aktualisierungen von Base Images
- Pull Request Controller - Reaktion auf Pull Requests
- Pipeline Trigger Controller - Eventbasiertes Starten einer Tekton Pipeline

", + "persons": [ + { + "id": 40390, + "public_name": "Tihomir Yordanov" + }, + { + "id": 15851, + "public_name": "Lyubomir Yordanov" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2566, + "date": "2023-06-23T12:00:00+02:00", + "start": "12:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Zero Downtime Migration into Google Cloud Platform Using Oracle GoldenGate", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2566", + "track": "Customer Stories", + "language": "de", + "abstract": "

Oracle Cloud Infrastructure GoldenGate is a fully managed, native cloud service that moves data in real-time, at scale. OCI GoldenGate processes data as it moves from one or more data systems to target databases. You can also design, run, orchestrate, and monitor data replication tasks without having to allocate or manage any compute environments.


These new services also automate many functions, including monitoring, workload scaling, and patching while maintaining high availability. Its interface enables non-DBA users to drive digital transformation, simplifying on-prem to cloud integrations, migrations, multi-region data synchronization, data pipelines, and multi-cloud database replication.


Furthermore as everyone is talking about migrating or sending data from on premises to the cloud, but how could we achieve this in a secured and efficient way? In this presentation, we will cover the overall migration steps on how to setup a data replication between on premises database to GCP (which can be any cloud vendor including OCI) and point it out how MediaMarket Saturn did it successfully using OCI GoldenGate with best practices, tips and tricks.

", + "persons": [ + { + "id": 40694, + "public_name": "Harald Maier" + }, + { + "id": 42096, + "public_name": "Juliana Gomes" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2568, + "date": "2023-06-23T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Automatisiert kontinuierliche Qualitätssicherung in komplexen PaaS-Systemen", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2568", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "In komplexen und hochsicheren multiregionalen Kubernetes-Umgebungen müssen Wartungsaufgaben und Updates im laufenden Betrieb durchgeführt werden. Das System muss voll funktionsfähig bleiben und gleichzeitig muss die Verfügbarkeit der einzelnen Clusterkomponenten und Dienste sichergestellt werden. Während eines Plattformupdates garantiert die Qualitätssicherung die Funktionalität der betrieblich notwendigen Plattformdienste. Steigende Nutzer-, Cluster- und Prozesszahlen machen Qualitätssicherung und Automatisierung zur Herausforderung. Um diese Aufgaben zu erleichtern, hat infologistix ein kontinuierliches, umfassendes und nachhaltiges Qualitätssicherungsverfahren entworfen und bei Kunden erfolgreich etabliert. Es basiert auf einer verteilten Microservice-Architektur und ist damit individuell skalierbar. Technisch gesehen nutzt es neben custom-build Data Agents unter anderem bestehende Logs und Metriken von Diensten wie dem k8s-API-Server, Prometheus und Grafana. Die zuletzt genannten Tools verfügen über umfangreiche Funktionen für die Protokollierung und Überwachung, aber die automatisierte Qualitätssicherung schließt durch Erweiterung mit custom-build Data Agents die Lücke zur plattformweiten Observability.", + "persons": [ + { + "id": 41819, + "public_name": "Paul Schmidt" + }, + { + "id": 40192, + "public_name": "Harald Gerhards" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2570, + "date": "2023-06-23T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 2", + "title": "Warum eure Microservice-Architektur nicht funktioniert", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2570", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Micrsoservice-Architekturen sind prinzipiell dazu gedacht, dass durch die Entkopplung der Dienste die Geschwindigkeit der Umsetzung von neuen Funktionalitäten schneller wird, weil die Abhängigkeiten verringert werden. Trotzdem kann es vorkommen, dass die geplante Unabhängigkeit nicht greift. Und das, obwohl die Einführung der Microservice-Architektur mit einer organisatorischen Änderung, z. B. anhand von _Team Topologies_ begleitet wurde. Genauso wie Source-Code muss auch die Organisationsstruktur kontinuierlich refaktoriert werden. Warum das so ist und wie man das umsetzt, erkläre ich in diesem Talk.

", + "persons": [ + { + "id": 39451, + "public_name": "Mick Hohmann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + } + ], + "Stage 3": [ + { + "id": 2600, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Observability for Efficient DevSecOps Pipelines", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2600", + "track": "CI / CD and automation", + "language": "en", + "abstract": "Continuous integration and delivery/deployment help speed up development and review workflows. Developers focus on code and rely on the application reliably tested in different environments. At some point, an error occurs and things are stuck. Broken pipelines, significant resource costs, security leaks, and broken dependencies make production deployments challenging.
\r\n
\r\nThis talk takes you from the first steps of a working but inefficient pipeline into the root cause analysis on possible performance and resource issues. Observability methods to look deeper into CI/CD pipelines with OpenTelemetry and eBPF will be uncovered with practical examples. Infrastructure cost optimization, capacity planning and AIOps help teams get more efficient. GitOps workflows in cloud-native environments are tackled too. Security shifted left already, now it is time for Observability for efficient DevSecOps pipelines.
\r\n", + "persons": [ + { + "id": 42091, + "public_name": "Michael Friedrich" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2601, + "date": "2023-06-23T11:00:00+02:00", + "start": "11:00", + "duration": "00:45", + "room": "Stage 3", + "title": " Customer Story: How Hybrid Cloud could look like", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2601", + "track": "noMainfocus", + "language": "de", + "abstract": "A look into the planned Hybrid-Cloud setup of REWE digital, powered by Google Cloud:\r\nUsing Google Anthos as the management platform for Hybrid Cloud Kubernetes setups.", + "persons": [ + { + "id": 25964, + "public_name": "Paul Puschmann" + }, + { + "id": 39958, + "public_name": "Jan Martens" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [], + "featureTags": [] + }, + { + "id": 2602, + "date": "2023-06-23T12:00:00+02:00", + "start": "12:00", + "duration": "00:105", + "room": "Stage 3", + "title": "Von Null auf Graph: Eine Reise zu Graphdatenbanken und Graph-basierten Analysen", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2602", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Wir möchten euch in die Welt der Graph-Datenbanken und Graph-basierten Analysen mitnehmen. Wir werden in mehreren Sessions mit unterschiedlichen Formaten folgende Themen und Fragestellungen behandeln: - Was sind Graph-Datenbanken? Für welche Anwendungsfälle sind sie konzipiert? - Was können Graph-Algorithmen? - Was sind Graph-Anfragesprachen? - Wie passen Graphen und relational modellierte Daten oder JSON-Dokumente zusammen? - Wie können Developers mit Graphen, Graphalgorithmen und Graphanfragesprachen arbeiten? - Wie passen Graphen und Machine Learning zusammen?


technische Voraussetzungen:

  • einen Internet-fähigen Laptop,
  • einen (Always Free) Oracle Cloud Account (www.oracle.com/cloud/free). (Wird nicht zwingend vorausgesetzt, ist aber sehr hilfreich.)
  • Oracle Database 23c Free – Developer Release (blogs.oracle.com/database/post/oracle-database-23c-free)


Spezielle Vorkenntnisse werden nicht vorausgesetzt.

", + "persons": [ + { + "id": 2994, + "public_name": "Karin Patenge" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2604, + "date": "2023-06-23T14:00:00+02:00", + "start": "14:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Mit Graph Algorithmen in der Cloud Ressourcennutzung optimieren ", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2604", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Haben Sie sich jemals gefragt, wie Sie die Ressourcennutzung in Ihrer Cloud-Infrastruktur maximieren können? Wenn Sie Ihre Cloud-Infrastruktur als Graph modellieren, können Sie Graph-Algorithmen anwenden um herauszufinden, wo Sie Ihre Workloads platzieren sollten um Kosten zu optimieren. Mit Graph Studio in der Oracle Autonomous Database können Sie Ihre eigenen Graph-Algorithmen mit Java-Syntax entwickeln und das Ergebnis im Webbrowser visualisieren, ohne dass Sie irgendwelche Tools installieren müssen. In dieser Session zeigen wir Ihnen, wie.


technische Voraussetzungen:

  • einen Internet-fähigen Laptop,
  • einen (Always Free) Oracle Cloud Account (www.oracle.com/cloud/free). (Wird nicht zwingend vorausgesetzt, ist aber sehr hilfreich.)
  • Oracle Database 23c Free – Developer Release (blogs.oracle.com/database/post/oracle-database-23c-free)


Spezielle Vorkenntnisse werden nicht vorausgesetzt.

", + "persons": [ + { + "id": 41430, + "public_name": "Korbi Schmid" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2605, + "date": "2023-06-23T15:00:00+02:00", + "start": "15:00", + "duration": "00:45", + "room": "Stage 3", + "title": "How to send a goal notification in real-time to hundredthousand Bundesliga fans?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2605", + "track": "Customer Stories", + "language": "en", + "abstract": "No one wants to get notified about a goal minutes after it happened on the pitch. By using the official Bundesliga App, the DFL wants their fans to cheer first.
\r\n 
\r\nIn this session, DFL will show how Amazon Pinpoint helped to send a massive amount of notifications to a massive amount of fans in real-time. On average, we send out 20.000.000 messages to 625.000 endpoints during a matchday. Before DFL migrated to Amazon Pinpoint, their push notification service based on Amazon SNS. But they faced several limitations. The audience will learn how to use Amazon Pinpoint for push notifications at scale. what challenges DFL faced while automating the creation of dynamic segments and campaigns for so called “auto-events” . We will cover how DFL was able to gain insights into campaign performance by using Amazon Pinpoint Eventstreams and Amazon Athena. To answer questions like: \"How long does it take to send a goal notification to all fans in a segment?\" or \"How many notifications are we able to send per seconds?\". And finally how those insights helped DFL, to challenge themselves along the question: “Do we really have the fastest push notifications?”", + "persons": [ + { + "id": 41121, + "public_name": "Christian Bonzelet" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [] + }, + { + "id": 2606, + "date": "2023-06-23T16:00:00+02:00", + "start": "16:00", + "duration": "00:45", + "room": "Stage 3", + "title": "Software Craft, was ist das und braucht man das bei DevOps überhaupt?", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2606", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "Spätestens seit der Entstehung des \"Software Craftsmanship Manifesto\" im Jahr 2008 etabliert sich das Mindset dahinter in der Software Engineering Welt. Oder doch nicht? Was wird eigentlich darunter verstanden? In dieser Session zeige ich mein Verständnis davon und was wir bei DATEV dafür unternehmen. Nach meinem Impuls möchte ich mit den Teilnehmenden Meinungen und Ideen dazu sammeln. Sind \"DevOps\" und \"Software Craft\" nur Buzzwords, oder braucht man es wirklich? Braucht es für \"DevOps\" mehr von \"Software Craft\" oder eher weniger?", + "persons": [ + { + "id": 38489, + "public_name": "Andreas Fischer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [] + } + ], + "Stage 4": [ + { + "id": 2632, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:105", + "room": "Stage 4", + "title": "JUG Nürnberg: Kubernetes Operator Hands-on", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2632", + "track": "CI/CD & Automatisierung", + "language": "de", + "abstract": "

Das Hands-on beginnt mit der Vorstellung des Kubernetes Operator: Welche Probleme löst er und wie funktioniert er? Anschließend betrachten wir den Operator SDK und dessen Bestandteile Kubebuilder und Operator Lifecycle Manager (OLM) und gehen auf konkrete Nutzungsszenarien ein - z.B. die Erweiterung von Tekton, Flux und die Provisionierung von Datenbanken.


Anschließend widmen wir uns der Implementierung eines Operators zum automatisierten Deployment von AKHQ mit dem Operator SDK in Go. Weitere Themen sind das Design der API, CRD und Reconciliation Loop.

Für die Teilnahme an diesem Hands-on wird Docker benötigt.

", + "persons": [ + { + "id": 39006, + "public_name": "Axel Krämer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2634, + "date": "2023-06-23T12:00:00+02:00", + "start": "12:00", + "duration": "00:285", + "room": "Stage 4", + "title": "Build ETL/ELT Pipelines Locally, then Deploy and Execute at Scale on Kubernetes", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2634", + "track": "Container- and Cloud-Technologies", + "language": "en", + "abstract": "

In this workshop we will form one or several teams to build individual processing pipelines. The purpose of those pipelines could be to ingest external data sources, perform data transformations, train ML models, AI-annotate data, or any other. The participants are invited to bring their own use-cases including data, business logic code, deep-learning models, etc. with them to the event. As fallback we will provide an exemplary text classification task for the participants without a home-made use-case.

After a brief introduction of the framework, teams will design their individual pipeline flows in form of DAGs (“directed acyclic graphs”, i.e. the processing steps can either form a linear chain or may exhibit parallelism or conditional branches). Then we jointly configure pre-made standard building blocks and create Docker images for the individual business logic steps. The teams then run and debug their pipelines locally. Finally, we demonstrate how to deploy a Kubernetes cluster on GCP and execute the pipelines on it (time scheduled, multi-batched and auto-scaled).

Prerequisites: Participants should bring laptops with Docker Desktop already installed. If your home-made code/models are based on Python, Java, PyTorch then no Docker expertise is required. For others, you should get acquainted with writing Docker files and bring a Docker base image on which your application code can be executed. No expertise of Kubernetes or GCP is required to participate in this workshop.

", + "persons": [ + { + "id": 40630, + "public_name": "Jan Kneissler" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "QAware Lounge": [ + { + "id": 2663, + "date": "2023-06-23T10:00:00+02:00", + "start": "10:00", + "duration": "00:105", + "room": "QAware Lounge", + "title": "OpenTelemetry für Fortgeschrittene", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2663", + "track": "Microservices & Domain-driven Design", + "language": "de", + "abstract": "

Observability und OpenTelemetry sind in aller Munde. Mit sehr hoher Wahrscheinlichkeit habt ihr bereits einen Vortrag gehört, der euch in dieses Thema eingeführt hat, oder ihr habt euch selbst in das Thema eingelesen. Ihr wisst also Bescheid über die drei Säulen (\"Three Pillars\"), könnt euren Code instrumentieren und habt mit Tracing vielleicht schon mal das ein oder andere Performance-Problem gelöst.


In diesem Vortrag möchte ich mit euch noch einen Schritt weiter gehen und euch mit einigen fortgeschrittenen Themen zu Observability & OpenTelemetry bekanntmachen:

- Wieso ihr nur den \"OpenTelemetry Collector\" braucht, um jegliche Telemetrie empfangen, verarbeiten und verschicken zu können
- Was der Unterschied zwischen \"manueller\", \"nativer\" und \"automatischer\" Instrumentierung ist und wann ihr was verwendet
- Wieso ihr \"semantische Konventionen\" lieben solltet
- Was ihr bei OpenTelemetry in der Zukunft erwarten könnt und wo es heute noch Limitierungen gibt

Die Session wird von Live-Demos begleitet und es wird Gelegenheit geben, viele Fragen zu stellen!

Voraussetzungen für Teilnehmer:

Grundlegendes Wissen (z.B. mal ein Tutorial gemacht, ein paar Dokus oder Videos dazu angeschaut, erste praktische Erfahrungen, …) mit OpenTelemetry (oder anderen Arten von Observability).


eigener Laptop mit
(1) Zugriff auf Docker-Engine / K8s Umgebung (lokal oder remote)
(2) IDE oder anderer bevorzugter Editor
(3) optional: eine eigene Anwendung, die ihr gerne mit OpenTelemetry instrumentieren möchtet (Sprache sollte offiziellen Support haben: https://opentelemetry.io/docs/instrumentation/)


max. 24 Teilnehmer




", + "persons": [ + { + "id": 40242, + "public_name": "Severin Neumann" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + }, + { + "id": 2665, + "date": "2023-06-23T12:00:00+02:00", + "start": "12:00", + "duration": "00:225", + "room": "QAware Lounge", + "title": "From Zero to Hero – GitOps Workshop mit K8s/Terraform/ArgoCD auf Open Telekom Cloud", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2665", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

In diesem Workshop habt ihr die Möglichkeit, das im “From Zero to Hero – Best Practices aus cloud-native GitOps-Projekten”-Vortrag gezeigte Setup selbst aufzusetzen. Dabei lernt ihr mit Unterstützung mehrerer erfahrener CloudOps-Tutoren, wie ihr den gesamten Prozess von einer blanken Cloud bis hin zu dutzenden laufenden Services komplett automatisiert.

Wir provisionieren mit euch auf Basis der Open Telekom Cloud ein Kubernetes Cluster (CCE) inkl. Autoscaling, ELB, DNS und allem, was dazugehört. Alles aufgesetzt durch Terraform und Infrastructure as Code. Weiter geht es für euch mit dem boostrapping von ArgoCD über Terraform, um danach automatisiert die Services wie CertManager, IngressController, elastic-stack und kafka zu installieren und konfigurieren. Interesse? Dann nehmt teil am Workshop.


Relevante Links
• Terraform Live Demo Source Code (https://github.com/iits-consulting/otc-terraform-template)
• ArgoCD Live Demo Source Code (https://github.com/iits-consulting/otc-infrastructure-charts-template)


Voraussetzungen:

  • Laptop (mit „freiem“ Internetzugang)
  • Entwicklertools:
  1. Terraform Version 1.3.5. Wir würden tfenv empfehlen
  2. otc-auth. Wir benötigen das um uns über die CLI einloggen zu können und die kube config zu holen
  3. Eine vernünftige Shell. Wenn du Windows verwendest dann nutz bitte GitBash
  4. kubectl cli
  5. jq
  6. git
  7. Github Account
  • Wir stellen euch einen kostenfreien Account auf der Open Telekom Cloud für die Dauer des Workshops. Am Anfang des Workshops erhaltet ihr einen Briefumschlag mit den Zugangsdaten.
", + "persons": [ + { + "id": 40105, + "public_name": "Victor Getz" + }, + { + "id": 42069, + "public_name": "Ulrich Schneider" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_advanced" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Community Hall": [ + { + "id": 2686, + "date": "2023-06-23T11:00:00+02:00", + "start": "11:00", + "duration": "00:300", + "room": "Community Hall", + "title": "Innovation Hacking Showcases im Expo-Bereich", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2686", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Euch erwartet eine Anzahl an innovativen Showcases des Innovation Hacking Teams der TNG Technology Consulting GmbH, inklusive Realtime Deepfakes, Realtime Style Transfer, Music AI, PowerPoint GhostWriter AI und vielen mehr.

Erlebt das futuristische Potenzial von KI hautnah! Unser Innovation Hacking Team stellt auf der Konferenz atemberaubende Projekte vor, die ihr selbst ausprobieren könnt. Lasst euch von der Power der Künstlichen Intelligenz begeistern und erfahrt mehr über die Möglichkeiten und Herausforderungen dieser Technologie.

", + "persons": [ + { + "id": 38505, + "public_name": "Martin Förtsch" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ], + "Cloud Universe (virtuell)": [ + { + "id": 2691, + "date": "2023-06-23T09:00:00+02:00", + "start": "09:00", + "duration": "00:480", + "room": "Cloud Universe (virtuell)", + "title": "JUG Oberland: Pixelflut", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2691", + "track": "DevOps & Methodik", + "language": "de", + "abstract": "

Es wird ein über das Konferenz-Netzwerk erreichbarer Server aufgestellt, der über einen Beamer einen Canvas zur Verfügung stellt. Der Canvas kann von den Konferenzteilnehmern in nachfolgender Art und Weise befüllt werden.


Der Server ist über \"telnet\" erreichbar (unverschlüsselter Text ohne Authentifizierung).

Der Server versteht folgende Befehle (die tatsächlich verwendete Implementierung könnte weitere unterstützen):
​​​​​​​
- SIZE
- QUIT
- PX x y RRGGBB

SIZE liefert die Größe des Canvas in Pixeln zurück (z.B. 6000x4000).
QUIT beendet die Session ordentlich.
PX x y fragt die aktuelle Farbe des angegebenen Pixels ab.
PX x y RRGGBB setzt die Farbe des angegebenen Pixels auf die angegebene RGB-Farbe.

Da der Server innerhalb des Konferenz-Netzwerks erreichbar ist, können über die Befehle alle interessierten Teilnehmer den Inhalt des Canvas beeinflussen. Die Idee ist, dass die Teilnehmer kleine Programme schreiben, die programmatisch Bilder generieren oder Bilddateien auf den Canvas projezieren. 


Da die Teilnehmer Beiträge der anderen Teilnehmer auch überschreiben können, entsteht in Spitzenzeiten ein Wettkampf um den Canvas und dessen Inhalt.


Das System wird nicht weiter beschrieben, lediglich Serveradresse und Port sind sichtbar. Die Idee ist, dass sich die Methodik der Canvas-Befüllung unter den Teilnehmern rumspricht.

", + "persons": [ + { + "id": 40043, + "public_name": "Sandra Fischer" + } + ], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_beginner" + ], + "featureTags": [] + }, + { + "id": 2694, + "date": "2023-06-23T11:00:00+02:00", + "start": "11:00", + "duration": "00:240", + "room": "Cloud Universe (virtuell)", + "title": "CloudLand plays!", + "type": "lecture", + "url": "https://meine.doag.org/#agendaId.2694", + "track": "Container- & Cloud-Technologien", + "language": "de", + "abstract": "

Auf einem Bildschirm lassen wir eine Anwendung laufen, die wir - inspiriert von \"Twitch plays Pokémon\" - geschrieben haben.


Die Einführung zum Spiel findet am Mittwoch, den 21.06.2023 um 11:00 Uhr in der Blue Lounge statt!


Let's play!

", + "persons": [], + "guid": null, + "logo": null, + "slug": null, + "subtitle": null, + "description": null, + "recording_license": null, + "do_not_record": false, + "links": [], + "attachments": [], + "crossChannelTopics": [], + "difficulty": [ + "eventslot_difficulty_no degree" + ], + "featureTags": [ + "eventslot_feature_demo" + ] + } + ] + } + } + ] + } + } +}