TechScrum DevOps 项目实训营

Project Familiarization

1. Download and install the required project dependencies.
2. Understand the project's directory structure and primary functionalities.
3. Review project documentation and comments.

Technical Stack & Environment

1. Identify the tech stack: Typescript, Node.js, etc.
2. Set up the development environment: Node.js, npm/yarn.
3. Identify required environment variables and their purposes.

Local Execution

1. Run the project's installation and start commands.
2. Test the main functionalities of the project to ensure it operates correctly locally.

Cloud Infrastructure Setup

1. Select the appropriate cloud platform based on project needs.
2. Manually set up the necessary cloud services for frontend, such as storage and CDN services.
3. Configure related networking and security settings.

Frontend IaC

1. Choose and familiarize with an IaC tool.
2. Write simple IaC scripts for frontend deployment.

Backend Cloud Components

1. Choose cloud servers or container services based on backend requirements.
2. Manually deploy backend code, set up database connections, etc.
3. Test backend functionalities and performance.

Backend IaC

1. Use the chosen IaC tool to script backend deployment.

IaC Enhancement for Frontend & Backend

1. Optimize existing IaC scripts for frontend and backend.
2. Add or modify resources based on project requirements.

Monitoring

1. Select appropriate monitoring tools.
2. Implement health checks for the frontend.
3. Set up and configure cloud-based monitoring tools to monitor frontend CDN's performance and availability.

Shared Resources

1. Create a GitHub organization and invite team members.
2. Choose a cloud platform and set up a shared account.

IaC & CI/CD for Frontend/Backend

1. Deploy frontend and backend applications in the shared account.
2. Optimize IaC scripts based on the characteristics of the shared account.
3. Establish Continuous Integration/Continuous Deployment pipelines.

Extended Monitoring

1. Expand monitoring capabilities for frontend and backend, including application performance and error rates.
2. Set up alerts to ensure prompt issue responses.

Manual Setup of Monitoring Tools

1. Choose monitoring tools like Prometheus, and Grafana based on project needs.
2. Manually deploy these monitoring tools on the cloud platform.

IaC for ELK

1. Familiarize with ELK's deployment and management.
2. Use an IaC tool to script ELK deployment.

Infrastructure Enhancement

1. Optimize networking, storage, and compute resources based on the expansion needs of the project.

IaC for Monitoring Tools

1. Script the deployment of Prometheus, and Grafana using IaC.
2. Automate the deployment of these tools on the cloud platform.

Integration & Pipeline Setup

1. Ensure monitoring tools can correctly monitor frontend and backend applications.
2. Configure integrations between monitoring tools and other services, such as alerts and log management(ELK/Opensearch).

Failover Strategies

1. Learn and determine the appropriate failover strategies for the project.
2. Configure and test auto-recovery functionalities.
3. Optimize the application to handle various failure scenarios.

Challenge:

API Gateway + Lambda:

1. Implement using Terraform, possibly in combination with SAM (Serverless Application Model).
2. Prioritize using Lambdas written by developers.
3. If the developer hasn't finished the Lambda function, the DevOps team can write a backup Lambda (for example, for handling tfstate files or frontend). This can be invoked using API Gateway, EventBridge, or S3.

EKS (Elastic Kubernetes Service) + AKS (Azure Kubernetes Service):

1. Implement one of the platforms.
2. Use Terraform to set up the cluster, worker nodes, and other foundational infrastructure.
3. Deploy applications via a pipeline, with the pipeline located in the code repository.

Code Testing:

1. Set up a SonarQube server and integrate it into the Jenkins pipeline. Email the test results to developers.
2. Incorporate Snyk into the pipeline and email the test reports to developers.
3. Scan once a week to compare code improvements.
4. Implement unit tests for critical parts of the application and ensure they run as part of the CI/CD pipeline.

Load Testing:

1. Use tools like JMeter or Locust to simulate heavy traffic to your infrastructure.
2. Analyze the system's response and identify bottlenecks.
3. Optimize the infrastructure based on the findings and retest.

Security:

1. Integrate with some cloud platform security tools, like AWS securityhub….
2. Integrate automated security scans in the CI/CD pipeline.
3. Ensure all services are running with least privilege access.

Failover Trigger:

1. Design mechanisms to detect system failures, such as health checks or monitoring alarms.
2. Implement automated or semi-automated processes to redirect traffic to the failover infrastructure in case of system failure.

Vault:

1. Set up a Vault server.
2. Store credentials in Vault and modify or create new pipelines accordingly.

GitHub Actions/Bitbucket Pipelines:

1. Re-implement Jenkins code pipelines using either GitHub Actions or Bitbucket Pipelines, depending on the type of the project's code repository.