Apache APISIX Website Documentation

repository·master·Indexed 40 days ago

https://github.com/apache/apisix-website

Development and build documentation for the Apache APISIX website, including the Docusaurus-based site and the high-performance Astro prototype. Includes guides for local development, content synchronization, and a lab environment for testing AI gateway capabilities using Apache APISIX 3.18.0 and Redis Open Source 8.10.1.

Tokens
294.3K
Snippets
567
Records
1.3K
Agent score
47%

What's inside Apache APISIX Website

  1. Overview of API7 Cloud for multi-cloud environments

    master

    API7 Cloud is a solution built on Apache APISIX designed to simplify API management in multi-cloud and hybrid-cloud scenarios.

    Key Features:

    • Control Plane/Data Plane Separation: API7 Cloud hosts the control plane, while the APISIX data plane can be deployed on any infrastructure (on-premises, cloud, etc.).
    • Enterprise Customizations: Includes enhanced dynamic capabilities and support for dynamic service discovery.
    • Automation: Provides an open API and an SDK to enable automated API management and program integration.
    • Observability: Includes built-in observability to monitor API usage and performance.
  2. Overview of Apache APISIX Use Cases

    master

    Apache APISIX is designed as a unified proxy infrastructure that can be deployed across several different architectural patterns:

    • Load Balancer & API Gateway: High-performance proxying with dynamic SSL certificate loading and SSL handshake optimization.
    • Microservice Gateway: Replaces traditional microservice gateways (like Zuul or Spring Cloud Gateway) by supporting service discovery (Nacos, etcd, Eureka, DNS) and multi-language plugins for east-west traffic.
    • Kubernetes Ingress: A dynamic, hot-reloading Ingress controller for K8s clusters.
    • Service Mesh: Supports the xDS protocol, allowing APISIX to function within a service mesh architecture (APISIX Mesh).
  3. Overview of APISIX AI Gateway capabilities

    master

    The APISIX AI Gateway (introduced in Apache APISIX 3.12.0) provides a specialized set of capabilities for managing AI-driven applications. It acts as a proxy layer between clients and AI services (such as OpenAI and DeepSeek), offering the following core functions:

    • Proxy and Request Management: Handles the routing and lifecycle of AI service requests.
    • Traffic Control: Implements load balancing and rate limiting to optimize performance and manage costs.
    • Prompt Processing: Allows for the manipulation and management of prompts before they reach the AI model.
    • Content Moderation: Provides security through content filtering and moderation mechanisms.
    • Data Enhancement: Enables augmenting data within the request flow.
    • Observability: Offers real-time monitoring of key metrics to track costs, identify performance issues, and ensure transparency.
  4. Compare Cloud-Managed, Open-Source, and Commercial API Gateways

    master

    When selecting an API gateway, evaluate three primary operating and support models. Note that these categories often overlap (e.g., a vendor may offer a managed service built on open-source software).

    1. Cloud-Managed API Gateways

    Best for teams wanting to reduce infrastructure management and those already heavily integrated into a specific cloud provider.

    • Benefits: Provider-managed availability, upgrades, and capacity; integrated identity, monitoring, and networking; usage-based billing.
    • Evaluation Criteria: Check if the control/data planes are portable across environments, evaluate the cost of data transfer/logging at scale, and verify available extension points for custom policies.

    2. Open-Source API Gateways

    Best for teams requiring visibility into implementation, deployment flexibility, and the ability to extend the software.

    • Benefits: Access to source code; ability to self-host on VMs, containers, Kubernetes, or on-premises; community-driven integrations.
    • Operational Responsibilities: You are responsible for scaling the data plane, applying security updates, protecting configuration stores, and managing backups/monitoring.

    3. Commercial API Gateways

    Best for organizations requiring vendor support, contractual service commitments, and packaged governance/analytics tools.

    • Benefits: Contractual support; packaged administration and developer portals; tested enterprise-grade integrations.
    • Evaluation Criteria: Check pricing models (per request, per instance, etc.), feature availability in different editions, and whether the data plane remains operational if the hosted control plane is lost.
  5. Future Roadmap for Apache APISIX Ingress

    master

    The development roadmap for Apache APISIX Ingress includes:

    • Kubernetes Gateway API Support: Implementing the standard to allow unified configuration across different Ingress implementations.
    • Monolithic Architecture Support: Moving toward a deployment model where Apache APISIX can be deployed separately from etcd. This aims to improve scalability in containerized cloud-native scenarios by allowing the Ingress Controller to listen to declarative configurations and synchronize them to a decoupled Apache APISIX instance.
  6. How Apache APISIX supports microservices

    master

    Apache APISIX is optimized for microservices through the following architectural capabilities:

    • Dynamic Configuration: Uses etcd as a configuration store, allowing routes, upstreams, and plugins to be modified via the Admin API in real-time without restarting nodes.
    • Plugin Pipeline Architecture: Executes a configurable sequence of plugins (e.g., authentication, rate limiting, transformation) per request. Plugins can be applied globally, per-service, or per-route.
    • Kubernetes-native Operation: The APISIX Ingress Controller supports both the legacy Ingress resource and the modern Gateway API specification.
    • Observability Integration: Built-in plugins export metrics to Prometheus and traces to Jaeger, Zipkin, and OpenTelemetry, providing a complete instrumentation point for external traffic.
  7. Compare Apache APISIX and NGINX

    master

    Apache APISIX is built on top of NGINX and LuaJIT (via OpenResty), inheriting NGINX's high-performance data plane while adding a complete API gateway control plane.

    Key differences include:

    • Configuration: APISIX uses etcd for dynamic, real-time configuration changes without requiring process reloads. NGINX (OSS) relies on static nginx.conf files that require reloads.
    • Management: APISIX provides a full REST Admin API, a Dashboard, and a rich plugin ecosystem (100+ plugins). NGINX requires manual configuration or custom Lua/njs scripting for gateway features.
    • Capabilities: APISIX includes built-in support for advanced service discovery (Nacos, Consul, Eureka, Kubernetes), AI gateway features (via ai-proxy plugin), and comprehensive authentication (OIDC, LDAP, mTLS) out of the box.
    • Licensing: APISIX is Apache 2.0 licensed (free), whereas NGINX Plus is a commercial subscription that provides similar dynamic features.
  8. Case Study: Gateway Performance Optimization at Zhengcaiyun

    master

    Zhengcaiyun utilized Apache APISIX as a central gateway within their "Highway" project to manage a hybrid cloud network (public, private, and government clouds). APISIX serves as the central hub for network routing in a star-shaped architecture, replacing a complex mesh structure to simplify cross-network communication between different administrative divisions (islands).

    Key architectural roles:

    • APISIX: Acts as the central gateway for network routing and common feature support.
    • Dubbo Gateway: Integrated with APISIX to support specific protocol requirements for cross-network RPC requests.
    • Star-shaped Architecture: Simplifies connectivity by routing traffic through central gateways rather than maintaining $n^2$ pairwise connections between nodes.
  9. Recap of securing APISIX Dashboard with Keycloak

    master

    This guide outlines a multi-step architecture for securing the APISIX Dashboard using Keycloak authentication. The workflow involves:

    1. PKI Setup: Creating a Certification Authority (CA) and issuing certificates for various sites.
    2. Reverse Proxy: Setting up an nginx-mainline server to act as a reverse proxy and load balancer.
    3. Identity Provider: Deploying a Keycloak server behind the Nginx reverse proxy.
    4. APISIX Deployment: Deploying APISIX in a Kubernetes cluster using an Ingress Controller and the apisix-dashboard.
    5. Authentication Integration: Configuring Keycloak to handle authentication for the dashboard.
    6. Load Balancing: Setting up an Nginx load balancer for the apisix-dashboard within Kubernetes.
    7. Plugin Configuration: Configuring APISIX resources, specifically using the openid-connect plugin, to enforce authentication via the Keycloak server.

    Warning: This specific setup is intended for educational purposes only and should not be used in production environments.

  10. Recent Apache APISIX Feature Highlights

    master

    The following features and plugin updates have been recently introduced to Apache APISIX:

    • proxy-rewrite plugin: Added the use_real_request_uri_unsafe option.
    • prometheus plugin: Added ngx.shared.DICT status reporting.
    • Plugin Execution: Added support for dynamic control over whether plugins are running.
    • jwt-auth plugin: Added support for setting clock skew for verification.
    • Control API: Added plugin_metadata into the control API.
    • clickhouse-logger plugin: Added support for multiple ClickHouse endpoints.
  11. Case Study: iQIYI's Migration from Kong to Apache APISIX

    master

    iQIYI migrated its gateway infrastructure from Kong to Apache APISIX to address performance bottlenecks, high CPU idle alerts, and complex system dependencies. Key benefits realized include:

    • Performance: Apache APISIX demonstrated significantly lower response latency (over 50% lower than other gateways) and maintained stability even when CPU usage exceeded 70%.
    • Architecture: Transitioned from a PostgreSQL-based storage model (Kong) to a cloud-native architecture suitable for large-scale microservices.
    • Operational Efficiency: Reduced development and maintenance costs through a more adaptable and easily deployable system.

    This case study highlights how Apache APISIX can handle massive traffic (millions of QPS) and tens of thousands of API routes.