enes-akar

Enes Akar is Co-Founder of Upstash, which is a Serverless Data Platform for Redis and Kafka. He 10+ years experience on distributed systems. He used to work for Confluent and Hazelcast before Upstash.

CEO at Upstash

Enes Akar

Use Auth0 Actions to send authentication events to Apache Kafka.

In this post, you’ll learn how to integrate Auth0 with [Apache Kafka](https://kafka.apache.org/) using Actions. You’ll do this by writing an Action that pushes information from new user registrations to a Kafka cluster. By doing this, you open a number of analytics and user experience possibilities, including:

*   Processing sign-up events (with [Apache Flink](https://flink.apache.org/) or [Spark](https://spark.apache.org/)) to notify your business and sales team when a new user signs up for an account.
*   Trigger processes such as sending a welcome email or Slack message in response to a user signing up.
*   Using a [Kafka connector](https://docs.snowflake.com/en/user-guide/kafka-connector-overview.html) to move the user data gathered from the sign-up process to a database or data warehouse to feed reporting and analytics applications.
*   Feeding new user data to your CRM application.

![Kafka](https://images.ctfassets.net/23aumh6u8s0i/47eyPrCR712YD4KWSRvG80/8150b144cf5cbb5747096d3f3af8bea4/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

## Why Apache Kafka?

Apache Kafka is a distributed messaging platform that receives data as events in real-time from sources such as sensors, mobile devices, databases, applications, and services (including Auth0) and makes that data available to target systems. It supports both publish/subscribe and distributed queue scenarios. Kafka gives you the flexibility to perform both stream processing and batch processing with your data. Kafka’s replication feature and durability allow you to use it as a persistent hub for your data.

## Auth0 Actions

Auth0 Actions are serverless Node.js functions that are triggered by certain events that take place when signing up for an Auth0 user account or authenticating with Auth0. Using Actions, you can customize and extend Auth0’s capabilities with your custom logic that you can add to events such as login, registration, changing passwords, and more. Auth0 Actions are stateless, so you’ll need an external store if you use them to collect data. Check [this article](https://auth0.com/docs/customize/actions/actions-overview) to learn more about Actions.

In this post, we will write an Auth0 Action which will be triggered by the Post User Registration flow, which happens after a user has completed signing up for an account.

## Create a Kafka Cluster

Because Auth0 Actions are stateless, we need a Kafka service that does not require stateful connections. We will use [Upstash’s Kafka service](https://upstash.com/kafka), which has a REST API and is designed for serverless environments and a free plan suitable for this project.

If you don’t already have an Upstash account, [sign up for one](https://console.upstash.com/login). The process is very quick, especially if you sign up using an Amazon, GitHub, or Google account. You’ll be taken to the [Upstash console](https://console.upstash.com/) immediately afterward:

![Cluster](https://images.ctfassets.net/23aumh6u8s0i/7i8OxJQwxFJZYOAKZGvS1f/d89275afb1698cc4f7c498eb100fb12d/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Select **Kafka** in the menu bar at the top of the page. You’ll be taken here:

![Cluster](https://images.ctfassets.net/23aumh6u8s0i/4shEb8jySPGei6xBcZ0DPK/6e056b1ae7fa8e0a9a60f7f67d047506/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

In order to use Kafka, you need a cluster, which is a set of one or more servers running Apache Kafka. Click the **Create Cluster** button. This form will appear:

![Cluster](https://images.ctfassets.net/23aumh6u8s0i/6LZJRtkgqpHLUPxpdoesuj/08d7a77dc2da2ef54e57f3dea316eaf7/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Provide the following information for each of its fields:

*   **Name:** Pick a name that will make it easy to recognize, such as “Auth0 Actions Test.”
*   **Region:** Select the region closest to you.
*   **Type:** Select **Single Zone**

Click the **Create** button to continue. You’ll see the form’s second page:

![Create](https://images.ctfassets.net/23aumh6u8s0i/130Z4nzMY3elKtmElpZz4o/d25551d11ae2615697e6b724199cac47/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

You need to provide a name for a _topic,_ which is how Kafka organizes events. If you think of events as being like files, topics are like directories. Enter the topic name **user-events-topic** into the **Name** field and click the **Send Request** button.

Upstash will create the cluster and immediately take you to its **Details** page:

![Details](https://images.ctfassets.net/23aumh6u8s0i/1iU7Q3GmamqgUbJQGVOOeF/fbf5724310a40936c0937a0e3d4baeca/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Scroll down to the **REST API** section, where you’ll see controls to copy the values for `UPSTASH_KAFKA_REST_URL`, `UPSTASH_KAFKA_REST_USERNAME`, and `UPSTASH_KAFKA_REST_PASSWORD`, which you will use in the next step.

![REST API](https://images.ctfassets.net/23aumh6u8s0i/3FEKvlN77iwUh0V8RBQ6aC/265f34f90d4d38ad09f64b5662a7dc79/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Keep this page open in a browser tab or window; you’ll need it shortly.

## Implement the Action

You will need an Auth0 account for this step. If you don’t already have an account, [you can sign up for one for free.](https://auth0.com/signup)

### Create a new action

Log into the Auth0 dashboard. On the left menu, select **Actions** → **Library**, then click the **Build Custom** button. This will open the **Create Action** pop-up:

![reate Action](https://images.ctfassets.net/23aumh6u8s0i/541DakfFmVUUMnBG9vHwr9/f60d4fe3cd82639f39f835a32b9c4a51/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Provide a name for the Action (I used **sendKafka**).  

Since the goal is to send a message to Kafka after a user has signed up for an account, the action should be triggered by the Post User Registration event. Select **Post User Registration** from the **Trigger** menu, then click the **Create** button.

You should now see the code editor:

![reate Action](https://images.ctfassets.net/23aumh6u8s0i/4QTUZab91hhnUek6nbydtm/789ab00bcbde339441a01d02ec0018c5/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

### Define the Action’s secrets

To send messages to the Kafka cluster, the Action needs the `UPSTASH_KAFKA_REST_URL`, `UPSTASH_KAFKA_REST_USERNAME` and `UPSTASH_KAFKA_REST_PASSWORD` values for your Kafka cluster, which you can copy from the Upstash console. You could simply use these values to define constants, but it’s more secure to keep them hidden. You can do this with Actions’ **_Secrets_** feature, which lets you securely store sensitive values and access them as properties of the `event.secrets` object.

Let’s start with the first value, `UPSTASH_KAFKA_REST_USERNAME`. Switch to the browser tab or window with the Upstash console and click on the icon beside `UPSTASH_KAFKA_REST_USERNAME` to copy its value. Then switch back to the Action code editor and click the “Secrets” icon:

![Secrets](https://images.ctfassets.net/23aumh6u8s0i/25t3LnePJf5WZEZlXWUNWk/d8eb298b643cc246f4edd5e9f16e8dc3/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

A new column with the title **Secrets** will appear in the code editor:

![Secrets](https://images.ctfassets.net/23aumh6u8s0i/5Mpielp1PpUBKdggFN95Ez/ff08915ea004c8a7eb894aa92bc1faec/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Click the **Add Secret** button. A pop-up will appear, and you will be able to define your first secret value:

![Add Secret](https://images.ctfassets.net/23aumh6u8s0i/6dxqg239qUPjaKFocZeGcT/c0acea0519808c411846200a23fee411/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Enter `UPSTASH_KAFKA_REST_URL` into the **Key** field, paste the value you copied from the Upstash console into the **Value** field, and click the **Create** button. This will create a property named `event.secrets.UPSTASH_KAFKA_REST_URL`, which you will be able to use in your Action.

Click the **Add Secret** button again. This time, define the `UPSTASH_KAFKA_REST_USERNAME` secret by copying its value from Upstash and filling out the **Define Secret** form as shown below:

![Add Secret](https://images.ctfassets.net/23aumh6u8s0i/g1QnSJwEekRL6u2lbcWoa/12a993bf7846febff07fbe3a4962f3e4/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Click the **Create** button, then click the **Add Secret** button one more time. Define the `UPSTASH_KAFKA_REST_PASSWORD` secret by copying its value from Upstash and filling out the **Define Secret** form as shown below…

![Define Secret](https://images.ctfassets.net/23aumh6u8s0i/35dYyYGnD9CrFlUNPhigqB/afd68d74bc539e86f607af23a956dab9/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

…then click the **Create** button. The **Secrets** column should now contain a list of three secrets:

![Create](https://images.ctfassets.net/23aumh6u8s0i/1wkGPTskvMIU8BHQUXdlTn/6090399c09c0cecebf448949444b5fa7/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

### Add the node-fetch module to the Action

You can import any npm module into an Action, which makes them very powerful. This action uses the [node-fetch](https://www.npmjs.com/package/node-fetch) module to send events to the Kafka cluster, so you’ll need to add it as a dependency. You can do this with the **_Modules_** feature.

Click the “Modules” icon, which is just below the “Secrets” icon:

![Modules](https://images.ctfassets.net/23aumh6u8s0i/1FIkQiyIwiEnMuLceyRqWm/229bfc23e1b8b9fb8c1f804fbfa672a4/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

A new column with the title **Modules** will appear in the code editor:

![Modules](https://images.ctfassets.net/23aumh6u8s0i/6D6vSKdIZwkhIk26zhpMfv/f6c18c676a69f6c519ba9b30166034e9/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Click the **Add Module** button. A pop-up will appear:

![Add Module](https://images.ctfassets.net/23aumh6u8s0i/7KbTmaZmZNNUDiMnqgvPF9/c1fa1efdc6285f5f51405f8a924df68c/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Enter **node-fetch** into the **Name** field and **2** into the **Version** field. Do _not_ select the latest version (3 at the time of writing), as it does not allow `require()` to import it.

Click the **Create** button. The **Modules** column should now list the _node-fetch_ module:

![Create](https://images.ctfassets.net/23aumh6u8s0i/3Uvbaeb6xNhGQWcE2T8Ru4/2dd6b53db2bf15ab2f23e020416e366c/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

### Write the Action

Now that you have provided the prerequisites, it’s time to write the Action!

Paste the code below into the editor:

```
const fetch = require('node-fetch');
 
exports.onExecutePostUserRegistration = async (event) => {
  const address = event.secrets.UPSTASH_KAFKA_REST_URL
  const user = event.secrets.UPSTASH_KAFKA_REST_USERNAME
  const pass = event.secrets.UPSTASH_KAFKA_REST_PASSWORD
  const auth = Buffer.from(`${user}:${pass}`).toString('base64')
  const topic = 'user-events-topic'

  const userData = JSON.stringify(event.user);
  const x = await fetch(`${address}/produce/${topic}`, {
    method: 'POST',
    headers: {'Authorization': `Basic ${auth}`},
    body: JSON.stringify({"value" : userData})
  })
  const response = await x.json();
  console.log(response)
};
```

This Action uses the `onExecutePostUserRegistration()` function provided by Auth0. The function is called when the user has finished signing up for an account. It takes a single parameter, `event`, whose `user` property is an object containing information about the newly-registered user, such as their email address and user ID.

This code retrieves the secret values stored in the Action’s Secrets and uses them to connect to the Kafka cluster. It takes the `user` object, converts it into a raw JSON string, and sends it to the topic named `user-events-topic` in the Kafka cluster. The user data to the Kafka topic using the Upstash REST API.

### Test the Action

Now, we can run the function by clicking on the **Test** icon on the editor’s sidebar:

![Test](https://images.ctfassets.net/23aumh6u8s0i/6UPSQybrGeZRu0kj6qzpsQ/13cf0a64078bd41880c5352ef585dc04/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

A new column with the title **Test** will appear in the code editor:

![Test](https://images.ctfassets.net/23aumh6u8s0i/6iPKb04fleyOW1kndgekn5/8a43590a9482e388757f5cecf628b227/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Click the **Run** button to run the test. A **Test Results** pane will appear in the lower section of the code editor:

![Run](https://images.ctfassets.net/23aumh6u8s0i/3NNpjQElJ4qrQQAGPSZ5mj/750f79ace5041fb987f839115067ea2b/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

You should see something similar to the output below in the **Logs** section:

```
Logs:
[
  {
    topic: 'user-events-topic',
    partition: 0,
    offset: 317,
    timestamp: 1641950606804
  }
]
```

You now have a working Action. It’s time to deploy it!

## Deploy the Action

Click the **Deploy** button located near the upper right corner of the page. This saves your Action and makes it the current version in your library,

Now that your Action is in the Library, you need to add it to the Post User Registration flow. Navigate to the flow by selecting **Actions** from the left side menu, then **Flows** →**Post User Registration**. You’ll see this:

![Deploy](https://images.ctfassets.net/23aumh6u8s0i/MTvdp0U3YWpwQ3zP0PNvm/cd660cc3c68f8c1b3f85738f4b764915/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

In the **Add Action** section on the right side of the page, select the **Custom** tab to see the Actions you have created:

![Deploy](https://images.ctfassets.net/23aumh6u8s0i/2ws2KlG9D05TFenL1KkHz5/3665c18f8042ba8f30ae2772c48fc206/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

You should see the **sendKafka** action. Drag and drop it to the area between the **Start** and **Complete** nodes in the flow as shown below:

![sendKafka](https://images.ctfassets.net/23aumh6u8s0i/6xO4IuP3sJXiURYYFYQDqt/4ba5fb18546c69890af0c71cefe55f27/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Now that you have added your Action to the flow apply the change by clicking the **Apply** button near the upper right corner of the page.

## Test the Action

Now that the Action is deployed, it’s time to test it!

### Create a new user

The Action you just created runs whenever a new user signs up, so one way to test it is to create a new user using the Auth0 dashboard.

In the Auth0 dashboard’s left menu, select **User Management** → **Users** → **Create User** and create a new user:

![User Management](https://images.ctfassets.net/23aumh6u8s0i/4oVUjX54aRwTPCOu4bBqXu/6e6bd39df85e29061f918af92681067f/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

After creating the user, switch to the Upstash browser tab or window, select the **Topics** tab, and then select the **user-events-topic** topic:

![Topics](https://images.ctfassets.net/23aumh6u8s0i/5KBLE6L4v4AVlNb5RsQPKX/208f1e1ba0c3820de192cf4d928c99d7/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

This will display the statistics for your Kafka topic:

![Topics](https://images.ctfassets.net/23aumh6u8s0i/6bYnLjjiKI1uQ8hTl7hQnQ/3c318e37ea74536beaa3923054b2c1f8/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Each time you create a new user, a new message is pushed to the Kafka topic, increasing its count —which appears under **Messages** —by one.

You can check the Kafka topic by using the **Consumer** curl script in the **REST API** section under the **Details** tab:

![Details](https://images.ctfassets.net/23aumh6u8s0i/54opQIKp8N757l82HmPrle/199a88de3d5caad79126da557fd76d26/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

![Details](https://images.ctfassets.net/23aumh6u8s0i/7HtICJcX8nk92VgX7O244c/053a270c39a0fb52ea759e85b476812b/Uploaded_from_Send_Auth0_Events_to_Kafka_for_Realtime_Processing_)

Run the curl script in your command line console. The result should look something like this:

```
[ {
  "topic" : "user-events-topic",
  "partition" : 0,
  "offset" : 316,
  "timestamp" : 1641948554609,
  "key" : "",
  "value" : "{\"email\":\"exampleuser@example.com\",\"tenant\":\"test-upstash\",\"user_id\":\"auth0|61de2511fd334200aq221d\",\"app_metadata\":{},\"user_metadata\":{},\"email_verified\":false,\"phone_verified\":false}",
  "headers" : [ ]
} ]%
```
## Conclusion

Auth0 Actions enable developers to inject custom logic into the user lifecycle, adding additional behavior and features to the login process. In this article, we used Auth0 Actions to produce events for Kafka triggered by new user registrations. Once stored in Kafka, there are endless possibilities for how you can leverage the data.

Use Auth0 Actions to Send User Info to Apache Kafka When They Register

maniish_jaiin

I am Manish and I am a Software Engineer by profession. I have been writing on Medium for a year now. I write majorly because it fulfills my desire to share my knowledge and gives me a creativity boost. <br> 
I write on a variety of topics like Software Engineering, Tech, Programming, Developer Productivity, Apple Products, and a few more. I have worked at ThoughtWorks and BCG Digital Ventures and I am currently living in Berlin. 

Software Engineer

Manish Jain

Learn how to process streams of data from Apache Kafka topics using Spring Cloud Streams

**TL;DR:** Have you ever wondered how features like Google Maps' live traffic work? These systems have to gather and process data in real-time. The architecture of these systems generally involves a data pipeline that processes and transfers data to be processed further until it reaches the clients. In this article, we will see something similar with a simple example using Kafka Streams. The sample app can be found [here](https://github.com/auth0-blog/spring-cloud-stream-sample).

## Introduction to Spring Cloud Stream

Spring Cloud Stream is a framework designed to support stream processing provided by various messaging systems like Apache Kafka, RabbitMQ, etc. The framework allows you to create processing logic without having to deal with any specific platform. It helps you build highly scalable event-driven microservices connected using these messaging systems.

The framework provides a flexible programming model built on already established and familiar Spring idioms and best practices. The way it works is simple; you have to provide implementations (called Binder implementations)for the messaging system that you are using. Spring cloud stream supports:

* [RabbitMQ](https://github.com/spring-cloud/spring-cloud-stream-binder-rabbit)
* [Apache Kafka](https://github.com/spring-cloud/spring-cloud-stream-binder-kafka)
* [Kafka Streams](https://github.com/spring-cloud/spring-cloud-stream-binder-kafka/tree/main/spring-cloud-stream-binder-kafka-streams)
* [Amazon Kinesis](https://github.com/spring-cloud/spring-cloud-stream-binder-aws-kinesis)

And a few others. The links above will take you to the binder implementations. In this article, we will look into a simple application that uses Kafka Streams as a stream processor listening to events on a topic, processing the data, and publishing it to the outgoing topic.

## Introduction to Apache Kafka

Apache Kafka is a distributed publish-subscribe messaging system. It is a system that publishes and subscribes to a stream of records, similar to a message queue. Kafka is suitable for both offline and online message consumption. It is fault-tolerant, robust, and has a high throughput. Kafka is run as a cluster on one or more servers that can span multiple data centers. The Kafka cluster stores stream of records in categories called topics. Each record consists of a key, a value, and a timestamp. For more information on topics, Producer API, Consumer API, and event streaming, please visit this [link](https://kafka.apache.org/intro).

## Introduction to Kafka Streams

Kafka Streams is a library that can be used to consume data, process it, and produce new data, all in real-time. It works on a continuous, never-ending stream of data. Consider an example of the stock market. The stock prices fluctuate every second, and to be able to provide real-time value to the customer, you would use something like Kafka streams.

## Pre-requisites:

1. Basic knowledge of [Java 11](https://jdk.java.net/archive/).
2. Basic knowledge of [Spring Boot](https://spring.io/projects/spring-boot).
3. A basic understanding of [Apache Kafka](https://kafka.apache.org/intro).
4. [Docker](https://docs.docker.com/get-docker/) and [Docker Compose](https://docs.docker.com/compose/install/) for running Kafka locally.

## Setting up Spring Boot App

Let us first create a Spring Boot project with the help of the [Spring boot Initializr](https://start.spring.io/#!type=mavenproject&language=java&platformVersion=2.4.5.RELEASE&packaging=jar&jvmVersion=11&groupId=io.pratik&artifactId=springcloudsqs&name=springcloudsqs&description=Demo%20project%20for%20Spring%20cloud%20sqs&packageName=io.pratik.springcloudsqs&dependencies=web,lombok), and then open the project in our favorite IDE. Select Gradle project and Java language. Last but not least, select Spring boot version `2.5.4`. Fill in the project metadata and click generate.

For Spring Cloud, We need to configure Spring Kafka and Kafka Streams in our `gradle.build`:

```groovy

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.apache.kafka:kafka-streams'
    implementation 'org.springframework.kafka:spring-kafka'
}

```

Let's setup the config for Kafka. We need to define a few parameters on how we want to serialize and deserialize the data. The config is easy to set up and understand. Since our application will be listening to a topic and producing the output to a different topic, our application is a producer and a consumer both. So, we need to define config for both producer and consumer.

In the application.yml file, we need to add these entries.

```yaml

kafka:
  bootstrap-servers: localhost:9092
  properties:
    schema.registry.url: http://localhost:8081

  producer:
    client-id: ${spring.application.name}
    key-serializer: org.apache.kafka.common.serialization.StringSerializer
    value-serializer: org.apache.kafka.common.serialization.StringSerializer

  consumer:
    client-id: ${spring.application.name}
    group-id: ${spring.application.name}-group
    key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    auto-offset-reset: earliest

  streams:
    client-id: ${spring.application.name}-stream
    application-id: ${spring.application.name}
    properties:
      default.key.serde: org.apache.kafka.common.serialization.Serdes$StringSerde
      default.value.serde: org.apache.kafka.common.serialization.Serdes$StringSerde

```

If you look at the config carefully, we are setting up serializers and de-serializers for the producer, the consumer, and the streams (serde is just short for serializer-deserializer). This is the only setup we need for the Spring boot project.

Let's jump into creating the producer, the consumer, and the stream processor. I have taken a simple example here. We are producing random numbers every 2 seconds using a scheduler.

```java

@Component
@AllArgsConstructor
public class NumberProducer {

    NumberPublisher numberPublisher;

    @Scheduled(fixedRate = 2000)
    public void produceIntStream() {
        Random random = new Random();
        numberPublisher.produce(random.nextInt(1000));
    }
}

```

The number publisher is the actual publisher that puts the data on a topic. We set a key for the message and the data (which is a random number in our case).

```java

@Slf4j
@Component
@AllArgsConstructor
public class NumberPublisher {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public void produce(Integer randomNumber) {
        String s = "Odd";
        if (randomNumber % 2 == 0) s = "Even";
        System.out.println("Produced number: " + randomNumber);
        kafkaTemplate.send(INPUT_TOPIC_NAME, s, String.valueOf(randomNumber));
    }
}
```

The key is defined as a String, which is either even or odd based on the number. We use the Kafka template to send the message; this comes from the spring-kafka library. It abstracts out the logic for publishing and consuming the messages.

Next up, we set up our stream processor that listens to the topic on which the publisher is putting the messages. This is where it gets interesting. We listen to the `INPUT_TOPIC` and then process the data. In this case, the job of the stream processor is to filter out the odd numbers and only send the even numbers on the `OUTPUT_TOPIC`.

```java

@Configuration
@EnableKafkaStreams
public class KafkaStream {

    public static final String OUTPUT_TOPIC_NAME = "even-number-topic";
    public static final String INPUT_TOPIC_NAME = "number-topic";

    @Bean
    public KStream<String, String> evenNumbersStream(StreamsBuilder kStreamBuilder) {
        KStream<String, String> input = kStreamBuilder.stream(INPUT_TOPIC_NAME);

        KStream<String, String> output = input.filter((key, value) -> key.equals("Even"));

        output.to(OUTPUT_TOPIC_NAME);
        return output;
    }
}

```

You might be wondering about that KStream in the return type of our method. I will give a brief overview here as it is outside the scope of this article.

KStream -> A Kafka stream that is append-only. When you provide data with the same key, it will not update the previous record. It provides several operations that are very useful for data processing, like a filter, map, partition, flatMap, etc. You can read more about KStreams [here](https://www.confluent.co.uk/blog/introducing-kafka-streams-stream-processing-made-simple/).

Finally, when we have processed the data, we put it on an `OUTGOING_TOPIC`. For the sake of simplicity and completion, I am listening to that topic in our application. This generally will not be the case, as there would be another application that would be consuming from that topic and hence the name `OUTGOING_TOPIC`.

```java

@Component
@EnableKafka
public class EvenNumberConsumer {

    @KafkaListener(topics = OUTPUT_TOPIC_NAME)
    public void receive(String value) {
        System.out.println("Received number: " + value);
    }
}

```

The application code is complete. Let's set up Kafka locally.

## Setting up Kafka Locally

Setting up Kafka is easy, but it requires some dependency to run, you just need to use the docker-compose file below, and it will start the Kafka server locally. Add the `docker compose.yml` to the repository's root directory. Start the required dependency using: `docker-compose up`.

```yaml

version: '3.7'

services:
  kafka:
    image: confluentinc/cp-kafka:5.5.0
    container_name: kafka
    hostname: kafka
    restart: always
    environment:
      KAFKA_LISTENERS: LISTENER_DOCKER_INTERNAL://:29092,LISTENER_DOCKER_EXTERNAL://:9092
      KAFKA_ADVERTISED_LISTENERS: LISTENER_DOCKER_INTERNAL://kafka:29092,LISTENER_DOCKER_EXTERNAL://localhost:9092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: LISTENER_DOCKER_INTERNAL:PLAINTEXT,LISTENER_DOCKER_EXTERNAL:PLAINTEXT
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_INTER_BROKER_LISTENER_NAME: LISTENER_DOCKER_INTERNAL
      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    ports:
      - 9092:9092
      - 9999:9999
    depends_on:
      - zookeeper

  zookeeper:
    container_name: zookeeper
    hostname: zookeeper
    image: confluentinc/cp-zookeeper:5.5.0
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
    ports:
      - 2181:2181

  schema-registry:
    image: confluentinc/cp-schema-registry:5.5.0
    hostname: schema-registry
    container_name: schema-registry
    restart: always
    environment:
      SCHEMA_REGISTRY_KAFKASTORE_BOOTSTRAP_SERVERS: "kafka:29092"
      SCHEMA_REGISTRY_HOST_NAME: schema-registry
      SCHEMA_REGISTRY_LISTENERS: "http://0.0.0.0:8081"
    ports:
      - 8081:8081
    depends_on:
      - zookeeper

```

That's it!

## Verify Sending, Processing, and Receiving of Events

Run the Spring Boot app:

1. Clone the sample code from the repo. Go to the root directory.
2. Use the Gradle plugin to run your Spring Boot app using the command in the project directory.

```shell
./gradlew bootRun
```

Just run the application. You should see logs like this.

```shell
Received number: 910
Received number: 320
Received number: 16
Received number: 526
Received number: 76
Received number: 936
Received number: 642
Produced number: 510
Received number: 510
Produced number: 996
Received number: 996
Produced number: 897
```

## Conclusion

Spring Cloud Stream provides a simple and convenient way to create apps that can process streams and publish data to different topics. You can build micro-services that talk to each other using Kafka messages and process data like you would process in a single application.

In this article, we have learned how to build a Spring Cloud Stream app that uses Kafka Streams. We saw how Spring Cloud Stream provides an easy way to set up and run an application that can consumer, process, and publish messages to Kafka topics without the hassle of configuring each. With such little code, we could do so much.

You can refer to the repository used in the article on [Github](https://github.com/auth0-blog/spring-cloud-stream-sample).

Spring Cloud Streams with Apache Kafka

jessica-sealby

Jessica drives public relations and global communications efforts for Auth0 across Asia Pacific. Outside Auth0, she frequents Melbourne’s live music venues and chases after her two energetic dogs.

PR Manager - APAC

Jessica Sealby

Seasoned partner executive joins the technology unicorn to grow partner business across APAC; Auth0 also announces new partner in Korea



**SINGAPORE, 30 April 2020:** The [Auth0](https://auth0.com/) Identity Platform, a product unit within Okta, has committed to growing its partner sales across Asia Pacific through the appointment of channel veteran [Jason Teo](https://www.linkedin.com/in/jasonteocj/?originalSubdomain=sg) as the company’s first partner chief in the region.

In this new role as APAC Head of Partnerships and Alliances, Teo’s mandate is two-fold: to build and grow the partner ecosystem in the region; and to execute a partner strategy that will diversify sales and accelerate growth.

Teo has extensive experience helping technology companies expand across Asia and plans to draw upon his vast network and established relationships with partners and system integrators to help support Auth0’s ambitious growth plans in Asia Pacific.

Regional Director for Auth0 in Asia Pacific, Richard Marr, welcomed Teo as an integral part of the company’s growth strategy. “Our differentiated identity platform is seeing adoption in all market sectors and geographies; we’ve experienced consistently high growth across Asia Pacific and invested strongly in the region with three offices and a team spanning South East Asia, Japan, Australia and New Zealand, and India,” said Marr. 

“Building partnerships in APAC is the next important step for Auth0 as we continue to expand locally, and we’re very pleased to have Jason at the helm,” added Marr.

As part of Auth0’s expansion in the region, it has partnered with digital transformation specialist, [OSC Korea](http://www.osckorea.com/). “We are experts in helping our customers to accelerate the digital transformation experience by providing Open Source, microservices architecture, DevOps CI/CD consulting and deployment,” said Jay Kim, CEO at OSC Korea. “To best support our customers, we are working with Auth0 as the identity and authentication solution that can be easily integrated and improve business performance.”

Teo has held leadership positions in various companies including Amazon Web Services, where he was the first Head of Channels and Alliances for ASEAN, launching and establishing its partner ecosystem across the region. His career also includes building the Cloud Business Unit for IBM in Singapore and being the first person on the ground for BlackBerry in Singapore, managing their telco partners across Asia Pacific.

According to Teo, finding the right partners is vital to help Auth0’s customers adopt a cloud-native solution for identity management. He joined the U.S.-based unicorn as he believes Auth0 is creating meaningful technology that can be applied across industries and to organizations of all sizes, from small businesses to large enterprises.

“I am thrilled to be part of such a high-growth company and lead the effort around its [Partner Program](https://auth0.com/partners) expansion in APAC. It takes a whole ecosystem to get our customers up and running, which is why it’s so important we have the interests of all our stakeholders at heart to provide the best possible service,” said Teo.

“We are working with our major global partner network while actively cultivating new local partner relationships across the region, ensuring our offerings are localized and relevant to the needs of each market,” Teo added. 

Auth0 has joined the Amazon Web Services (AWS) [Partner Network](https://auth0.com/blog/auth0-joins-the-aws-partner-network-global-startup-program/) (APN) Global Startup Program and recently announced global partnerships with [Cognizant](https://auth0.com/blog/auth0-expands-global-partner-network-with-cognizant/) and [Globant](https://auth0.com/blog/auth0-partner-program-accelerates-global-growth/) as it expands its [Partner Program](https://auth0.com/partners) in APAC and around the world.

<include src="asides/AboutAuth0" />

### Media Contacts
Jessica Sealby<br>
[jessica.sealby@auth0.com](mailto:jessica.sealby@auth0.com)

Sophie Mayes<br>
[auth0@keepleft.com.au](mailto:auth0@keepleft.com.au)


Auth0 Hires Former AWS Channel Head, Jason Teo, to Lead Efforts in Asia Pacific

auziros:jeana-tahnk

Jeana has been in the tech industry for 15+ years, both as a communications professional and writer. As Director of Global Communications at Auth0, she works with her internal team and external agencies to amplify the company's visibility worldwide and establish its leadership in the identity industry. When she is not working, she can most likely be found on a field watching one of her three kids playing sports, or cleaning up after her one-year-old retriever who chews everything.

Senior Director, Global Communications

Jeana Tahnk

New hire will drive growth to maximize potential for the region.



**BELLEVUE, Wash. and TOKYO – November 27, 2018 –** [Auth0](https://auth0.com/), a global leader in Identity-as-a-Service (IDaaS), today reinforced its commitment to growth in Japan with the addition of Jun Fujita to its team. As Country Manager based in Tokyo, Mr. Fujita will be responsible for reaching Auth0’s revenue and growth targets, further building the Auth0 KK team, and driving strategic business development activities.

Japanese companies are investing aggressively in digital transformation and are expected to spend at least $5.8 billion on cloud services in 2018; and experience the second fastest growth in public cloud services spending worldwide over the next five years, according to [IDC](https://www.idc.com/getdoc.jsp?containerId=prUS43511618). Given this trend, Japanese companies and their customers, partners, and employees are confronting the challenges of complex authentication and authorization, representing a tremendous market opportunity for Auth0. 

Earlier this year, Auth0 announced a [$55 M Series D](https://auth0.com/blog/auth0-announces-55m-series-d-funding/) funding round, which included significant investment from [World Innovation Lab (WiL)](https://wilab.com/), a leading firm known for its expertise in the Japanese market. Auth0, under Mr. Fujita’s leadership, will work closely with WiL to aggressively expand its go-to-market strategy and execute its longer-term vision for the region. 

“The continued support of WiL and the addition of Fujita-san to our team provides a great foundation for us to really spread our wings in Japan,” said Eugenio Pace, CEO and Co-founder of Auth0. “There is no denying that the appetite for identity and access management in Japan is present and growing. We are ready to take advantage of this opportunity to build our market leadership position.”

“Auth0 is well-positioned to support Japanese companies' digital transformation with its authentication and authorization solution, a critical component of any digitally-native business and their processes,” said Tsune Shirota, Partner at WiL. “Auth0 certainly has the technology innovation and now the leadership to be very successful there.”

Mr. Fujita has nearly 20 years of experience in the IT industry, focusing specifically on enterprise customers in Japan. As former country manager for Elastic and Github, he brings valuable knowledge of strategic planning and regional growth initiatives to the role. 

“Auth0 is a very unique company that I feel so lucky to join,” said Mr. Fujita. “The company has already gained several key customers here, and I look forward to continuing this momentum and contributing even more to our success.”  

Auth0’s focus on Japan represents another step in the company’s global expansion plan. Having recently announced significant momentum in [Australia and New Zealand](https://auth0.com/blog/auth0-announces-growth-in-australia-and-new-zealand/), Auth0 is poised to command a more prominent share of the greater Asia-Pacific region. 

**About World Innovation Lab**

World Innovation Lab (WiL) connects entrepreneurs with corporate resources to build global businesses. WiL is a multi-stage venture capital firm that invests in consumer and enterprise technology companies. With a deep network of global corporate partners, the firm is committed to providing startups with unparalleled investment and partnership opportunities. Recent investments include Auth0, Automation Anywhere, BirdEye, ClearMotion, Digital Shadows, Doctor on Demand, Intertrust, Mercari, Soracom, PeerStreet, and TransferWise.

World Innovation Lab's foundational platform includes the Japanese government investment arm and over 25 Japan leading corporations such as Sony, Nissan, 7-Eleven, ANA (All Nippon Airways), Suzuki, Mizuho Bank, Daiwa Securities, Itochu, NTT, and KDDI. In addition to venture investment, WiL also collaborates with the world’s leading companies to incubate new businesses and to create spin-offs and joint ventures.

[www.wilab.com](http://www.wilab.com/)


<include src="asides/AboutAuth0" />

### **Media Contacts:**
Jeana Tahnk<br/>
Corporate Communications<br/>
Auth0<br/>
[jeana.tahnk@auth0.com](mailto:jeana.tahnk@auth0.com)


Auth0 Announces New Country Manager in Japan

Headcount triples in Sydney to support rapidly expanding customer base



**BELLEVUE, Wash., September 25, 2018** – [Auth0](https://auth0.com/), a global leader in Identity-as-a-Service (IDaaS), today announced the company’s growth in Australia, New Zealand, and neighboring countries. In the past year alone, Auth0 has tripled its staff in this region to support the 125 percent growth in customer acquisition, including well-known enterprises such as CarsGuide, Atlassian, AGL, Servcorp, THE ICONIC, Television New Zealand (TVNZ), and many others. 

A recent [industry report](https://www.reportbuyer.com/product/4837042/consumer-iam-market-by-solution-service-authentication-type-deployment-mode-organization-size-industry-vertical-and-region-global-forecast-to-2023.html) by Report Buyer forecasts the consumer Identity and Access Management (IAM) market to grow to more than $37 billion by 2023, with Asia Pacific accounting for the highest growth rate during this period. 

The rapid adoption of Auth0’s Universal Identity Platform, especially within Australia and New Zealand over the past year, is indicative of the company’s continued expansion throughout this region. 

"As one of the largest online car marketplaces in the country, one of our primary goals is to make things simpler, safer, and more enjoyable for our customers during their car-purchasing process,” said Jeremy Gupta, CTO of CarsGuide. “For us, that involves using best-of-breed platforms, enabling our internal teams to move with speed – and leaving security and user identity to the experts. We'll soon have two large consumer brands in market with the introduction of Autotrader, and Auth0’s seamless and secure login process will help immensely with providing users a superior experience, no matter the channel."

“Enterprises are choosing Auth0 for its extensibility and ability to simultaneously address the identity needs for any audience that needs authentication,” said Eugenio Pace, CEO and Co-founder of Auth0. “This demand is driving our remarkable growth across Australia and New Zealand, and we are continually adding to our team in Sydney.”

The threefold growth of the team, led by Regional Director Richard Marr, represents Auth0’s commitment to its customers in this region.

Pace adds, “I had the pleasure of being in Sydney two weeks ago to meet our valued customers and ensure we are providing them with the best identity solution now and into the future.” 

Funds from the company’s [$55M in Series D funding](https://auth0.com/blog/auth0-announces-55m-series-d-funding/), announced in May, have driven Auth0’s expansion in Australia and New Zealand as part of the company’s wider global growth strategy.

<include src="asides/AboutAuth0" />

### **Media Contact:**

Jeana Tahnk<br>
Corporate Communications<br>
Auth0<br>
[jeana.tahnk@auth0.com](mailto:jeana.tahnk@auth0.com)

Jordan Lambe<br>
Keep Left for Auth0<br>




Auth0 Announces Growth in Australia and New Zealand

diegopoza

System Engineer, geek, foodie, technology lover, speaker.

Sr Manager, Developer Advocacy

Diego Poza

How you can effortlessly create your multiplatform application from a web application



<div class="alert alert-danger alert-icon">
  <i class="icon-budicon-500"></i>
  <strong>This post is out of date.</strong> Please stay tuned for any new content coming on the hybrid mobile app development space from us. What would you like to see? React Native? Let us know through our <a href="https://community.auth0.com/c/blog-discuss">Auth0 Community Blog board</a>, please.
</div>

**TL;DR:** Apache Cordova is a good option for those who already have a web application and want to port it to the different mobile platforms. This post show you how yo can do this, even if your app is already hosted and live. It also provides several tips on how to create a successful Cordova app. Check out [the repo](https://github.com/auth0/cordova-sample) to get the code.

---

Mobile applications is one of the fastest-growing categories in the mobility market today. If you already have a web application up and running and want to get on board with this trend, you can do it very quickly using Apache Cordova.

<include src="TweetQuote" quoteText="Mobile applications is one of the fastest-growing categories in the mobility market today."/>

The promise of Cordova development is quite charming: you can use your existing HTML + JavaScript + CSS application to build cross-platform mobile applications for iOS, Android, Windows Phone, and other platforms.

## What is Apache Cordova?

[Apache Cordova](https://cordova.apache.org/) is a free and open-source platform for building native mobile applications using HTML, CSS, and JavaScript. This allows you to target multiple platforms with just one codebase.

Basically, Cordova is a wrapper, an application that has an embedded web browser where your web app is loaded.

 > **Note:** There is some confusion between Cordova and PhoneGap. Let's clarify this: Cordova is owned and maintained by Apache and will always be maintained as an open-source project. On the other hand, PhoneGap is a distribution of Cordova owned by Adobe which includes additional build services that may not be free. Currently, both have a very similar API. Unless you need one of the additional build services that PhoneGap provides, you should go with Cordova.

## Installing and setting up Apache Cordova

Before installing and running anything related to Cordova, you will need to install the SDK for each platform that you intend to build your application for. In this post we will focus on iOS and Android; nevertheless, the process for other platforms is quite similar.

You will need a Mac computer with [Xcode](https://developer.apple.com/xcode/download/) to specify iOS as the target platform, and the [Android SDK](http://developer.android.com/sdk/index.html) to target the Android platform.

> For instructions on downloading and configuring the Android SDK, go to the [Official Android SDK installation documentation](http://developer.android.com/sdk/installing/index.html).

First, install the Cordova command-line utility by running the following command:

```
npm install -g cordova
```

> If you are on a Mac computer, you must add `sudo` at the start of the aforementioned command.

Create a new Cordova project by running the following command, where `[your-app-name]` is the folder where the app will be created:

```
cordova create your-app-name com.example.myapp MyAppName
```

> The `create` command has three parameters: the first specifies the folder where the solution will be created, the second is a reverse domain-style identifier which must be unique, and the last one is the application display name. The last two paramenters can be omitted and configured later in the `config.xml` file.

Browse to the project folder to add the platforms that you want to support. To do this, once you are in the project foler, run the following command for each platform you want to add:

```
cordova platform add [platform]
```

Where `[platform]` can be:

- ios
- android
- windows
- wp8
- blackberry10
- firefoxos
- amazon-fireos

> If you want to check which platforms are available in your system, run `cordova platform ls`.

Each time you run the `platform add` command, it will add native files to build apps for the specified platform. After running the above command, you should find a folder named ios containing .xcodeproj files and a bunch of other files.

## Porting your web app to Cordova

In your project folder, you should find the `/www` directory. This is where your web app is located.

> For this example we used the TodoMVC Vanilla JavaScript example that you can download from [here](https://github.com/tastejs/todomvc/tree/master/examples/vanillajs). Remember to run `npm install` to get the app dependencies.

Your app's `index.html` body content goes into the body of `/www/index.html`. Perform these three simple steps to update it:

1. Update the **head** of the file carefully so as not to remove or modify Cordova's required meta tags, but add the elements necessary to your app. In this case, we added our app's title, CSS references, and the charset meta tag.
2. Update the **body** content with your app content.
3. Add the references to your app's required .js files (typically, at the end of the _body_).

The `/js/index.js` includes functions that are required for Cordova. You just need to call your app init logic inside the **onDeviceReady** method, as shown in the example below:

```
var app = {
    initialize: function() { ... }    
    bindEvents: function() { ... }    

    onDeviceReady: function() {
        // Your app init code
        ...
    }
};

app.initialize();

```

> As the TodoMVC is very simple, just ensuring that the cordova.js and index.js files are executed before the app logic is sufficient.

Finally, all the CSS files, images, and JavaScript files should be moved to the corresponding folder inside the `/www/` folder.

![Cordova app structure](https://images.ctfassets.net/23aumh6u8s0i/6M1FSAQE1u8UWp46xaYeKq/6ee162f353d494ade190d54901e122b1/cordova-app-structure)

### Add hosted webpage as an app

If your application is already hosted on a server, converting your web app is very easy independent of the framework and languages used to create it.

Add the **dialogs** and **network information** plugins to your application by running the following commands:

```
cordova plugin add cordova-plugin-dialogs

cordova plugin add cordova-plugin-network-information
```

To do it, after the **onDeviceReady** event occurs, just navigate to the URL of your hosted app, and that's it.

This is shown in the following code:

> Continuing with the ToDoMVC app sample, we added this code at the bottom of the `app.js` file.

```
 <script>
  function onDeviceReady() {
    if (navigator.connection.type == Connection.NONE) {
      navigator.notification.alert('An internet connection is required to continue');
    } else {
      window.location="http://www.myapp.com";
    }
  }
  document.addEventListener("deviceready", onDeviceReady, false);
</script>

```

Additionally, as the hosted app will require an internet connection, we added a simple check to verify that this condition is fullfilled.

> **Note:** By default, the Cordova app has the access origin policy set to all: `*`. If you change this policy, remember to add a rule to allow access to the domain on your hosted app in the `config.xml` file, as shown in the following code:

```
<?xml version="1.0" encoding="utf-8"?>
<cordova>
    <access origin="http://www.myapp.com*"/>
</cordova>
```

### Define the application icon and splash screen

These two assets are very simple to add and very important to your application, as they will give the look and feel of a mobile app.

You can set a generic icon in the `config.xml` file for all platforms by using the **icon** element. If you do not specify an icon then the _Apache Cordova_ logo is used.

However, an icon that looks good on one platform may not look good on another. For this reason, you have the option to include specific icons for each platform. If you specify a platform icon, this will override the generic icon setting.

In the other hand, you can use the `splash` element to define the splash screens for each platform. In this case you will have one element per resolution. You should also consider the device's orientations; that is, splash screens for portrait and landscape orientations.

> See the [Cordova documentation](http://cordova.apache.org/docs/en/latest/config_ref/images.html) for the available resolutions for each platform.

The following code snippet shows the definition of a generic icon and platform-specfic icons; it also shows the splash screen definition for iOS.

```
<?xml version='1.0' encoding='utf-8'?>
<widget id="com.example.myapp" version="0.0.1" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
    <name>MyApp</name>
    <icon src="generic-icon.png" />
    ...
    <platform name="ios">
    <icon src="ios-icon.png" />
    <splash src="res/screen/ios/Default~iphone.png" width="320" height="480"/>
    <splash src="res/screen/ios/Default@2x~iphone.png" width="640" height="960"/>
        ...
    </platform>
        <platform name="android">
        <icon src="android-icon.png" />
        ...
    </platform>
</widget>
```

> Notice that the value of the `src` attribute is relative to the project directory and not to the www directory.

## Adding native features

Most native features can be easily added to your Cordova app by using its plugin system. You can browse [Cordova Plugin APIs page](https://cordova.apache.org/docs/en/latest/cordova/plugins/pluginapis.html) to see the most used plugins.

In this blog post we will show you how to add geolocation support to make your applications location-aware.

First, install the **cordova-plugin-geolocation** plugin by running the following command:

```
cordova plugin add cordova-plugin-geolocation
```

Once the plugin is installed, just add a call to the **navigator.geolocation.getCurrentPosition** method in your app's code, and that's it.

```
navigator.geolocation.getCurrentPosition(geolocationSuccessCallback,
                                         [geolocationError],
                                         [geolocationOptions]);
```

> **Note:** You can only call the **getCurrentPosition** method once the **onDeviceReady** event has been fired.

The following is a very simple example of code that gets the current location.

```
var onSuccess = function(position) {
    console.log('Latitude: ' + position.coords.latitude + '\n' +
          'Longitude: ' + position.coords.longitude+ '\n');
};

var onError = function onError(error) {
    console.log('code: '    + error.code    + '\n' +
          'message: ' + error.message + '\n');
}

navigator.geolocation.getCurrentPosition(onSuccess, onError);

```

The following screenshot shows how we implemented this code in our simple app:

![Using GeoLocation](https://images.ctfassets.net/23aumh6u8s0i/437Kb1lg8gyZVpYzQ5PSlJ/eca13134279a1eedbe7e1081b27fd82e/using-geolocation)

## Testing your Cordova app

To run your application you will need a device or emulator of the corresponding platform.
Build your application by running the following command:

```
cordova build [platform]
```

If you specify a platform, only that platform will be built, otherwise all added platforms will be built one by one.

The following subsections show instructions to install and set up the iOS and Android emulators.

### Installing an iOS simulator

If you are using a Mac computer, you can install the iOS simulator by running the following command:

```
sudo npm install -g ios-sim

```

### Creating the Android virtual device

Once you have installed the Android SDK and configured the enviroment variables, run the following command to list the available targets:

```
android list targets
```

Note the id number of the desired target and use it in the following command to create the Android virtual device.

```
android create avd --name myCordova --target 1
```

> **Note:** If multiple ABIs are installed for the selected target, you will have to run the command specifying one ABI using the `--abi` parameter. The available ABIs are listed when the `create avd` command fails or using the `android list targets` command.

Try the emulator by running:

```
cordova emulate android
```

![Running the app in Android](https://images.ctfassets.net/23aumh6u8s0i/1YLLNTzZA6SqXceLVbb7Bd/fb20847268e02591dcc5c98d427268bf/android-app)

### Running the app

If the build went well and the emulators are installed, run the following command specifying the desired platform to start the application:

```
cordova run [platform]
```

![Running the app in iOS](https://images.ctfassets.net/23aumh6u8s0i/P7RA31sZiwjIvTcFIbqPl/6ed98753342cd1d21bb50218fbdede69/iphone-app)

## 6 tips for migrating your application

<div class="" style="text-align: center;"><img style="margin: 0; max-width: 250px;" src="https://images.ctfassets.net/23aumh6u8s0i/0dRIaEpjhU5VZa1v3w941/f4a58b68a638442cfcf179d9d6ccffb5/recommendations" alt="Tips for creating your Cordova app" />
</div>

Based on our experience with this type of app, we created the following list of tips for creating your own Cordova apps.

1. **Single Page Apps work better.** Remember that the recommended architecture for Cordova applications is Single-Page Applications (SPAs). This way, all of the resources are only loaded once when the app starts, and can stay in the web view for as long as the application is running. In addition, with SPAs, the user will not have page reloads, which are simply not typical for native applications.

2. **Make your app responsive.** Ensure your app is responsive, in that it adapts gracefully to different devices and resolutions. Using CSS media queries is a good approach for this.

3. **Add smooth transitions when needed.** If your app is not SPA, add transitions when navigating to other pages so the navigation goes unnoticed.

4. **Decide what form factors you will support.** Will you support only mobile phone or tablet form factors, or provide a responsive, universal experience? Just as each platform and platform version will introduce an extra level of effort, each form-factor/breakpoint setting will introduce a new level of effort for designers, developers, and, eventually, testers.

5. **Add Offline Support.** Decide if it is important to add offline support. While some apps don’t require any internet access for normal behavior, some do (hosted apps, for example). Even some particular features of the app may require internet. Consider the user experience of your app when no internet connection is present. For example, some features, such as sharing, can be disabled when offline. You can use the [Cordova Network Information plugin](https://www.npmjs.com/package/cordova-plugin-network-information) to detect the connection type and to handle online and offline detection.

6. **Test on devices.** It is almost mandatory to have at least one physical device for each platform/version that you are supporting. There are emulators and simulators that can help you to test the application and identify some major issues, but nothing is as good as  having a real device for testing.

## Aside: Adding Auth0 to your Cordova App

Auth0 can be easily added to your Cordova application. In a few minutes you can add authentication to your platforms by following these simple steps:

1. Set up the callback URL in Auth0.
2. You must install the **InAppBrowser** plugin from Cordova to be able to show the _Login popup_, and then update the config.xml file.
3. Follow the guide specific to the front-end technology you're using.
4. That's it!

For detailed instructions, browse to the [Auth0 Cordova Tutorial](https://auth0.com/docs/native-platforms/cordova).

## Wrapping up

You can create mobile apps quickly and easily with Cordova, but making a successful Cordova app means that the end user doesn't notice that the app is a wrapped web app. This is very simple if you have a responsive single-page app; if this is not the case, consider tweaking your app to make it look like native apps---that is, add page transitions, handle offline scenarios gracefully, disable navigation to external sites, adding platform-specific icons and splash screens, and so on.


Convert your Web App to a Mobile App with Apache Cordova

eugenio-pace-new-avatar

Pace co-founded Auth0 in early 2013 with CTO and “brother-in-arms” Matias Woloski while living 7,000 miles apart from each other. Since then, Pace has played an instrumental role in growing Auth0 into a leading identity management company that is loved by developers and trusted by global enterprises. He loves traveling and has visited more than 35 countries for business and pleasure. He currently lives in Redmond, Washington with his wife, two sons, and their labrador retriever. In his spare time, he enjoys the outdoors, rowing, riding bikes, spending time with his family, restoring his 1970 Karmann Ghia, writing his blog, and reading history and philosophy.

CEO and Co-Founder

Eugenio Pace

Auth0 SDKs make it really easy to add SSO to any app, on any platform. But sometimes, apps cannot be modified. What to do then? A very simple solution is to

Auth0 [SDKs](https://docs.auth0.com) make it really easy to add [Single Sign On (SSO)](https://resources.auth0.com/definitive-guide-to-single-sign-on/?utm_source=blog) to any app, on any platform. But sometimes, apps cannot be modified. What to do then?

A very simple solution is to front any web content with a web server that itself is capable of negotiating authentication for users. One web server with the extensibility required for plugging-in any auth is Apache server.

In this post, we'll learn how to install and configure `mod_auth_openidc` to work with Apache and Auth0.



##How it works
Apache has [plugable authentication modules](http://httpd.apache.org/docs/current/mod/mod_auth_basic.html#authbasicprovider) that you can use to protect specific routes. One such module is [mod_auth_openidc](https://github.com/pingidentity/mod_auth_openidc) written by [Hans Zandbelt](http://hanszandbelt.wordpress.com/).

> __mod_auth_openidc__ is an authentication/authorization module for the Apache 2.x HTTP server that allows users to authenticate using an OpenID Connect enabled Identity Provider.

When a user first attempts to access protected content behind Apache, the module will first redirect the user to the configured OpenID Connect identity provider. After the user is authenticated, access is granted to the actual resource:

![image](https://images.ctfassets.net/23aumh6u8s0i/4Tz0lvc5MlWvs8ydbEj319/0d3b9e38b264ced1ed6a2f835ad18176/pub_w_811_amp_h_340)

Since Auth0 supports the OpenID Connect protocol (among [many others](https://docs.auth0.com/protocols)), it is straight forward to configure the module with it:

```
OIDCProviderIssuer https://contoso.auth0.com
OIDCProviderAuthorizationEndpoint https://contoso.auth0.com/authorize
OIDCProviderTokenEndpoint https://contoso.auth0.com/oauth/token
OIDCProviderTokenEndpointAuth client_secret_post
OIDCProviderUserInfoEndpoint https://contoso.auth0.com/userinfo

OIDCClientID 3g6d6c..........mXNxkAE
OIDCClientSecret _8sCbkTNhYk4..........8u3mdvRFWBx

OIDCScope "openid email profile"
OIDCRedirectURI https://your_apache_server/example/redirect_uri/
OIDCCryptoPassphrase <password>
OIDCCookiePath /example/

SSLEngine on
SSLCertificateFile /home/your_cert.crt
SSLCertificateKeyFile /home/your_key.key

<Location /example/>
   AuthType openid-connect
   Require valid-user
   LogLevel debug
</Location>
```

##How to configure it

First, you need to [register a new app](https://app.myauth0.com/#/applications/create) in Auth0. You will get a `clientId` and a `clientSecret`. These two go to the `OIDCClientID` and `OIDCClientSecret` params respectively. Then you need to setup SSL certs and define the protected locations (e.g. `/example` in the config file above).

Of course you will have to replace the Auth0 auth URLs with your actual account (__contoso__ is used in the example above).

Any of [Auth0 supported identity providers](https://docs.auth0.com/identityproviders) would work: __Active Directory__, __LDAP__, __ADFS__, __SAML-P__, __custom databases__ or any of the __30+ social providers__. Auth0 will bridge any protocol implemented by these identity systems with OpenID Connect.

It is also very easy to configure a _specific_ connection in Auth0 if you add the `connection` parameter to the `OIDCProviderAuthorizationEndpoint` parameter:

```
OIDCProviderAuthorizationEndpoint https://contoso.auth0.com/authorize?connection=linkedin
```

Users will be sent directly to LinkedIn for authentication in this case.

That's it!

[Want to learn more about Single Sign-On? Get The Definitive Guide on SSO (74-page free eBook) here.](https://resources.auth0.com/definitive-guide-to-single-sign-on/?utm_source=blog)

"apac"