Importing APIs Via Dev First Approach

WSO2 API Controller (apictl) allows you to create and deploy APIs without using the Publisher Portal of the WSO2 API Manager (WSO2 API-M). You can use this feature to create an API from scratch or using an existing Swagger or Open API specification and then deploy it to the desired WSO2 API-M environment.

Info

Before you begin

  • Make sure that the apictl is downloaded and initialized, if not, follow the steps in Download and Initialize the apictl.

  • Make sure you already have added an environment using the apictl for the WSO2 API-M environment you plan to import the API to.

    If not, follow the steps in Add an Environment.

Initialize an API project

  1. Open a terminal window and navigate to the path you need to create the project.

  2. You can follow either of the following ways to generate the project.

    1. From Scratch

      • Command

        apictl init <Project Path>   
        apictl init <Project Path> --definition <API definition template file>  --force=<force create project>

        Example

        apictl init SampleAPI                
        apictl init SampleAPI --definition definition.yaml --force=true                

        As an example, you can use the Sample-Api.yaml here to generate an API Project.

      • Response

        Initializing a new WSO2 API Manager project in /home/user/work/SampleAPI
        Project initialized
        Open README file to learn more

        Info

        In this case, the project artifacts are generated according to a set of predefined templates. Therefore, after initializing the project, you need to go and edit the project artifacts manually.

    2. From OpenAPI/Swagger Specification
      You can use a Swagger2 and OpenAPI3 specification to generate an API. The file format should be YAML or JSON.

      • Command

        apictl init <Project Path> --oas <Path to API specification>
        apictl init <Project Path> --oas <Path to API specification> --definition <API definition template file> --force=<force create project>

        Example

        apictl init Petstore --oas petstore.yaml
        apictl init Petstore --oas https://petstore.swagger.io/v2/swagger.json
        apictl init Petstore --oas petstore.yaml --definition definition.yaml --force=true

      • Response

        Initializing a new WSO2 API Manager project in /home/user/work/PetstoreAPI
        Project initialized
        Open README file to learn more

        Info

        When you initialize an API project using an OpenAPI specification, apictl will automatically read the OpenAPI definition and populate a certain set of configs in the API definition file, api.yaml.

        Info

        Flags:

        • Optional :
          --definition or -d : Provide a YAML definition of API
          --oas : Provide an OpenAPI specification file/URL for the API
          --force or -f : To overwrite the directory and create the project

      Note

      You can define scopes for a resource when defining a Swagger2 or OpenAPI3 specification to generate an API.

      Example

      openapi: 3.0.0
      info:
      title: Online-Store
      version: v1.0.0
      description: This API contains operations related to the online shopping store.
      x-wso2-basePath: /store/{version}
      x-wso2-production-endpoints:
      urls:
          - http://products
      paths:
      /products:
          get:
          responses:
              "200":
              description: successful operation
      /products/{productId}:
          get:
          parameters:
              - name: productId
              in: path
              required: true
              schema:
                  type: string
          security: 
              - 
              default: 
                  - "read"
          responses:
              "200":
              description: successful operation
      components: 
      securitySchemes: 
          default: 
              type: "oauth2"
              flows: 
                  implicit: 
                  authorizationUrl: "https://test.com"
                  scopes: 
                      read: ""
                  x-scopes-bindings: 
                      read: "admin"

      First you need to define the scope name ("read") under security > default section inside the required resource and then define the role binding under the securitySchemes section. You can use any preferred name as the security scheme.

      Make sure to set the security type as oauth2 when defining the scopes. Also when defining the roles under a particular scope, put them under x-scopes-bindings: as a scope name and roles mapping.

      Note

      You can define WSO2 API-M supported open API extensions for an API when defining a Swagger2 or OpenAPI3 specification to generate an API. These extensions can be used to define endpoint configurations, runtime configurations, resource level throttling, and API level throttling, transport-level security, CORS configurations and response cache configurations. The list of APIM supported OpenAPI extensions is as follows.

      Extension

      Description

      API Level/ Resource Level

      x-wso2-basePath

      The base path which gateway exposes the API

      API level 

      x-wso2-production-endpoints

      Specify the actual back end of the service

      API level

      x-wso2-sandbox-endpoints

      Specify the sandbox endpoint of the service if available

      API level

      x-wso2-throttling-tier

      Specify the rate-limiting for the API or resource

      API level/ Resource level

      x-wso2-cors

      Specify CORS configuration for the API

      API level 

      x-wso2-disable-security

      When the value of this extension specified as true, the resources can be invoked without any authentication

      API level/ Resource level

      x-wso2-response-cache

      Enable response caching when creating a new API with cache timeout

      API level

      x-wso2-mutual-ssl

      Enable mutual SSL for API (With optional and mandatory keywords as values)

      API level

      x-wso2-auth-header

      Specify the authorization header for the API in which either bearer or basic token is sent

      API level 

      x-wso2-transports

      Specify the transport security for the API (HTTP, HTTPS, and Mutual SSL)

      API level 

      x-wso2-application-security

      Specify application security (basic_auth, api_key, oauth2)

      API level/ Resource level

      Let's see how these OpenAPI extensions are used in Open API definition.

    A project folder with the following default structure will be created in the given directory.

    ├── api.yaml
    ├── api_meta.yaml
    ├── deployment_environments.yaml
    ├── Client-certificates
    ├── Definitions
    │   └── swagger.yaml
    ├── Docs
    ├── Endpoint-certificates
    ├── Image
    └── Sequences
        ├── fault-sequence
        ├── in-sequence
        └── out-sequence

    Sub Directory/File Description
    api.yaml The specification of the created API.
    api_meta.yaml The meta-information file of the source artifact (This includes the name and the version of the API).
    deployment_environments.yaml Specify the gateway environments to which the API should be deployed.
    swagger.yaml The Swagger file that is generated when the API is created.
    Sequences
        ├── fault-sequence
        ├── in-sequence
        └── out-sequence
    To add custom sequences, save them in XML format and add them to the corresponding folder. For example, to add a custom in-sequence, save the custom sequence as SampleSequence.xml and add it to the Sequences/in-sequence/Customdirectory.
    Client-certificates Contains the client certificates for Mutual SSL enabled APIs.
    Docs Contains the documents.
    Endpoint-certificates Contains the endpoint certificates for endpoint security enabled APIs.
    Image Contains the thumbnail image of the API.

    Note

    Overriding an API with organization-specific details and further finetuning

    When you create an API Project, APIs are generated using a default template. To further finetune the process of creating the API and to include organization-specific common API related details, you can use a custom API Definition file. For more information, see Initialize an API project.

    Generate APIs with Dynamic Data

    When initializing an API Project, apictl is capable of detecting environment variables in the default definition file or in the provided custom definition file. For more information on using dynamic data, see Initialize API Projects with Dynamic Data.

  3. Open the <API Project>/api.yaml file. You can edit the mandatory configurations in the field named data as listed below.

    Field Description
    name The name of API without spaces.
    context Context of the API in WSO2 API-M with a leading slash.
    production_endpoints Production endpoints for API.
    sandbox_endpoints Sandbox endpoint for API.

    For more information about the configurations, see the Sample-Api.yaml.

    api.yaml

        type: api
        version: v4.0.0
        data:
            name : SampleAPI
            version: 1.0.0
            context: /sampleapi
            endpointConfig:
                endpoint_type: http
                production_endpoints:
                    url: http://prod.wso2.com
                sandbox_endpoints:
                    url: http://sand.wso2.com
            endpointImplementationType: ENDPOINT
            lifeCycleStatus: CREATED
            policies:
            - Unlimited
            provider: admin
            transport:
            - http
            - https
            type: HTTP
            visibility: PUBLIC

Import an API project

Info

Before you begin...

  • Make sure you have already created an environment to which you are planning to import the API. If not, follow steps in Add an Environment.

  • Make sure you have logged-in to the importing environment. If not, follow steps in Login to an Environment.

Tip

A user with Internal/devops role or admin role are allowed to import APIs. To create a custom user who can import APIs, refer Steps to Create a Custom User who can Perform API Controller Operations.

After editing the mandatory fields in the API Project, you can import the API to an environment using any of the following commands.

  • Command

    apictl import api -f <path to API Project> -e <environment> 
    apictl import api --file <path to API Project> --environment <environment> --rotate-revision
    apictl import api --file <path to API Project> --environment <environment> --params=<environment params file> 

    Info

    Flags:

    • Required :
      --file or -f : The file path of the API project to import.
      --environment or -e : Environment to which the API should be imported.
    • Optional :
      --rotate-revision : If the maximum revision limit reached, delete the oldest revision and create a new revision.
      --skip-deployments : Skip the deployment environments specified in the project and only update the working copy of the API.
      --preserve-provider : Preserve the existing provider of API after importing. The default value is true.
      --update : Update an existing API or create a new API in the importing environment.
      --params : Provide a API Manager environment params file. For more information, see Configuring Environment Specific Parameters.
      --skip-cleanup : Leave all temporary files created in apictl during import process. The default value is false.

    Example

    apictl import api -f ~/myapi -e production 
    apictl import api --file ~/myapi --environment production --rotate-revision
    apictl import api --file ~/myapi --environment production --params prod/params.yaml  

    Tip

    When using the --update flag with the import api command, apictl will check if the given API exists in the targeted environment. If the API exists, it will update the existing API. If not, it will create a new API in the imported environment.

    Note

    Changes to the import command with the revision support for APIs

    • From WSO2 API-M 4.0.0 onwards, you have to create a new revision in order to deploy an API in an gateway environment and only a revision can be deployed in a gateway environment.
    • With the import command of the apictl, if the API project has specified the deployment environments, import will first update the working copy of the API.
    • If the number of revisions created for that API does not exceed the max revision limit of 5, a new revision of that API will be created and that revision will be deployed in the specified gateway environments.
    • If the max revision numbers is reached, imported API will only update the working copy and not be deployed in the specified gateway environments.
    • You can use --rotate-revision flag with the import command and if the max revision limit reached, import operation will delete the earliest revision for that API and create a new revision. This new revision will be deployed in the specified gateway environments.

    Note

    apictl import-api command has been deprecated from apictl 4.0.0 onwards. Instead use apictl import api as shown above.

  • Response

    Successfully imported API!

Top