Software Product Mastering / Produkt & Projekt / Methoden / Deliberating structures / Werkzeuge & Automatisierung
Software-Projekt mit gitlab¶
💡 WiP¶
Die hier erklärten Schritte sind aktuell noch ungetestet.
Hier eine kurze und stichpunktartige Zusammenfassung, wie GitLab für ein Webapp-Softwareprojekt mit .NET genutzt werden kann:
Repository einrichten:
- Erstelle ein GitLab-Repository für den Code.
- Struktur:
/src,/tests,/docsfür saubere Organisation.
CI/CD-Pipeline:
- Definiere eine
.gitlab-ci.yml-Datei zur Automatisierung von Build, Test und Deployment. - Beispiel:
dotnet build,dotnet test, Deployment-Skripte.
- Definiere eine
Branching und Merge Requests:
- Nutze Branches für Features/Tasks.
- Merge Requests für Code-Reviews und Integration.
Code-Reviews:
- Verwende Merge Requests für Feedback und Code-Qualitätssicherung.
Dokumentation:
- Nutze GitLab Wiki für Projektdokumentation.
- Achte auf eine detaillierte
README.md-Datei.
Aufgabenverwaltung:
- Verwende GitLab Issues zur Verwaltung von Aufgaben, Bugs und Features.
- Visualisiere den Fortschritt über Kanban-Board.
Kollaboration und Kommunikation:
- Nutze GitLab Discussions für Teamkommunikation.
- Erstelle Teams für verschiedene Gruppen oder Aufgaben.
Testing und Codequalität:
- Integriere Unit-Tests (z.B. mit xUnit, NUnit) in CI/CD.
- Verwende Tools wie SonarCloud zur Codequalität.
Deployment:
- Automatisiere das Deployment mit GitLab CI/CD (z.B. auf Server oder Cloud).
- Docker-Integration für containerisierte Anwendungen.
Das sorgt für eine effiziente Zusammenarbeit und kontinuierliche Qualitätssicherung im Projekt.
Nochmal zum Nachlesen...
GitLab ist ein exzellentes Tool für die Zusammenarbeit an Softwareprojekten und kann eine Gruppe optimal unterstützen, wenn sie gemeinsam an einem Webapp-Projekt mit z.B. .NET-Technologie arbeiten. Hier sind einige grundlegende Schritte und Best Practices, wie du GitLab für das Projekt nutzen kannst:
1. Repository einrichten¶
- Erstelle ein GitLab-Repository: Zu Beginn des Projekts solltest du ein GitLab-Repository erstellen, in dem der gesamte Quellcode und die Ressourcen des Projekts gespeichert werden. Gehe dazu in dein GitLab-Profil und erstelle ein neues Projekt.
- Repository-Struktur festlegen: Eine saubere und konsistente Struktur ist entscheidend. Eine typische Struktur für ein .NET-Webanwendungsprojekt könnte so aussehen:
/src /WebApp /Controllers /Models /Views /wwwroot /tests /docs- /src für den Code der Webanwendung.
- /tests für Unit-Tests oder Integrationstests.
- /docs für die Projektdokumentation.
2. GitLab CI/CD für Automatisierung¶
GitLab CI/CD ermöglicht es, Build- und Deployment-Pipelines zu automatisieren.
- CI/CD Pipeline einrichten: Du kannst eine
.gitlab-ci.ymlDatei anlegen, um deine Build- und Deployment-Prozesse zu definieren. - Beispiel einer
.gitlab-ci.ymlfür .NET-Projekte:image: mcr.microsoft.com/dotnet/aspnet:6.0 stages: - build - test - deploy variables: DOTNET_CLI_HOME: "/tmp" before_script: - apt-get update && apt-get install -y unzip - curl -sSL https://aka.ms/InstallAzureCLIDeb | sudo bash build: stage: build script: - dotnet build WebApp/WebApp.csproj test: stage: test script: - dotnet test WebApp.Tests/WebApp.Tests.csproj deploy: stage: deploy script: - echo "Deploying to production..." # Hier könnte ein Skript zum Deployen auf einen Server folgen
- Build: Baut das .NET-Projekt.
- Test: Führt Unit-Tests aus.
- Deploy: Kann auf eine Serverumgebung oder auf Docker/Cloud-Services zielen.
3. Branches und Merge Requests¶
- Branching-Strategie: Um die Arbeit an verschiedenen Features und Aufgaben zu organisieren, sollten Branches verwendet werden. Ein typisches Vorgehen ist:
- Main-Branch: Für die stabile Version des Projekts.
- Feature-Branches: Jeder Student oder jedes Team arbeitet an einem Feature in einem eigenen Branch.
- Merge Requests: Feature-Branches sollten über Merge Requests in den Main-Branch integriert werden, was es ermöglicht, Code-Reviews durchzuführen und sicherzustellen, dass der Code in die Hauptentwicklungslinie integriert wird.
4. Code-Reviews¶
- Merge Requests für Code-Reviews: Jeder Merge Request sollte von einem anderen Studenten oder Mentor überprüft werden. GitLab ermöglicht es, Kommentare direkt im Code zu hinterlassen und Diskussionen zu führen.
- Regeln für Pull-Requests: Stelle sicher, dass der Code vor dem Mergen mit den festgelegten Codestandards übereinstimmt und Unit-Tests erfolgreich sind.
5. Dokumentation¶
- Wikis nutzen: GitLab bietet ein integriertes Wiki, das für die Projektdokumentation genutzt werden kann (z.B. Architektur, Setup-Anweisungen).
- README-Datei: Achte darauf, dass das Repository eine gut dokumentierte
README.mdDatei enthält, die den Studenten erklärt, wie sie das Projekt lokal einrichten und ausführen können.
6. Aufgaben und Issues verwalten¶
- GitLab Issues: Nutze GitLab Issues, um Aufgaben, Bugs und Features zu verwalten. Du kannst Labels, Meilensteine und Assignees nutzen, um das Projekt zu organisieren.
- Kanban-Board: GitLab bietet ein Kanban-Board, das dir hilft, Aufgaben und den Fortschritt des Projekts zu visualisieren. Du kannst Aufgaben nach "To Do", "In Progress" und "Done" organisieren.
7. Kollaboration und Kommunikation¶
- GitLab Discussions: Ermutige die Studenten, Diskussionen in GitLab zu führen, wenn sie auf Probleme stoßen oder Fragen haben. Dies ist eine effektive Möglichkeit zur Zusammenarbeit.
- Teams und Rollen: Falls du mehrere Gruppen von Studenten hast, kannst du verschiedene Gruppen von GitLab-Teams erstellen, um bestimmte Repositories oder Bereiche zu verwalten.
8. Testing und Codequalität¶
- Unit-Tests mit xUnit oder NUnit: Stelle sicher, dass Unit-Tests mit .NET getestet werden. Dies kann durch Integration in die CI/CD-Pipeline erfolgen.
- SonarCloud oder CodeClimate für Codequalität: Du kannst Tools wie SonarCloud verwenden, um die Codequalität zu überwachen und sicherzustellen, dass Best Practices eingehalten werden.
9. Deployment¶
- Deployment in Cloud/Server: Du kannst GitLab CI/CD nutzen, um die Anwendung nach jedem Commit automatisch in eine Entwicklungs- oder Produktionsumgebung zu deployen.
- Docker-Integration: Falls die Anwendung containerisiert wird, kannst du Docker und GitLab CI/CD verwenden, um das Deployment zu automatisieren.
Durch diese Schritte wird GitLab zu einem effektiven Werkzeug für das Management und die Zusammenarbeit in einem .NET-basierten Webapp-Projekt. Es fördert das Teamwork, die Automatisierung und die Qualität des Codes.
Umgebungen im studentischen Umfeld¶
Entwicklungsumgebungen für Studenten¶
- Visual Studio Code (VSCode): Kostenlos, leichtgewichtig, unterstützt .NET, Docker, und DevContainers.
- Visual Studio Community Edition: Vollständige IDE, kostenlos für Studenten, bietet erweiterte .NET-Features.
Kostenlose Produktionsumgebungen¶
- Azure for Students: Kostenloses Guthaben für Hosting von Web-Apps, Datenbanken, und mehr.
- GitHub Pages: Kostenlos für statische Websites, geeignet für Blazor oder einfache .NET-Anwendungen.
- Heroku: Kostenloser Plan für Web-Apps, einfaches Setup.
- Vercel: Kostenloses Hosting für statische und serverseitig gerenderte Web-Apps.
- Glitch: Kostenloses Hosting, einfache APIs und Web-Apps.
- Netlify: Kostenloses Hosting für statische Seiten, automatische Deployments.
Cloud-Services für Studenten¶
- AWS Educate: Kostenloses Guthaben für Cloud-Dienste wie EC2 und RDS.
- Google Cloud Platform (GCP): Kostenlose Ressourcen für das Hosting von Anwendungen.
Docker und Containerization¶
- Docker Desktop: Lokal für Containerentwicklung, unterstützt Cloud-Deployment.
- Docker Hub: Kostenloses Speichern von Container-Images.
CI/CD und Automatisierung¶
- GitLab CI/CD: Automatisiertes Build- und Deployment, Tests und Builds direkt im Repository.
- GitHub Actions: Automatisierte Workflows für Builds, Tests und Deployments.
Nochmal zum Nachlesen...
Im studentischen Umfeld gibt es viele kostengünstige oder sogar kostenlose Entwicklung- und Produktionsumgebungen, die ideal für Webanwendungen mit .NET-Technologie geeignet sind. Hier sind einige empfohlene Optionen:
1. Entwicklungsumgebungen (für lokale Entwicklung)¶
Visual Studio Code (VSCode):
- Kostenlos und Open-Source: Ideal für .NET Core-Projekte. VSCode unterstützt .NET durch die Erweiterung „C#“ und bietet eine leichtgewichtige, anpassbare Entwicklungsumgebung.
- Features: Code-Completion, Debugging, Git-Integration und vieles mehr.
- Docker Support: Unterstützt Docker-Container für die Entwicklung von Anwendungen in isolierten Umgebungen.
- DevContainers: Mit DevContainers können die Studierenden eine vollständige Entwicklungsumgebung in einer Docker-Umgebung direkt im Editor starten.
Visual Studio Community Edition:
- Kostenlos für Studenten: Visual Studio bietet eine vollständige IDE für .NET-Entwickler, mit erweiterten Funktionen wie Debugging, Refactoring und Testmanagement.
- Integration von Azure, Docker und anderen Tools: Besonders nützlich, wenn du mit Azure oder Docker arbeitest.
2. Produktionsumgebungen (für das Hosting von Webapps)¶
Kostenlose Optionen für Hosting¶
Azure for Students:
- Kostenloses Guthaben: Microsoft bietet ein spezielles Programm für Studenten, das kostenlosen Zugang zu Azure-Diensten, wie App Services, Virtual Machines und SQL-Datenbanken bietet.
- Dienste: Du kannst Web-Apps, APIs, Datenbanken und viele andere Services auf Azure nutzen.
- Nutzung für Produktions- und Entwicklungsumgebungen: Azure bietet sowohl Entwicklungs- als auch Produktionslösungen für deine .NET-basierte Web-App.
GitHub Pages:
- Kostenlos für statische Websites: Ideal, wenn du eine einfache statische Webanwendung mit .NET oder Blazor erstellen möchtest.
- Deployment aus einem GitHub-Repository: Erlaube den Studierenden, direkt aus ihrem GitHub-Repo zu deployen.
Heroku:
- Kostenlose Web-Heroku Dynos: Heroku bietet eine kostenlose Stufe, bei der du Webanwendungen und APIs hosten kannst. Diese ist gut geeignet für kleinere Webanwendungen.
- Einfaches Setup: Besonders für Studenten, die nicht mit komplexeren Infrastruktur-Anbietern arbeiten möchten.
- .NET-Integration: Heroku bietet Unterstützung für .NET-Anwendungen über Docker.
Vercel:
- Kostenlos für Studenten: Vercel bietet einen einfach zu bedienenden Service für das Hosting von statischen und serverseitig gerenderten Webanwendungen. Wenn deine Anwendung ein Frontend mit React, Next.js oder Blazor hat, ist Vercel eine gute Wahl.
- Integration mit GitHub: Automatische Deployments direkt aus einem GitHub-Repository.
Glitch:
- Kostenloses Hosting für Web-Apps: Glitch ist eine weitere einfache Möglichkeit für das Hosting von Webanwendungen, wobei Studenten schnelle Deployments durchführen können.
- Einfache API-Verwaltung und Fullstack-Unterstützung.
Netlify:
- Kostenlose Hosting-Pläne für kleine Apps: Netlify bietet kostenlose Hosting-Pläne, die besonders gut für statische Seiten oder Jamstack-Architekturen geeignet sind.
- Automatische Deployments: Direktes Deployment aus Git-Repositories (GitHub, GitLab, Bitbucket).
Cloud-Services für Studenten¶
Amazon Web Services (AWS) Educate:
- Kostenloses Guthaben: AWS bietet über das AWS Educate-Programm kostenlosen Zugang zu einer Vielzahl von Cloud-Diensten, die für das Hosting von Webanwendungen und Datenbanken genutzt werden können.
- Dienste wie EC2, RDS und S3: Diese eignen sich gut für skalierbare Webanwendungen.
Google Cloud Platform (GCP) for Education:
- Kostenlose Ressourcen und Guthaben: Google bietet für Studierende kostenlose Cloud-Ressourcen, die du für das Hosting von .NET-Anwendungen nutzen kannst, inklusive Compute Engine und Firebase für Datenbanklösungen.
3. Docker und Containerization (lokale und Cloud-basierte Entwicklung)¶
Docker:
- Lokal mit Docker Desktop: Docker eignet sich hervorragend für die Erstellung von Containerumgebungen, die die Entwicklung und das Testing von .NET-Anwendungen vereinfachen.
- Cloud-Dienste wie AWS und Azure bieten umfassende Unterstützung für Docker-Container und ermöglichen eine einfache Bereitstellung in der Cloud.
Docker Hub:
- Kostenlose Repositories: Nutze Docker Hub, um Docker-Images zu speichern und in verschiedenen Umgebungen zu verwenden. Dies ist besonders hilfreich, um die Studenten an das Arbeiten mit Containern heranzuführen.
4. CI/CD und Automatisierung (für die Integration und Bereitstellung)¶
GitLab CI/CD:
- Automatisiertes Deployment: Mit GitLab CI/CD können die Studenten die Anwendung sowohl lokal als auch in die Cloud (z.B. auf Azure, AWS oder Heroku) deployen, sobald sie Änderungen in ihren Repositories vornehmen.
- Automatische Tests und Builds: Führe Tests und Builds direkt im GitLab-Repository durch, bevor du eine Version deployen kannst.
GitHub Actions:
- Automatisierte Workflows: Wenn das Projekt auf GitHub basiert, können GitHub Actions genutzt werden, um Builds, Tests und Deployments zu automatisieren. Es gibt vorgefertigte Actions für .NET, die du direkt verwenden kannst.
Fazit¶
Für das studentische Umfeld bieten sich kostenlose oder kostengünstige Entwicklungs- und Produktionsumgebungen wie Azure for Students, Heroku, GitHub Pages, Vercel und Docker an. Diese Dienste ermöglichen eine einfache Einrichtung und Verwaltung von Webanwendungen und eignen sich hervorragend, um Studenten sowohl in der Entwicklung als auch im Deployment zu unterstützen. Ideal ist auch der Einsatz von CI/CD-Tools wie GitLab oder GitHub Actions, um die Prozesse zu automatisieren und eine professionelle Entwicklungsumgebung zu simulieren.
Gitlab und Azure for Students¶
Zusammenfassung des Deployments auf Azure for Students mit GitLab CI/CD¶
Azure Setup:
- Erstelle einen Azure App Service und ein Service Principal (mit den Berechtigungen Contributor).
- Hole dir die Azure Subscription ID, Tenant ID, Client ID, und Client Secret aus dem Azure-Portal.
GitLab CI/CD Konfiguration:
- Image: Verwende ein .NET Docker-Image (z.B.
mcr.microsoft.com/dotnet/aspnet:6.0). - Stages: Definiere
build,test,deploy. - Before Script: Installiere die Azure CLI.
- Build Stage: Baue das .NET-Projekt.
- Test Stage: Führe Unit-Tests aus.
- Deploy Stage:
- Logge dich mit dem Azure Service Principal ein (
az login). - Setze die Azure Subscription (
az account set). - Veröffentliche die Anwendung (
dotnet publish). - Deploye auf Azure App Service (
az webapp deploy).
- Logge dich mit dem Azure Service Principal ein (
- Image: Verwende ein .NET Docker-Image (z.B.
Secrets verwalten in GitLab:
- Gehe zu Settings → CI / CD → Variables.
- Füge die folgenden Variablen hinzu:
AZURE_SUBSCRIPTION_ID,AZURE_TENANT_ID,AZURE_CLIENT_ID,AZURE_CLIENT_SECRET,AZURE_APP_NAME,AZURE_RESOURCE_GROUP,AZURE_APP_SERVICE_NAME.
- Diese Variablen sind während des CI/CD-Prozesses verfügbar und schützen sensible Daten.
Sicherheit:
- Speichere keine sensiblen Daten direkt in
.gitlab-ci.yml. - GitLab Secrets sind verschlüsselt und sicher während des Deployments verfügbar.
- Speichere keine sensiblen Daten direkt in
Beispiel .gitlab-ci.yml:¶
image: mcr.microsoft.com/dotnet/aspnet:6.0
stages:
- build
- test
- deploy
variables:
DOTNET_CLI_HOME: "/tmp"
before_script:
- curl -sSL https://aka.ms/InstallAzureCLIDeb | sudo bash
build:
stage: build
script:
- dotnet build src/WebApp/WebApp.csproj
test:
stage: test
script:
- dotnet test src/WebApp.Tests/WebApp.Tests.csproj
deploy:
stage: deploy
script:
- echo $AZURE_CLIENT_SECRET | az login --service-principal --username $AZURE_CLIENT_ID --password stdin --tenant $AZURE_TENANT_ID
- az account set --subscription $AZURE_SUBSCRIPTION_ID
- dotnet publish src/WebApp/WebApp.csproj -c Release -o ./publish
- az webapp deploy --resource-group $AZURE_RESOURCE_GROUP --name $AZURE_APP_SERVICE_NAME --src-path ./publish --type zip
only:
- main
Fazit:¶
- CI/CD automatisiert das Builden, Testen und Deployen auf Azure.
- Secrets werden sicher in GitLab verwaltet.
- Deployment erfolgt durch Azure CLI innerhalb der GitLab Pipeline.
Nochmal zum Nachlesen...
Das Deployment einer .NET-Anwendung auf Azure for Students über GitLab CI/CD erfordert einige grundlegende Schritte, um die Anwendung zu erstellen, zu testen und anschließend auf Azure zu deployen. Zusätzlich ist es wichtig, sensible Daten wie API-Keys oder Verbindungszeichenfolgen sicher zu verwalten. Hier ist eine detaillierte Anleitung, wie das in deiner .gitlab-ci.yml aussehen könnte und wie du Secrets sicher verwaltest.
1. Azure-Setup¶
Bevor du mit dem Deployment beginnst, musst du sicherstellen, dass dein Azure-Account korrekt eingerichtet ist. Im Fall von Azure for Students erhältst du kostenloses Guthaben, aber du musst ein paar Dinge einrichten:
- Azure App Service: Erstelle einen Azure App Service, um deine Anwendung zu hosten.
- Azure Service Principal: Erstelle ein Service Principal (eine Identität, die von GitLab verwendet wird, um sich bei Azure zu authentifizieren), das GitLab die Berechtigung zum Deployment gibt.
2. Azure Service Principal erstellen¶
Um deine Azure App in GitLab zu deployen, musst du ein Service Principal erstellen, das du in deiner GitLab CI/CD Pipeline nutzen kannst:
- Melde dich bei deinem Azure-Portal an.
- Gehe zu Azure Active Directory → App Registrations → New registration und registriere eine neue Anwendung.
- Erstelle ein Secret für diese App unter Certificates & Secrets.
- Vergib die Berechtigungen Contributor auf der Ressourcengruppe oder App Service Ebene.
Die Service Principal-Daten (App-ID, Tenant-ID und Secret) müssen sicher in GitLab hinterlegt werden.
3. GitLab CI/CD Setup¶
In der .gitlab-ci.yml definierst du den gesamten CI/CD-Prozess, einschließlich des Builds, Tests und Deployments auf Azure.
Beispiel einer .gitlab-ci.yml Datei:¶
image: mcr.microsoft.com/dotnet/aspnet:6.0
stages:
- build
- test
- deploy
variables:
DOTNET_CLI_HOME: "/tmp"
AZURE_SUBSCRIPTION_ID: "your-subscription-id"
AZURE_TENANT_ID: "your-tenant-id"
AZURE_CLIENT_ID: "your-client-id"
AZURE_CLIENT_SECRET: "your-client-secret"
AZURE_APP_NAME: "your-app-name"
AZURE_RESOURCE_GROUP: "your-resource-group"
AZURE_APP_SERVICE_NAME: "your-app-service-name"
before_script:
- curl -sSL https://aka.ms/InstallAzureCLIDeb | sudo bash
build:
stage: build
script:
- dotnet build src/WebApp/WebApp.csproj
artifacts:
paths:
- bin/
test:
stage: test
script:
- dotnet test src/WebApp.Tests/WebApp.Tests.csproj
deploy:
stage: deploy
script:
# Log into Azure
- echo $AZURE_CLIENT_SECRET | az login --service-principal --username $AZURE_CLIENT_ID --password stdin --tenant $AZURE_TENANT_ID
- az account set --subscription $AZURE_SUBSCRIPTION_ID
# Publish to Azure App Service
- dotnet publish src/WebApp/WebApp.csproj -c Release -o ./publish
- az webapp deploy --resource-group $AZURE_RESOURCE_GROUP --name $AZURE_APP_SERVICE_NAME --src-path ./publish --type zip
only:
- main
Schritte erklärt:¶
- Image: Wir verwenden das offizielle .NET Docker-Image für die Build- und Test-Phasen.
- Before Script: Installiert die Azure CLI, die für das Deployment notwendig ist.
- Build Stage: Baut die .NET-Anwendung.
- Test Stage: Führt Unit-Tests aus.
- Deploy Stage: Loggt sich mit dem Service Principal in Azure ein, setzt die Azure Subscription und deployt die Anwendung auf den Azure App Service.
4. Verwalten von Secrets in GitLab¶
Die sensiblen Daten wie Azure Client ID, Client Secret, Tenant ID und Subscription ID sollten nicht direkt in der .gitlab-ci.yml Datei gespeichert werden. Stattdessen speicherst du sie sicher in GitLab CI/CD Secrets (Umgebungsvariablen), die nur zur Laufzeit verfügbar sind.
Schritte, um Secrets in GitLab zu verwalten:¶
- Gehe in deinem GitLab-Projekt auf Settings → CI / CD → Variables.
- Füge neue Variablen hinzu:
AZURE_SUBSCRIPTION_ID: Deine Azure Subscription ID.AZURE_TENANT_ID: Deine Azure Tenant ID.AZURE_CLIENT_ID: Deine Azure Application (Client) ID.AZURE_CLIENT_SECRET: Dein Azure Application Secret.AZURE_APP_NAME: Dein Azure App Name.AZURE_RESOURCE_GROUP: Die Ressourcengruppe für den Azure App Service.AZURE_APP_SERVICE_NAME: Der Name des Azure App Services, auf dem die App läuft.
Die Werte für diese Variablen erhältst du aus dem Azure-Portal, wenn du den Service Principal einrichtest.
5. Sicherheit¶
Achte darauf, dass du niemals sensible Daten direkt in deinem Code oder der .gitlab-ci.yml speicherst. GitLab CI/CD Secrets sind verschlüsselt und nur zur Laufzeit zugänglich, was die Sicherheit erhöht. Zudem solltest du darauf achten, dass nur die benötigten Personen oder Gruppen Zugriff auf die Secrets und das Projekt haben.
6. Überprüfen des Deployments¶
Nachdem das Deployment abgeschlossen ist, kannst du in Azure unter deinem App Service überprüfen, ob die Anwendung erfolgreich deployed wurde. Du kannst auch Log-Daten und Fehlerprotokolle einsehen, um sicherzustellen, dass alles korrekt läuft.
Zusammenfassung¶
Mit dieser Konfiguration wird die .NET-Anwendung auf Azure for Students deployt, wobei GitLab CI/CD für die Automatisierung des Build-, Test- und Deployment-Prozesses genutzt wird. Die Nutzung von GitLab CI/CD Secrets stellt sicher, dass sensible Daten sicher verwaltet werden.