Linux Postman如何集成到CI/CD流程中

Integrating Postman with CI/CD in Linux: A Step-by-Step Guide
Integrating Postman into your Linux-based CI/CD pipeline enables automated API testing, ensuring code changes don’t break existing functionality. Below is a structured approach to achieve this integration, covering prerequisites, tool setup, and execution.

1. Prerequisites

Before starting, ensure the following tools are available in your Linux environment:

• Node.js & npm: Required to install Newman (Postman’s CLI). Install via curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash - followed by sudo apt-get install -y nodejs.
• Git: For version control (install via sudo apt-get install git).
• CI/CD Tool: Popular options include Jenkins, GitHub Actions, Travis CI, or GitLab CI/CD.
• Postman Account: To export collections and environments (sign up at Postman).

2. Prepare Postman Assets

Organize your API tests in Postman before integrating with CI/CD:

• Create Collections: Group related API requests (e.g., “User Management”) to modularize tests.
• Add Tests: Use the Tests tab in each request to write validation scripts (e.g., check status codes, response bodies). Example:

  pm.test("Status code is 200", function () {
      pm.response.to.have.status(200);
  });
  pm.test("Response contains user data", function () {
      const jsonData = pm.response.json();
      pm.expect(jsonData).to.have.property("id");
  });
  

• Export Collections: Go to the collection, click Export, select Collection Format v2.1 (recommended for Newman), and save as a .json file (e.g., user_management_collection.json).
• Manage Environments: Create environment variables (e.g., base_url, api_key) to parameterize requests. Export environments as .json files (e.g., dev_environment.json).

3. Install Newman on the CI Server

Newman is the CLI tool that runs Postman collections in the CI/CD pipeline. Install it globally using npm:

sudo npm install -g newman

Verify installation with newman --version (should return the installed version).

4. Configure the CI/CD Tool

Choose a CI/CD tool and set up a pipeline to automate Postman test execution. Below are examples for common tools:

A. Jenkins Integration

1. Install Plugins: In Jenkins, go to Manage Jenkins > Manage Plugins and install:
   • Pipeline: For defining pipeline workflows.
   • HTML Publisher (optional): To visualize test reports.
2. Create a Pipeline Job:
   • Go to New Item, select Pipeline, and name it (e.g., “Postman Tests”).
   • Under Pipeline, choose Pipeline script from SCM and set:
     • SCM: Git
     • Repository URL: Your Git repository URL (e.g., https://github.com/your-repo/api-tests.git).
     • Script Path: Path to your Jenkinsfile (e.g., Jenkinsfile).
3. Write a Jenkinsfile: Create a Jenkinsfile in your repository with the following content:

   pipeline {
       agent any
       stages {
           stage('Checkout') {
               steps {
                   git branch: 'main', url: 'https://github.com/your-repo/api-tests.git'
               }
           }
           stage('Install Newman') {
               steps {
                   sh 'npm install -g newman'
               }
           }
           stage('Run Postman Tests') {
               steps {
                   sh 'newman run user_management_collection.json --reporters cli,junit --reporter-junit-export reports/postman-results.xml'
               }
           }
           stage('Publish Results') {
               steps {
                   junit 'reports/postman-results.xml'
               }
           }
       }
   }
   

   This pipeline:
   • Checks out code from Git.
   • Installs Newman.
   • Runs the Postman collection and exports results in JUnit format.
   • Publishes results to Jenkins for visualization.

B. GitHub Actions Integration

1. Create a Workflow File: In your repository, create a .github/workflows/postman.yml file with the following content:

   name: Run Postman Tests
   on:
     push:
       branches: [ main ]
     pull_request:
       branches: [ main ]
   jobs:
     run-postman-tests:
       runs-on: ubuntu-latest
       steps:
         - name: Checkout Code
           uses: actions/checkout@v3
         - name: Set up Node.js
           uses: actions/setup-node@v3
           with:
             node-version: '18'
         - name: Install Newman
           run: npm install -g newman
         - name: Run Postman Tests
           run: newman run user_management_collection.json --reporters cli,junit --reporter-junit-export reports/postman-results.xml
         - name: Upload Test Results
           uses: actions/upload-artifact@v3
           with:
             name: postman-test-results
             path: reports/postman-results.xml
   

   This workflow:
   • Triggers on code pushes or pull requests to the main branch.
   • Sets up Node.js and installs Newman.
   • Runs the Postman collection and uploads results as an artifact.

5. Handle Sensitive Data

Avoid hardcoding sensitive information (e.g., API keys, database credentials) in your collections. Use environment variables in Postman and pass them to Newman via the CI/CD pipeline:

• In Postman, create a collection-level environment (e.g., dev_environment.json) with variables like {{base_url}} and {{api_key}}.
• In your CI/CD pipeline, pass these variables when running Newman. For example, in Jenkins:

  newman run user_management_collection.json --env-var "base_url=https://api.example.com" --env-var "api_key=your_api_key" --reporters cli,junit --reporter-junit-export reports/postman-results.xml
  

  Or in GitHub Actions:

  - name: Run Postman Tests
    env:
      BASE_URL: ${{ secrets.BASE_URL }}
      API_KEY: ${{ secrets.API_KEY }}
    run: |
      newman run user_management_collection.json \
        --env-var "base_url=$BASE_URL" \
        --env-var "api_key=$API_KEY" \
        --reporters cli,junit --reporter-junit-export reports/postman-results.xml
  

  Store secrets in your CI/CD tool’s secret manager (e.g., Jenkins Credentials, GitHub Secrets).

6. Parse and Visualize Results

Use CI/CD plugins to parse Newman’s output and display test results:

• Jenkins: The JUnit Plugin (pre-installed) can parse JUnit-formatted reports (generated by Newman with --reporter-junit-export). Add a Publish JUnit Test Result Report post-build action in your pipeline to visualize results.
• GitHub Actions: The actions/upload-artifact step uploads test results as an artifact, which can be downloaded from the workflow run page. For advanced reporting, use the JUnit Reporter with tools like Allure.

7. Automate and Scale

• Trigger on Code Changes: Configure your CI/CD tool to run Postman tests on every push, pull request, or merge to ensure real-time feedback.
• Multi-Environment Testing: Use different Postman environments (e.g., dev, staging, prod) to test against various API configurations. Pass the environment file dynamically in your pipeline (e.g., --environment dev_environment.json).
• Notify on Failures: Integrate with notification tools (e.g., Slack, Email) to alert teams when tests fail. For example, in Jenkins, use the Email Extension Plugin to send emails on build failure.

By following these steps, you can seamlessly integrate Postman into your Linux-based CI/CD pipeline, enabling automated API testing and improving software quality.