Bespoke .NET core: Architecture/DevOps

This course teaches how to achieve DevOps for modern app development with .NET Core. We start with a general description of DevOps, and key components of the modern app development, including Git source control, inner and outer loops, containers, Kubernetes, and so on. Then, we discuss how to achieve DevOps through continuous integration, delivery, microservices, and containers. Subsequently, we learn what changes are necessary to achieve DevOps, and how Git workflow helps to manage your master, develop, feature and bugfix branches. Subsequently, we move to containers. We learn basic terms and how to build the Docker image from the .NET Core source.

Then, we learn about microservices. Specifically, we discuss what are typical problems, and solutions. We will learn here how to design microservice architecture with .NET Core. Finally, we move to deployment using TeamCity, Octopus, Azure DevOps, and Azure Kubernetes Service. You will learn a plethora of tools, enabling you to choose the right one for your needs.

1. Introduction to DevOps:

   • A big picture of modern app development,

   • The inner and outer loop,

   • Source code control,

   • Build and release pipelines,

   • Container image and container registry,

   • Helm charts,

   • Terraform,

   • Kubernetes production cluster,

   • Policies,

   • Monitoring and logging,

   • Observe, Orient, Decide and Act (OODA approach).

2. How to Achieve DevOps:

   • Continuous Integration,

   • Continuous Delivery,

   • Version Control,

   • Agile planning,

   • Public and hybrid clouds,

   • Infrastructure as a Code,

   • Microservices,

   • Containers.

3. DevOps changes:

   • Instrumental changes,

   • Vertical teams,

   • Bug cap.

4. DevOps and GitFlow:

   • Introduction to DevOps,

   • Master, develop, release, feature, and bugfix/hotfix branches,

   • Branch merging,

   • Pull requests.

5. Containers:

   • What is containerization

   • Virtual machines, containers, and serverless,

   • Containers in Docker,

   • Docker terminology,

   • Microsoft platform and tools for containerized apps,

   • Common container design principles,

6. Container support in .NET Core.

7. Microservices architecture:

   • Monolithic approach,

   • Service-oriented architecture,

   • Microservices,

   • Scaling in monolithic and microservices architectures,

   • Benefits of microservices,

8. Challenges of microservices:

   • State and data,

   • Data sovereignty per microservice,

   • Boundaries,

   • Consistency,

   • Communication,

   • Deployment.

9. Implementing microservices with .NET Core Web API

   • API Gateway,

   • Communication between microservices,

   • Azure Service Bus,

   • Security.

10. Deployment:

    • Setup build pipeline with TeamCity,

    • Setup a continuous delivery pipeline with Octopus,

    • Setup a build and delivery pipeline with Azure DevOps,

    • Container deployment,

11. Deploying to Azure Kubernetes Service

    • Kubernetes architecture and glossary,

    • Kubernetes support in .NET Core,

    • Building the Kubernetes cluster,

• • Pushing a container to Docker registry,

  • Pull Docker image from the Docker registry to Kubernetes cluster,

  • Horizontal pod autoscaling

12. Summary and conclusions