Download link : Based on SpringCloud+Kubernetes, the actual combat of containerized continuous delivery of microservices
Chapter 1 Course Guidance
This chapter mainly introduces why we should take you to learn the containerized continuous delivery practical course of microservices. After that, we will introduce the specific arrangements of this course and finally give some learning suggestions on how to learn this course. I hope everyone can pass this course and learn something.
1-1 Must read before class (If you don’t read it, you will miss one hundred million)
1-2 Course introduction and learning guidance Try
Chapter 2 Continuous Delivery Methods
This chapter will introduce the definition of continuous delivery and the continuous delivery pipeline methods and models in Internet companies. The following practical courses establish a theoretical foundation.
2-1 How
Internet Companies Carry
Out Continuous Integration [Theoretical Support] Take a look at 2-2 How Internet Companies Carry Out Continuous Deployment [Theoretical Support] Chapter 3 Starting from Requirements
This chapter takes you from the perspective of the project manager to see how requirements are managed, how requirements and codes are Traceability, how to integrate development tools and Jira demand management tools to establish best practices for demand management and code submission.
3-1 Use Jira to create Sprints, user stories and tasks
3-2 Assign and schedule tasks in Jira Kanban
3-3 Install Jira plug-ins in Idea and automatically create branches locally
3-4 Gitflow VS Trunk base branch model More suitable for your team
. Chapter 4 Developing Spring Cloud Applications: Notebook
This chapter is the core chapter of the course. It will reflect the difference between microservices and traditional Spring MVC applications by compiling a Notebook application based on Spring Cloud 2.1.4, including Spring Cloud registration. A series of components such as the center Eureka, load balancing Zuul, and service management Zipkin.
4-1 Develop a Spring Boot application: Notebook-1.0.jar
4-2 Create a Spring Cloud service registry
4-3 Add a gateway to the front end of the Notebook application
4-4 Service link tracking Zipkin
Chapter 5 Microservice application packaging
This chapter will show you how to use Maven to package multi-module applications, and Publish artifacts to the open source artifact library Artifactory.
5-1 Apache Maven Core Demo
5-2 Building Maven Private Server
5-3 Downloading Products from Maven Private Server
Chapter 6 Jenkins:
Building Pipeline for NoteBook This chapter is based on Jenkins core through Jenkins pipeline, integrated application unit test JUnit, static code inspection Sonarqube , Interface automation testing YAPI, UI automation testing Selenium, connect various testing tools in series in the continuous integration pipeline to improve the quality of software delivery.
6-1 Jenkins core
6-2 Jenkins continuous integration pipeline
6-3 Jenkins integrated Artifactory
6-4 Jenkins integrated Jira
6-5 Jenkins integrated Sonarqube code scanning
6-6 Jenkins integrated YAPI
6-7 Selenium integration
Chapter 7 is written for the application Dimensional Test Cases
This chapter will introduce how to write unit test cases for the application, how to perform static code checks, write interface automation test cases, write UI automation test cases, and perform comprehensive tests on the application.
7-1 Add unit test for Notebook application
7-2 Use Sonarcube to check whether the Notebook code is standard
7-3 Use YAPI to add Notebook interface test cases to the application
7-4 Use Selenium to perform Notebook UI automation testing
Chapter 8 Use Ansible Playbook to deploy microservices
This chapter will take you to complete the installation of Ansible And configuration, write the first Ansible script, take everyone to understand the best practices of Ansible Playbook, and write Ansible Playbook for Notebook microservices, and finally integrate Notebook Playbook in the pipeline.
8-1 Ansible Core
8-2 Ansible Installation Configuration
8-3 Writing the First Ansible Command
8-4 Ansible Playbook Introduction
8-5 Reusable Playbook
8-6 Writing Playbook for Notebook
8-7 Integration of Ansible Playbook in the Pipeline Deploy
8-8 Ansible Playbook Best Practices
Chapter 9 In-depth understanding of Docker principles, actual containerized release of Notebook applications.
This chapter is the core chapter of the course. It will elaborate on the underlying implementation principles of Docker and help you understand Docker's processes, resources, and files. The implementation principle of the system, and will build a free Docker mirror warehouse, realize a Docker mirror of the Notebook application, and publish the mirror to the Docker mirror warehouse.
9-1 Why are Internet companies using Docker instead of virtual machines?
9-2 How does Docker achieve resource isolation
9-3 How Docker achieves process space isolation
9-4 How Docker achieves storage isolation
9-5 Common commands for Docker images
9-6 Build a free version of the Docker mirror warehouse
9-7 Start writing notebook Dockerfile
9-8 Dockerfile Best Practice
9-9 Build a Docker image of a microservice and upload the image
9-10 Use Docker to run multiple
microservices
Chapter 10 Deploying Notebook Docker images to Kubernetes This chapter is the core chapter of the course, which will elaborate on the core concepts of Kubernetes. Including Pod, Deployment, Service, PV, secret key, configmap, probe, Helm Chart packaging, etc., and contains the best practices used, and finally will create a Helm Chart for notebook deployment.
10-1 minikube
10-2 namespace
10-3 Kubernetes pod
10-4 Kubernetes service
10-5 Kubernete storage
10-6 Kubernete deployment
10-7 The role of Kubernetes probes
10-8 Kubernetes configmap
10-9 Multiple Kubernetes deployment notebooks micro services
10-10 Kubernetes logging system
10-11 Kubernetes secret key management
10-12 Getting started with helm
10-13 Creating helmchart for the notebook service
10-14 Using helm for application upgrade and rollback
Chapter 11 Microservice containerized continuous delivery practice
This chapter will associate the previous code with requirements through practical operations. Automated testing, continuous integration pipeline, upgrade of container image, Helm Chart one-click deployment in the Kubernetes environment. Deeply understand the charm of continuous delivery through practice.
11-1 Write new notebook application functions to associate Jira requirements and run in the local test environment
11-2 Scan the packaged code in the Jenkins pipeline to build the image
11-3 Upload the image to JCR in Jenkins and deploy it to the test environment space of Kubernetes
11 -4 Jenkins trigger interface automation test
11-5
Upgrade the Docker image to the Prod warehouse in Jenkins 11-6 Deploy the image to the Kubernetes production environment space in Jenkins
This course has been completed