Skip to main content

Python Quick Start

This document describes how to create a Python application from scratch and deploy it to CloudBase HTTP cloud functions. The project uses Flask as the Web application framework.

Prerequisites​

Before you begin, ensure that you have:

  • Installed Python 3.10 or a later version
  • Have a Tencent Cloud account and have activated the CloudBase service
  • Have a basic knowledge of Python and Flask development

Step 1: Create the project directory​

Create a new project directory named helloworld-python and enter the directory:

mkdir helloworld-python
cd helloworld-python

Step 2: Set up the Python virtual environment​

Create and activate a virtual environment to manage project dependencies:

# Create a virtual environment
python -m venv env

# Activate the virtual environment
# Linux/macOS
source env/bin/activate

# Windows
# env\Scripts\activate

💡 Tip: Using a virtual environment can avoid dependency conflicts and ensure project isolation.

Step 3: Install Dependencies​

Install the Flask framework:

pip install flask

Step 4: Write the Application Code​

Create the app.py file as the entry file of the application:

⚠️ Important: CloudBase HTTP cloud functions must use the default port 9000.

import os
from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/')
def hello():
    """Root path handler function"""
    return 'Hello World from Python Flask!'

@app.route('/health')
def health_check():
    """Health Check Endpoint"""
    return jsonify({
        'status': 'healthy',
        'message': 'Python Flask app is running',
        'python_version': os.sys.version
    })

@app.route('/api/info')
def get_info():
    """Obtain request information"""
    return jsonify({
        'method': request.method,
        'path': request.path,
        'headers': dict(request.headers),
        'args': dict(request.args)
    })

@app.errorhandler(404)
def not_found(error):
    """404 Error Handling"""
    return jsonify({'error': 'Not Found', 'message': 'The requested resource was not found'}), 404

@app.errorhandler(500)
def internal_error(error):
    """500 Error Handling"""
    return jsonify({'error': 'Internal Server Error', 'message': 'Something went wrong'}), 500

if __name__ == '__main__':
    # Listen on port 9000 for all network interfaces
    app.run(host='0.0.0.0', port=9000, debug=False)

This code creates a basic Flask Web application that provides the following features:

  • Root path (/): Returns a welcome message
  • Health Check (/health): returns application status information
  • Info Interface (/api/info): Returns detailed request information
  • Error Handling: Unified 404 and 500 error handling

Step 5: Generate dependency file​

Generate the requirements.txt file to record project dependencies:

pip freeze > requirements.txt

View the generated dependency file:

cat requirements.txt

Typical requirements.txt contents are as follows:

blinker==1.7.0
click==8.1.7
Flask==3.0.0
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.3
Werkzeug==3.0.1

Step 6: Create the Startup Script​

💡 Note:

  • When creating the scf_bootstrap file on windows, it is recommended to use
  • When creating the scf_bootstrap file using vscode on windows, deploying to an HTTP cloud function may result in an error: scf_bootstrap file does not exist
  • This error occurs because the script file contains Windows-style carriage returns (^M), causing Linux to fail to recognize the interpreter path correctly. This is a common issue in WSL

Create the scf_bootstrap file (with no file extension), which is the startup script for CloudBase cloud functions:

#!/bin/bash
# Set the Python dependency loading path, which defaults to the third_party directory
export PYTHONPATH="./third_party:$PYTHONPATH"
/var/lang/python310/bin/python3.10 app.py

⚠️ Note:

  • The file name must be scf_bootstrap with no extension
  • The Python path needs to match the runtime version (here we use Python 3.10)
  • Ensure the file has execute permissions

Grant execute permissions to the startup script:

chmod +x scf_bootstrap

Step 7: Local Testing (Optional)​

Before deployment, you can test the application locally:

python app.py

After successful testing, you can verify in the following ways:

  • Access http://localhost:9000/ to view the welcome message
  • Access http://localhost:9000/health to view the health status
  • Access http://localhost:9000/api/info to view the request information

Press Ctrl + C to stop the local server.

Step 8: Prepare Deployment Files​

Before deployment, install dependencies to the third_party directory:

⚠️ Note:

  • HTTP cloud functions do not automatically install Python dependencies, so we need to manually download them into the code package
pip install -r requirements.txt -t third_party

Ensure your project directory contains the following files:

helloworld-python/
├── third_party/            # Python dependencies
├── app.py                  # Application main file
├── requirements.txt        # Dependencies list
└── scf_bootstrap           # Startup script

Step 9: Package the project​

Package the project files into a ZIP file:

# Ensure you are in the project root directory
zip -r helloworld-python.zip third_party app.py scf_bootstrap

💡 Packaging Tip:

  • Include the third_party directory to ensure dependencies are complete
  • Ensure the scf_bootstrap file is included
  • Avoid including unnecessary files (such as .git, __pycache__, etc.)

Step 10: Deploy to CloudBase HTTP cloud function​

Deploy via the console​

  1. Log in to TCB/cloud function
  2. Click "New Cloud Function"
  3. Select "HTTP cloud function"
  4. Enter the function name (e.g.: helloworld-python)
  5. Select runtime: Python 3.10
  6. Select the "Local upload" method
  7. Upload the helloworld-python.zip file you just created
  8. Click "OK" to complete the deployment

Deploy via CLI​

For details, see Deploy HTTP function via CLI

Step 11: Access Your Application​

After successful deployment, you can refer to Accessing Cloud Functions via HTTP to set up custom domain access to the

You can test in the following ways:

  • Access the root path to view the welcome message
  • Access the /health path to view the application status
  • Access the /api/info path to view request information

Frequently Asked Questions​

Q: Why must port 9000 be used?​

A: CloudBase HTTP cloud functions require the application to listen on port 9000, which is the standard configuration of the platform.

Q: What is the purpose of the scf_bootstrap file?​

A: scf_bootstrap is the startup script for cloud functions, used to set environment variables and start the application.

Q: How to view function logs?​

A: On the Cloud Functions page of the CloudBase console, click the function name to go to the details page, where you can view the runtime logs.

Q: Which Python versions are supported?​

A: CloudBase supports Python versions 3.6, 3.7, 3.9, and 3.10, with Python 3.10 recommended.

Q: How to handle the issue of excessively large dependency packages?​

A: You can use the (Layer) feature to manage large dependency packages, or use pip install --no-deps to only install necessary packages.

Best Practices​

  1. Dependency Management: Use requirements.txt to pin dependency versions
  2. Error Handling: Implement a unified error handling mechanism
  3. Logging: Use Python's logging module to log key information
  4. Environment Variables: Use environment variables to manage configuration information.
  5. Code Structure: For complex applications, it is recommended to use Blueprint (Blueprint) to organize code.

Next steps​