Designing APIs

Procedure

1. In your web browser, open the OpenShift console and log in with your credentials (for example, username developer and password developer).
2. Select the project that includes the API Designer operator.

3. Select Topology and verify that you see an icon that is labeled fuse-apicurito.

   If there are icons for apicurito-service-ui and apicurito-service-generator then your OpenShift administrator already added the API Designer as a service to the project and you can skip the rest of these steps.

   If there are no icons for apicurito-service-ui and apicurito-service-generator, continue to the next step.

4. In the left navigation pane, click Add+.
5. Under the Developer Catalog section, click Operator Backed.
6. In the search field, type Apicurito to filter the catalog items.
7. Click the Apicurito provided by Red Hat card.

8. Click Create.

   A default form with a minimal starting template for the API Designer instance opens. Accept the default values or, optionally, edit them.

9. Click Create to trigger the start up of the pods, services, and other components of the new API Designer instance.
10. To verify that the API Designer service is added to the project, select Topology and then confirm that you see icons for apicurito-service-ui and apicurito-service-generator.
11. To open the API designer, click the URL link on the apicurito-service-ui icon.

1. In a command window, log in to the OpenShift server:

   oc login -u developer -p developer

2. Create a new project namespace. For example, the following command creates a new project named myproject:

   oc new-project myproject

3. Create a new application based on the API Designer template by running the following command (where myproject is the name of your project):

   oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-7_10_0-00015-redhat-00001/fuse-apicurito.yml -p ROUTE_HOSTNAME=myhost

   Note: Optionally, you can specify other template parameters by appending additional -p options to the oc new-app command. For example, if you installed the Fuse on OpenShift images and templates in a namespace other than the default openshift namespace, you can set the IMAGE_STREAM_NAMESPACE to specify the namespace in which the Fuse image streams are installed:

   oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-7_10_0-00015-redhat-00001/fuse-apicurito.yml -p ROUTE_HOSTNAME=myhost -p IMAGE_STREAM_NAMESPACE=othernamespace

4. Obtain the status and the URL of your API Designer deployment by running this command:

   oc status

   If the API Designer is not deployed, run the following command to verify that you installed the correct versions of the apicurito-ui and fuse-apicurito-generator images:

   oc get is -n openshift | grep "apicurito"

5. To access the API Designer from a browser, use the provided URL (for example, https://apicurito.192.168.64.12.nip.io).

Procedure

1. If you are using Fuse Online, skip to step 2.

   If you are using Fuse on OpenShift:

   1. Log in to your OpenShift web console and then open the project that contains API Designer.

   2. For OpenShift 4.x, select Topology and then click the URL link on the apicurito-service-ui icon.

      For OpenShift 3.11, from the list of applications, click the URL for API Designer, for example https://apidesigner-myproject.192.168.64.43.nip.io

      A new browser window or tab opens for API Designer.

      Note

      Because API Designer is a “light” version of the Apicurio Studio open source project, "Apicurio" shows in the API Designer interface.

2. Click New API. A new API page opens.

   By default, API Designer uses the OpenAPI 3 specification. If you want to use the OpenAPI 2 specification, click the arrow next to the New API button and then select OpenAPI 2.

   Note

   If you open an API based on the OpenAPI 2 specification, you can use the API Designer’s Convert to OpenAPI 3 option to convert the API to comply with the OpenAPI 3 specification.

3. To change the API name:

   1. Hover the cursor over the name and then click the edit icon ( ) that appears.
   2. Edit the name. For example, type Task API.
   3. Click the checkmark icon to confirm the name change.

4. Optionally:

   • Provide a version number and a description.
   • Add your contact information (name, email address, and URL).
   • Select a license.
   • Define tags.
   • Define one or more servers.
   • Configure a security scheme.
   • Specify security requirements.

5. Define a relative path to each individual endpoint of the API. The field name must begin with a slash (/).

   For the Task Management API example, create two paths:

   • A path for tasks: /todo

   • A path for a specific task by ID: /todo/{id}

     

6. Specify the type of any path parameters.

   For the example id parameter:

   1. In the Paths list, click /todo/{id}.

      The id parameter appears in the PATH PARAMETERS section.

   2. Click Create.
   3. For the description, type: The ID of the task to find.

   4. For the type, select integer as 32-Bit integer.

      

7. In the Data Types section, define reusable types for the API.

   1. Click Add a data type.
   2. In the Add Data Type dialog, type a name. For the Task Management API example, type Todo.

   3. Optionally, you can provide an example from which API Designer creates the data type’s schema. You can then edit the generated schema.

      For the Task Management API example, start with the following JSON example:

      {
          "id": 1,
          "task": "my task",
          "completed": false
      }

   4. Optionally, you can choose to create a REST Resource with the data type.

   5. Click Save. If you provided an example, API Designer generates a schema from the example:

      
8. Optionally, you can add edit the schema properties and add new ones.

9. For the Task Management API example, create another data type named Task with one property named task of type string.

   

10. For each path, define operations (GET, PUT, POST, DELETE, OPTIONS, HEAD, or PATCH).

    For the Task Management API example, define the operations as described in the following table:

    Table 3.1. Task Management API operations

    Path	Operation	Description	Request Body	Response
    /todo	POST	Create a new task.	Media Type: application/json Data Type: Task	Status Code: 201 Description: Task created Response Body: Media Type: application/json Data Type: Todo
    /todo	GET	Get all tasks.	Not applicable	Status Code: 200 Description: List of Tasks
    /todo/{id}	GET	Get a task by ID.	Not applicable	Status Code: 200 Description: Task found for ID Response Body: Media Type: application/json Data type: Task Status Code: 404 Description: No task with provided identifier found.
    /todo/{id}	PUT	Update a task by ID.	Request Body type: Task	Status Code: 200 Description: Completed Status Code: 400 Description: Task not updated
    /todo/{id}	DELETE	Delete a task by ID.	Not applicable	Status Code: 200 Description: Task deleted Status Code: 400 Description: Task not deleted

11. Resolve any issues, as described in Resolving validation issues in API Designer.

12. For Fuse on OpenShift only, save your API specification by clicking Save As and then select JSON or YAML format.

    The JSON or YAML file is downloaded to your local download folder. The default filename is openapi-spec with the appropriate file extension.

Procedure

1. Find an issue indicated by an exclamation (!) icon. For example:

   

2. Click the exclamation icon to view a description of the issue. For example:

   

3. Based on the information provided by the issue description, navigate to the location of the issue and fix it.

   For example, to fix the "Operation must have at least one response" issue, click the GET operation to open it and then click Add a response.

   

   After you type a description for the response, the issue is resolved and the exclamation icon disappears:

   

4. For a summary of all issues:

   1. Click the Issues link in the upper right corner.

      

   2. Click Go to a problem for a specific issue to go to the location of the issue so that you can resolve it.

      

Procedure

1. In your OpenShift web console, open the project that contains API Designer.

2. Open the API Designer console. In the list of applications for the project, click the URL under apidesigner. For example: https://apidesigner-myproject.192.168.64.38.nip.io

   The API Designer console opens in a separate web browser tab or window.

3. Click Open API.

   A file manager window opens.

4. In the file manager window:

   1. Navigate to the folder that contains the existing OpenAPI definition file, for example, openapi.json.

   2. Select the OpenAPI definition file and then click Open.

      The OpenAPI definition opens in the API Designer console.

1. Click Generate.
2. Select Fuse Camel Project from the drop-down list.

Procedure

1. Unzip the API Designer-generated camel-project.zip file to a temporary folder.
2. Open Red Hat Developer Studio.
3. In Developer Studio, select File → Import.
4. In the Import dialog, select Maven → Existing Maven Projects.
5. Open the project’s camel-context.xml file in the editor view.

6. Click the REST tab to edit the Rest DSL components.

   For information on defining REST services, see the "Defining REST services" section of the Apache Camel Development Guide.

   For information on extending JAX-RS endpoints with Swagger support, see the Apache CXF Development Guide.

   For information on using the Fuse Tooling REST editor, see the "Viewing and editing Rest DSL components" section of the Tooling User Guide.

7. In the Design tab, edit the Camel routes.

   For information on editing Camel routes, see the "Editing a routing context in the route editor" section of the Tooling User Guide.

1. Log in to your OpenShift cluster:

   $ oc login -u developer -p developer

2. Create a new OpenShift project for the project. For example, the following command creates a new project named test-deploy.

   $ oc new-project test-deploy

3. Change the directory to the folder that contains your Fuse Camel project (for example, myworkspace/camel-project) :

   $ cd myworkspace/camel-project

4. Build and deploy the project to the OpenShift cluster:

   $ mvn clean fabric8:deploy -Popenshift

5. In your browser, open the OpenShift console and navigate to the project (for example, test-deploy). Wait until you can see that the pod for the camel-project application has started.
6. On the project’s Overview page, locate the URL for the camel-project application. The URL uses this form: http://camel-project-MY_PROJECT_NAME.OPENSHIFT_IP_ADDR.nip.io.
7. Click the URL to access the service.

1. Edit the Fuse project’s pom.xml file to include the openshift-maven-plugin dependency, as shown in this example:

   <plugin>
           <groupId>org.jboss.redhat-fuse</groupId>
           <artifactId>openshift-maven-plugin</artifactId>
           <version>${fuse.version}</version>
           <executions>
             <execution>
               <goals>
                 <goal>resource</goal>
                 <goal>build</goal>
               </goals>
             </execution>
           </executions>
     </plugin>

   The OpenShift Maven Plugin runs the Service Discovery Enricher if certain project-level conditions are met (for example, the project must be a Camel Rest DSL project). You do not need to specify the Service Discovery Enricher as a dependency in the pom.xml file, unless you want to customize the enricher’s behavior (as described in Customizing the API service annotation values.)

2. In the Fuse Rest DSL project’s camel-context.xml file, specify the following attributes in the restConfiguration element:

   • scheme: The scheme part of the URL where the service is hosted. You can specify “http” or “https”.
   • contextPath: The path part of the URL where the API service is hosted.

   • apiContextPath: The path to the location where the API service description document is hosted. You can specify either a relative path if the document is self-hosted or a full URL if the document is hosted externally.

     The following excerpt from an example camel-context.xml file shows annotation attribute values in the restConfiguration element:

     <?xml version="1.0" encoding="UTF-8"?>
     <beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://camel.apache.org/schema/spring       http://camel.apache.org/schema/spring/camel-spring.xsd">
     
         <camelContext xmlns="http://camel.apache.org/schema/spring">
             <restConfiguration component="servlet" scheme="https"
                   contextPath="myapi" apiContextPath="myapi/openapi.json"/>
     ...

1. Open your Fuse project’s pom.xml file in an editor of your choice.

2. Locate the openshift-maven-plugin dependency, as shown in this example:

   <plugin>
           <groupId>org.jboss.redhat-fuse</groupId>
           <artifactId>openshift-maven-plugin</artifactId>
           <version>${fuse.version}</version>
           <executions>
             <execution>
               <goals>
                 <goal>resource</goal>
                 <goal>build</goal>
               </goals>
             </execution>
           </executions>
     </plugin>

3. Add the Fabric8 Service Discovery Enricher as a dependency to the openshift-maven plugin as shown in the following example.

   <plugin>
     <groupId>org.jboss.redhat-fuse</groupId>
     <artifactId>openshift-maven-plugin</artifactId>
     <version>${fuse.version}</version>
     <executions>
       <execution>
         <goals>
           <goal>resource</goal>
           <goal>build</goal>
         </goals>
       </execution>
     </executions>
     <dependencies>
       <dependency>
         <groupId>io.acme</groupId>
         <artifactId>myenricher</artifactId>
         <version>1.0</version>
         <configuration>
           <enricher>
             <config>
               <f8-service-discovery>
                 <scheme>https</scheme>
                 <path>/api</path>
                 <descriptionPath>/api/openapi.json</descriptionPath>
               </f8-service-discovery>
             </config>
           </enricher>
         </configuration>
         </dependency>
     </dependencies>
   </plugin>

4. Save your changes.