Store2008 Review - Overview of the .Net Monolithic Code
Store2018 - Refactor and Redesign
The course is part of this learning path
In this advanced course, we take a legacy monolithic .Net application and re-architect it to use a combination of cloud services to increase scalability, performance, and manageability.
This course will enable you to:
- Learn the principles and patterns associated with microservices
- Understand the principles and patterns associated with Restful APIs
- Learn important requirements to consider when migrating a monolithic application into a microservices architecture
- Master the benefits of using microservices and associated software patterns and tools to build microservice-based applications at speed and scale
- Understand tradeoffs between different architectural approaches
- Become comfortable with modern open source technologies such as Dotnet Core, Docker, Docker Compose, Linux, Terraform, Swagger, React
- Become familiar with Docker and Container orchestration runtimes to host and run containers, such as Docker Compose, Amazon ECS using Fargate, and Amazon EKS
- A basic understanding of software development
- A basic understanding of the software development life cycle
- A basic understanding of DevOps and CICD practices
- Familiarity with Dotnet and C#
- Familiarity with AWS
- Software Developers and Architects
- DevOps Practitioners interested in CI/CD implementation
- Anyone interested in understanding and adopting Microservices and Restful APIs within their own organization
- Anyone interested in modernizing an existing application
- Anyone interested in Docker, and Containers in general
- Anyone interested in container orchestration runtimes such as Kubernetes
Welcome back, in this lecture, we'll step aside from the architecture and development work and instead do some housekeeping. We now have a substantial body of source code that we should really version control. And that's what we'll focus on in this lecture. We've decided to use Bitbucket for our version control. So within the dashboard we'll create a new repository. We'll call it Store2018. And we'll keep it as a private repository and we'll definitely use Git, so clicking the Create repository button, creates our repository. So we'll copy the clone URL and then we head over to our terminal. For starters, let's do a directory listing in our solution root folder. Next we'll run the tree command to see what the directory structure looks like.
Scrolling up, we can see that there's a number of files and folders that we should not version control. For example, the dotnet framework has a bin debug folder and there's no need for us to actually version control the dlls, nor the debugging files. So again, doing a directory listing we can see that we have a gitingnore file in there already. Let's take a look at the contents of that. If we scroll to the top of that file, you can see that we've got statements in there to ignore those particular folders, which is good. Okay, let's now initialize the root folder to be version controlled. We do so by running git init. Okay, doing a directory listing again. We can see now that indeed we've initialized our solution folder for source control. We'll do a git status.
And at the moment these are all the untracked folders and files. So we'll do a git add and we'll add all of them in one go. If we do a git status again, we've successfully added everything can, but still ignoring the compiled files and the debug files as per the statements in the doc gitignore file. Next we'll run a git commit, give it a message, initial commit. We'll do a git log. You can see that our first committal ID is HEAD pointing at master as expected. Finally, we need to push this up to our Bitbucket repository so we do so by running git remote add origin and then we need the Bitbucket repository URL, so we'll go back to Bitbucket and we'll copy the URL. Back to our terminal, entering our URL, execute. And Bitbucket has now been added as a remote origin.
And then finally we need to do a git push. Enter. Okay, so all of our source code to date has now been pushed into our Bitbucket repository, so that's completed. And if we go back to Bitbucket, and we now do a refresh, indeed, you can see that all of our source control has been correctly pushed up into our repository. So that's a great outcome. It now makes our source code far more secure and manageable in the long run. Okay, that completes this lecture, go ahead and close it and we'll see you shortly in the next one.
About the Author
Jeremy is the DevOps Content Lead at Cloud Academy where he specializes in developing technical training documentation for DevOps.
He has a strong background in software engineering, and has been coding with various languages, frameworks, and systems for the past 20+ years. In recent times, Jeremy has been focused on DevOps, Cloud, Security, and Machine Learning.
Jeremy holds professional certifications for both the AWS and GCP cloud platforms.