Oude-site Article

HOME
About
Contact
Disclaimer
Privacy

Azure DevOps Tutorial: Dein Erfolg Mit CI/CD

Oct 23, 2025 by Oude-site 45 views

Azure DevOps Tutorial: Dein Erfolg mit CI/CD Sieh mal einer an, du bist hier, um die Geheimnisse von _Azure DevOps_ zu lüften – und das auf Deutsch! Na, dann bist du hier genau richtig, meine Lieben. Dieses **umfassende Azure DevOps Tutorial** nimmt dich an die Hand und führt dich durch die faszinierende Welt der Softwareentwicklung, wo Effizienz, Zusammenarbeit und *schnelle Releases* keine leeren Versprechen sind, sondern gelebte Realität. Stell dir vor, du könntest den gesamten Lebenszyklus deiner Software – von der Ideenfindung über die Entwicklung, das Testen bis hin zur Bereitstellung – nahtlos und automatisiert verwalten. Genau das ermöglicht Azure DevOps. Es ist nicht nur ein Tool; es ist eine *Plattform*, die Entwicklern, Testern, Projektmanagern und Operations-Teams hilft, enger zusammenzuarbeiten und dabei die Qualität und Geschwindigkeit der Softwarelieferung massiv zu steigern. Wir reden hier von einer _All-in-One-Lösung_ von Microsoft, die eine breite Palette an Dienstleistungen bietet, von der Versionskontrolle über agile Planungstools bis hin zu leistungsstarken CI/CD-Pipelines. Egal, ob du ein alter Hase in der Softwareentwicklung bist oder gerade erst deine ersten Schritte machst, dieses Tutorial ist darauf ausgelegt, dir einen **tiefgreifenden Einblick** zu geben und dich zu befähigen, Azure DevOps effektiv in deinen Projekten einzusetzen. Wir werden uns ansehen, wie du Projekte aufsetzt, wie du deine Arbeit mit Boards organisierst, deinen Code sicher in Repos verwaltest, deine Software mit Pipelines automatisch baust und bereitstellst, wie du Tests planst und sogar, wie du deine Artefakte versionierst. Bereite dich darauf vor, die Art und Weise, wie du Software entwickelst, zu revolutionieren. Wir tauchen tief in die Materie ein, nutzen eine _lockere, verständliche Sprache_ und zeigen dir _praktische Beispiele_, damit du das Gelernte sofort anwenden kannst. Also, schnall dich an, es wird eine spannende Fahrt durch die Welt von Azure DevOps! # Was ist Azure DevOps überhaupt? Na, **was ist Azure DevOps** denn nun eigentlich genau, fragst du dich vielleicht? Ganz einfach erklärt, ist Azure DevOps das Schweizer Taschenmesser für deine Softwareentwicklung – eine _umfassende Suite von Diensten_, die dir und deinem Team dabei hilft, Softwareprojekte von Anfang bis Ende zu planen, zu entwickeln, zu testen und bereitzustellen. Und das alles, wie der Name schon sagt, von Microsoft und tief integriert in die Azure Cloud. Es ist *viel mehr als nur ein Versionskontrollsystem* oder ein Task-Management-Tool; es ist eine Plattform, die wirklich den kompletten Application Lifecycle Management (ALM)-Zyklus abdeckt. Die Kernidee dahinter ist, Silos zwischen Entwicklung, Betrieb und Projektmanagement aufzubrechen und eine _nahtlose Zusammenarbeit_ zu fördern, was im modernen DevOps-Paradigma ja der heilige Gral ist. Stell dir vor, du hast ein Team, das an einer komplexen Anwendung arbeitet. Ohne Azure DevOps könntest du für die Planung Jira verwenden, für den Code GitHub, für das CI/CD Jenkins, und für das Testmanagement vielleicht noch ein separates Tool. Das bedeutet viele Konfigurationen, viele Integrationen und oft auch Reibungsverluste. _Azure DevOps_ bündelt all diese Funktionalitäten unter einem Dach. Das spart nicht nur Zeit und Nerven bei der Einrichtung, sondern sorgt auch für einen **konsistenten Workflow** und eine _transparente Sichtbarkeit_ über den gesamten Projektfortschritt. Es bietet eine **einheitliche Umgebung** für deine Entwicklungsteams, was bedeutet, dass jeder genau weiß, wo er seine Aufgaben findet, wo der aktuelle Code liegt, welche Tests durchgeführt wurden und wie der Status der neuesten Bereitstellung ist. Das Schöne daran ist, dass es _modular aufgebaut_ ist. Das heißt, du musst nicht alle Dienste nutzen, wenn du nicht willst. Wenn du zum Beispiel schon ein Repository auf GitHub hast, kannst du Azure Pipelines trotzdem wunderbar dafür nutzen, um deine Builds und Deployments zu automatisieren. Wenn du aber ein **komplettes End-to-End-Erlebnis** möchtest, dann sind alle Dienste perfekt aufeinander abgestimmt und arbeiten Hand in Hand. Die wichtigsten Säulen, die wir in diesem **Azure DevOps Tutorial** genauer beleuchten werden, sind _Azure Boards_ (für die agile Planung), _Azure Repos_ (für die Versionskontrolle deines Codes), _Azure Pipelines_ (für die Automatisierung von Builds und Releases, also CI/CD), _Azure Test Plans_ (für das Testmanagement) und _Azure Artifacts_ (für das Paketmanagement). Jedes dieser Module ist für sich schon super mächtig, aber ihre wahre Stärke entfalten sie erst im Zusammenspiel. Es ist also nicht nur ein Toolset, sondern ein _Ökosystem_, das darauf ausgelegt ist, die Produktivität deines Teams zu maximieren und die Qualität deiner Software kontinuierlich zu verbessern. Und das Beste daran: Für kleine Teams und Open-Source-Projekte gibt es sogar eine **kostenlose Stufe**, sodass du sofort loslegen und dich damit vertraut machen kannst, ohne einen Cent ausgeben zu müssen. Ein _echter Game Changer_ für jede moderne Softwareentwicklung! # Der Einstieg: Dein erstes Azure DevOps Projekt So, meine Lieben, jetzt wird's ernst! Bevor wir uns in die Details der einzelnen Dienste stürzen, müssen wir erst mal die Basis legen: **Dein erstes Azure DevOps Projekt erstellen**. Das ist wirklich der _erste und wichtigste Schritt_, um in die Welt von Azure DevOps einzutauchen und all die fantastischen Funktionen nutzen zu können, die es zu bieten hat. Stell dir vor, du startest ein neues Softwareprojekt – egal ob es eine kleine Web-App, eine mobile Anwendung oder ein komplexes Unternehmenssystem ist – du brauchst einen zentralen Ort, an dem dein Team zusammenarbeiten kann. Azure DevOps bietet genau diesen Ort. Der Prozess ist _erstaunlich intuitiv_ und führt dich Schritt für Schritt durch die Einrichtung deiner Entwicklungsumgebung. Zuerst brauchst du natürlich ein Azure-Konto oder zumindest ein Microsoft-Konto. Wenn du das hast, kannst du direkt loslegen und eine _Azure DevOps Organisation_ erstellen. Die Organisation ist quasi dein Dach über allen Projekten und repräsentiert dein Unternehmen oder dein Team. Darin kannst du dann mehrere Projekte anlegen, jedes mit seinen eigenen Einstellungen, Teams und Code-Repositories. Das ermöglicht eine **saubere Trennung** deiner verschiedenen Arbeitsbereiche, was besonders praktisch ist, wenn du an mehreren Projekten gleichzeitig arbeitest oder verschiedene Kunden betreust. Bei der Projekterstellung musst du ein paar wichtige Entscheidungen treffen, die den Workflow deines Projekts maßgeblich beeinflussen werden. Dazu gehören die Auswahl des _Prozessmodells_ (Agile, Scrum, CMMI) und des _Versionskontrollsystems_ (Git oder TFVC). Keine Sorge, diese Entscheidungen sind nicht in Stein gemeißelt, aber eine gut überlegte Wahl am Anfang erspart dir später Umwege. Das _Prozessmodell_ legt fest, welche Arbeitselementtypen (wie User Stories, Bugs, Tasks) und Workflow-Zustände (wie Neu, Aktiv, Geschlossen) dein Projekt verwenden wird. Für die meisten agilen Teams sind **Agile** oder **Scrum** die erste Wahl, da sie gut zu den gängigen Entwicklungspraktiken passen. _Git_ ist heutzutage der De-facto-Standard für die Versionskontrolle und wird von den meisten Entwicklern bevorzugt, da es distributed ist und eine hohe Flexibilität bei der Branch-Verwaltung bietet. TFVC (Team Foundation Version Control) ist eine zentralisierte Alternative, die eher in älteren oder spezifischen Unternehmensumgebungen zum Einsatz kommt. Für dieses **Azure DevOps Tutorial** und moderne Entwicklungspraktiken werden wir uns definitiv auf _Git_ konzentrieren. Der ganze Prozess ist darauf ausgelegt, dir eine _reibungsloseste Erfahrung_ zu bieten, sodass du dich schnell auf das Wesentliche konzentrieren kannst: _hochwertige Software zu entwickeln_. Also, keine Angst vor dem ersten Klick – legen wir los und schaffen die Grundlage für all die coolen Dinge, die wir noch zusammen lernen werden! ### Organisation und Projekt erstellen Okay, fangen wir mit dem Allerwichtigsten an: Eine **Azure DevOps Organisation und ein neues Projekt erstellen**. Das ist wie der Grundstein für dein digitales Bauvorhaben. Öffne einfach deinen Browser und navigiere zu `dev.azure.com`. Falls du noch kein Konto hast, wirst du aufgefordert, dich mit einem Microsoft-Konto anzumelden oder eines zu erstellen. Ist das erledigt, kommst du zu einer Seite, auf der du deine _Organisation erstellen_ kannst. Wähle einen Namen, der dein Unternehmen oder dein Team gut repräsentiert, z.B. „MeineSuperDevs“ oder „TechInnovationsGmbH“. Achte darauf, dass der Name einzigartig ist, da er Teil deiner URL sein wird (`dev.azure.com/MeineSuperDevs`). Wähle auch die Region aus, in der deine Daten gehostet werden sollen, typischerweise die, die dir am nächsten liegt, um die Latenz gering zu halten. Sobald die Organisation steht, wirst du zum Erstellen deines **ersten Projekts** aufgefordert. Gib deinem Projekt einen aussagekräftigen Namen, z.B. „MeinErstesWebAppProjekt“. Die _Sichtbarkeit_ des Projekts kann entweder „Öffentlich“ (jeder kann es sehen) oder „Privat“ (nur Teammitglieder haben Zugriff) sein. Für die meisten internen Entwicklungsprojekte ist „Privat“ die bevorzugte Option. Bei den _erweiterten Einstellungen_ triffst du, wie oben erwähnt, zwei wichtige Entscheidungen: Das **Versionskontrollsystem** und den **Arbeitsprozess**. Für das Versionskontrollsystem empfehle ich dir dringend, _Git_ auszuwählen. Es ist der Standard in der Branche und bietet die größte Flexibilität. Beim Arbeitsprozess wählst du am besten _Scrum_ oder _Agile_. Scrum ist ideal für Teams, die in Sprints arbeiten und einen klaren Backlog priorisieren, während Agile etwas allgemeiner ist und oft für Teams verwendet wird, die weniger strenge Sprint-Zyklen haben. Für den Anfang ist _Scrum_ eine ausgezeichnete Wahl. Klicke auf „Erstellen“ und voilà – dein erstes Azure DevOps Projekt ist geboren! Du wirst auf die Projektübersichtsseite weitergeleitet, die ein Dashboard und erste Schritte anzeigt. Herzlichen Glückwunsch, der Grundstein ist gelegt! ### Versionskontrolle verstehen: Git vs. TFVC Lasst uns kurz über **Versionskontrolle** sprechen, denn das ist das A und O jeder modernen Softwareentwicklung. In Azure DevOps hast du die Wahl zwischen _Git_ und _TFVC (Team Foundation Version Control)_. Aber mal ehrlich, Leute, in der heutigen Zeit ist **Git** der klare Champion. Es ist ein _verteiltes Versionskontrollsystem_ (DVCS), das bedeutet, jeder Entwickler hat eine vollständige Kopie des Repositories auf seinem lokalen Rechner. Das ermöglicht Offline-Arbeit, schnelle Commits und eine enorme Flexibilität bei der Erstellung und Verwaltung von Branches. Wenn du mit Git arbeitest, pusht du deine Änderungen von deinem lokalen Repo in ein *Remote Repo* (in diesem Fall das Azure Repos). Das ist der Standard für moderne Entwicklung und bietet eine Menge Vorteile, wie zum Beispiel die einfache Integration mit Tools wie GitHub oder GitLab, falls du mal wechseln möchtest. _TFVC_ hingegen ist ein *zentralisiertes Versionskontrollsystem*. Das bedeutet, es gibt ein einziges, zentrales Repository, und Entwickler arbeiten direkt mit diesem. Wenn du Änderungen machen willst, musst du typischerweise Dateien auschecken, was zu Sperrkonflikten führen kann. Es ist ein älteres Modell, das oft in älteren Projekten oder bei Teams zum Einsatz kommt, die noch nicht auf Git umgestiegen sind. Für dieses **Azure DevOps Tutorial** werden wir uns ausschließlich auf _Git_ konzentrieren, da es die modernen Best Practices repräsentiert und die meisten Vorteile für agile Teams bietet. Git ist flexibel, robust und die _erste Wahl_ für fast alle neuen Projekte. # Boards: Dein Backlog und Sprint-Management Okay, liebe Leute, nachdem wir jetzt unser erstes Projekt in **Azure DevOps** aufgesetzt haben, tauchen wir ein in den vielleicht sichtbarsten und für die Planung zentralsten Bereich: die **Azure Boards**. Stell dir vor, du hast eine Idee für eine geniale Software – aber wie behältst du den Überblick über all die Features, Bugs, Tasks und User Stories, die dafür notwendig sind? Genau hier kommen die Azure Boards ins Spiel! Sie sind dein _digitales Command Center_ für die agile Planung und das Tracking deines Fortschritts. Mit den Boards kannst du den gesamten Arbeitsfluss deines Teams transparent machen, vom initialen Brainstorming bis zur abgeschlossenen Implementierung. Sie bieten eine **flexible und intuitive Möglichkeit**, Arbeitselemente zu definieren, zu priorisieren und zu verfolgen, egal ob du nach _Scrum_, _Agile_ oder _Kanban_ arbeitest. Das Herzstück der Boards ist dein **Backlog**. Hier sammelst du alle Ideen, Anforderungen, Bugs und Aufgaben, die in deinem Projekt anfallen. Du kannst sie priorisieren, Details hinzufügen, Schätzungen vornehmen und sie Teams oder einzelnen Entwicklern zuweisen. Das Schöne daran ist, dass jeder im Team immer sehen kann, woran gerade gearbeitet wird, was als Nächstes ansteht und welche Elemente bereits erledigt wurden. Das schafft eine _unglaubliche Transparenz_ und fördert die Zusammenarbeit, da niemand im Dunkeln tappt. Die Boards ermöglichen es dir auch, deine Arbeit in **Sprints** zu organisieren, was für Scrum-Teams unerlässlich ist. Du kannst Sprints definieren, Arbeitselemente in diese Sprints ziehen und den Fortschritt deines Teams während des Sprints über Burndown-Charts und andere Metriken verfolgen. Das gibt dir und deinem Team eine _klare Fokussierung_ auf das, was in einem bestimmten Zeitraum erreicht werden soll. Für Teams, die eher einen kontinuierlichen Fluss bevorzugen, bieten die **Kanban-Boards** eine hervorragende Visualisierung des Workflows. Hier siehst du auf einen Blick, welche Arbeitselemente sich in welcher Phase befinden – von „Neu“ über „In Entwicklung“ bis „Erledigt“. Du kannst Spalten anpassen, Swimlanes hinzufügen und Work-in-Progress (WIP)-Grenzen festlegen, um Engpässe zu identifizieren und einen _stetigen Fluss_ der Arbeit zu gewährleisten. Die Integration der Boards mit anderen Diensten in Azure DevOps ist dabei super praktisch. Wenn du zum Beispiel einen Bug in einem Testplan findest, kannst du ihn direkt mit einem Arbeitselement in den Boards verknüpfen. Oder wenn ein Entwickler Code in Repos eincheckt, kann er den Commit mit einem Task verknüpfen, sodass man immer nachvollziehen kann, welche Codeänderung zu welchem Arbeitselement gehört. Diese **durchgängige Rückverfolgbarkeit** ist extrem wertvoll für die Qualitätssicherung und das Projektmanagement. Kurz gesagt, die Azure Boards sind dein _zentrales Nervensystem_ für die Projektplanung und -verfolgung. Sie helfen dir, den Überblick zu behalten, Prioritäten zu setzen und dein Team auf die wichtigsten Ziele auszurichten. Ohne sie wäre agiles Arbeiten in **Azure DevOps** nur halb so effektiv! ### Arbeitselemente und Backlog-Pflege So, packen wir's an: Das Herzstück der Azure Boards sind die **Arbeitselemente**. Das sind im Grunde digitale Karten, die alles darstellen können, was in deinem Projekt getan werden muss. Je nachdem, welchen Prozess (Agile, Scrum, CMMI) du beim Erstellen deines Projekts gewählt hast, hast du verschiedene Arten von Arbeitselementen zur Verfügung. Bei _Scrum_ hast du zum Beispiel **Epics**, **Features**, **Product Backlog Items (PBIs)** und **Tasks**. Epics sind große, übergeordnete Anforderungen, die sich über mehrere Releases erstrecken können. Features sind kleinere, aber immer noch bedeutende Funktionen, die ein Epic unterteilen. PBIs sind die konkreten, entwickelbaren User Stories oder nicht-funktionale Anforderungen, die in Sprints bearbeitet werden. Und Tasks sind die kleinsten Einheiten, die einzelne Entwicklungsschritte innerhalb eines PBIs beschreiben. Bei _Agile_ sind die Bezeichnungen ähnlich: **Epics**, **Features**, **User Stories** und **Tasks**. Das Prinzip bleibt dasselbe: Du zerlegst große Anforderungen in immer kleinere, handhabbare Einheiten. Die **Backlog-Pflege** ist entscheidend für den Erfolg deines Projekts. Stell dir den Backlog wie eine immerwährende To-Do-Liste vor. Hier kommen alle Ideen, Anforderungen und Bugs rein. Es ist wichtig, diesen Backlog regelmäßig zu pflegen, zu priorisieren und Details hinzuzufügen. Eine gute Backlog-Pflege beinhaltet: * **Priorisierung**: Was ist am wichtigsten? Was bringt den größten Wert? * **Detaillierung**: Die Arbeitselemente sollten klar und verständlich beschrieben sein. * **Schätzung**: Eine grobe Aufwandsschätzung hilft bei der Planung. * **Zerlegung**: Große Elemente in kleinere, überschaubare Teile zerlegen. Nutze die Drag-and-Drop-Funktion, um Elemente im Backlog zu verschieben und so ihre Priorität festzulegen. Füge Beschreibungen, Akzeptanzkriterien, Anhänge und Diskussionen hinzu, um sicherzustellen, dass jeder im Team die Anforderungen versteht. Die Backlog-Pflege ist ein _kontinuierlicher Prozess_, der dir hilft, den Fokus zu behalten und sicherzustellen, dass dein Team immer an den wertvollsten Dingen arbeitet. ### Sprint-Planung und Kanban-Boards Sobald dein Backlog gut gepflegt ist, kannst du mit der **Sprint-Planung** loslegen (wenn du mit Scrum arbeitest). In Azure DevOps gehst du zu den „Boards“ und dann zu „Sprints“. Hier definierst du die _Iteration Paths_ (die Sprints) deines Projekts mit Start- und Enddaten. Für jeden Sprint kannst du dann die relevanten Product Backlog Items (PBIs) aus deinem Backlog in den Sprint ziehen. Der _Sprint Backlog_ gibt deinem Team einen klaren Überblick über das, was im aktuellen Sprint erreicht werden soll. Die **Sprint-Ansicht** bietet dir ein leistungsstarkes Werkzeug, um den Fortschritt zu verfolgen. Hier siehst du die PBIs und die dazugehörigen Tasks. Du kannst den Status der Tasks von „Neu“ über „Aktiv“ bis „Abgeschlossen“ ändern. Das System zeigt dir auch die _Kapazität_ deines Teams an, damit du Sprints realistisch planen und Überlastungen vermeiden kannst. Für Teams, die einen kontinuierlichen Fluss bevorzugen, sind die **Kanban-Boards** die perfekte Wahl. Du findest sie unter „Boards“ -> „Boards“. Ein Kanban-Board visualisiert deinen Workflow als Spalten, z.B. „Neu“, „In Entwicklung“, „In Test“, „Erledigt“. Du kannst deine Arbeitselemente einfach per Drag-and-Drop von einer Spalte zur nächsten ziehen. Ein _riesiger Vorteil_ der Kanban-Boards ist die Möglichkeit, **Work-in-Progress (WIP)-Limits** festzulegen. Das bedeutet, du definierst, wie viele Arbeitselemente maximal in einer bestimmten Spalte gleichzeitig aktiv sein dürfen. Dies zwingt dein Team, sich auf die Fertigstellung von Aufgaben zu konzentrieren, bevor neue begonnen werden, was die Effizienz steigert und Engpässe reduziert. Die Kanban-Boards sind vollständig anpassbar: Du kannst Spalten hinzufügen, umbenennen oder entfernen und auch _Swimlanes_ verwenden, um verschiedene Arten von Arbeit oder Teams zu trennen. # Repos: Code-Management leicht gemacht So, liebe Entwickler-Community, kommen wir jetzt zu einem ganz entscheidenden Bereich in **Azure DevOps**, der für uns Coder das absolute Zentrum darstellt: die **Azure Repos**. Hier passiert die Magie, hier lebt euer Code! Stell dir vor, du arbeitest an einem Projekt mit mehreren Teammitgliedern, und jeder schreibt an verschiedenen Teilen des Codes. Ohne ein robustes Versionskontrollsystem wäre das _Chaos vorprogrammiert_ – wer hat welche Änderungen gemacht? Wo ist die aktuelle Version? Wie können wir Fehler rückgängig machen? All diese Fragen beantworten die Azure Repos, indem sie dir ein _hochleistungsfähiges und flexibles_ System zur Verfügung stellen, um deinen Quellcode sicher zu verwalten und effektiv im Team zusammenzuarbeiten. Azure Repos unterstützt, wie wir bereits erwähnt haben, sowohl _Git_ als auch _TFVC_, wobei _Git_ heutzutage der absolute Industriestandard und die bevorzugte Wahl für moderne Entwicklungsteams ist. Wir werden uns daher voll auf die **Git-Repositories** innerhalb von Azure Repos konzentrieren. Mit Git hast du die volle Kontrolle über deine Codebasis. Jeder Entwickler hat eine lokale Kopie des gesamten Repositories, was ein _schnelles Arbeiten_ ermöglicht, auch wenn keine Internetverbindung besteht. Du kannst Änderungen lokal committen, verschiedene Feature-Branches erstellen, experimentieren und erst dann deine Änderungen mit dem Hauptentwicklungszweig zusammenführen, wenn sie stabil und getestet sind. Die _Vorteile von Azure Repos_ gehen aber weit über die reine Versionskontrolle hinaus. Es ist tief in die anderen Dienste von Azure DevOps integriert, was bedeutet, dass deine Codeänderungen nahtlos in den CI/CD-Pipelines ausgelöst werden können, Pull Requests mit Arbeitselementen aus den Boards verknüpft sind und Branch Policies die Codequalität sichern. Du hast hier also nicht nur einen Ort, um deinen Code zu speichern, sondern ein **intelligentes Ökosystem**, das deine Entwicklungsprozesse optimiert. Egal ob du große Monorepos hast oder viele kleine Microservices verwaltest, Azure Repos bietet die Skalierbarkeit und die Werkzeuge, die du brauchst. Du kannst _private Repositories_ erstellen, die nur für dein Team zugänglich sind, oder _öffentliche Repositories_, falls du an Open-Source-Projekten arbeitest. Die Benutzeroberfläche ist _intuitiv gestaltet_, sodass du schnell Code durchsuchen, die Historie einsehen, Unterschiede zwischen Versionen vergleichen und natürlich Pull Requests erstellen und überprüfen kannst. Die **Power von Git in Kombination mit der Enterprise-Grade-Stabilität und den Integrationsmöglichkeiten von Azure DevOps** macht Azure Repos zu einem unverzichtbaren Tool für jedes ernsthafte Softwareentwicklungsprojekt. Also, seid gespannt, denn jetzt geht's ans Eingemachte: Wir schauen uns an, wie ihr euren Code in diesen Repositories managt, wie ihr effektiv mit Branches arbeitet und wie ihr sicherstellt, dass nur qualitativ hochwertiger Code in euren Hauptzweig gelangt. Lasst uns die Welt des Code-Managements mit _Azure Repos_ erobern! ### Git-Workflows und Pull Requests Nachdem du dein Projekt in **Azure DevOps** erstellt hast, findest du unter „Repos“ dein Git-Repository. Der erste Schritt ist oft, das Repository auf deinen lokalen Rechner zu klonen. Du findest die Clone-URL direkt im Repos-Bereich. Mit einem Befehl wie `git clone [URL]` in deinem Terminal oder über deine bevorzugte IDE hast du eine lokale Kopie. Der gängigste _Git-Workflow_ für Teams ist der **Feature-Branch-Workflow**. Das bedeutet, für jede neue Funktion oder Bugfix erstellst du einen neuen Branch ausgehend vom Hauptzweig (oft `main` oder `master`). So arbeitest du isoliert, ohne den Hauptzweig zu beeinflussen. * `git checkout -b mein-neues-feature` erstellt einen neuen Branch und wechselt dorthin. * Nachdem du Änderungen vorgenommen hast, committest du sie lokal: `git add .` und `git commit -m

Related Posts

Joe Montana's Jersey Number: A Legacy In Football

Oct 30, 2025 49 views

Colorado Buffaloes: Retired Jersey Numbers & Legends

Oct 30, 2025 52 views

Dodgers Final Score Today: Game Highlights & Recap!

Oct 29, 2025 51 views

Maharashtra Election News: Live Updates & Results

Oct 23, 2025 49 views

Speedtest.net MOD APK: Everything You Need To Know

Oct 30, 2025 50 views

Iikatakan Putus Trans TV: Apa Yang Sebenarnya Terjadi?

Oct 23, 2025 54 views

Meghan Trainor's "Better When I'm Dancing": A Deep Dive

Oct 23, 2025 55 views

JDT Vs Selangor Final Showdown: Live Updates & Analysis

Oct 30, 2025 55 views

Brooklyn Nets Latest News: Updates, Trades & Player Stats

Oct 22, 2025 57 views

Samuel Johnson And Emma Rooke: A Love Story

Oct 30, 2025 43 views

100 HKD To IDR: Today's Best Exchange Rate

Nov 17, 2025 42 views

24K Gold Rate Today: Live Prices & Trends

Oct 23, 2025 41 views

New Post

WWI Poets: Voices From The Trenches

Dec 25, 2025 35 views

Amendments Game: Learn The Constitution

Dec 25, 2025 39 views

© 2025 Oude-site