Tutorial: Connect to a managed Eureka Server for Spring in Azure Container Apps

Eureka Server for Spring is a service registry that allows microservices to register themselves and discover other services. Eureka Server for Spring is available as an Azure Container Apps component. You can bind your container app to Eureka Server for Spring for automatic registration with the Eureka server.

In this tutorial, you learn how to:

Prerequisites

• An Azure account with an active subscription. If you don't already have one, you can can create one for free.
• Azure CLI.

Considerations

When you run Eureka Server for Spring in Container Apps, be aware of the following details:

Setup

Before you begin to work with the Eureka Server for Spring component, you first need to create the required resources.

Create the Eureka Server for Spring Java component

Bind your container app to the Eureka Server for Spring Java component

Return to the container app in the portal. Copy the URL of your app to a text editor so that you can use it in an upcoming step.

Go to the /allRegistrationStatus route to view all applications that are registered with the Eureka Server for Spring component.

The binding injects several configurations into the application as environment variables, primarily the eureka.client.service-url.defaultZone property. This property indicates the internal endpoint of the Eureka Server Java component.

The binding also injects the following properties:

"eureka.client.register-with-eureka":    "true"
"eureka.client.fetch-registry":          "true"
"eureka.instance.prefer-ip-address":     "true"

The eureka.client.register-with-eureka property is set to true to enforce registration with the Eureka server. This registration overwrites the local setting in application.properties, from the configuration server and so on. If you want to set it to false, you can overwrite it by setting an environment variable in your container app.

The eureka.instance.prefer-ip-address property is set to true because of the specific domain name system resolution rule in the container app environment. Don't modify this value so that you don't break the binding.

Optional: Unbind your container app from the Eureka Server for Spring Java component

az containerapp update \
    --name $APP_NAME \
    --unbind $JAVA_COMPONENT_NAME \
    --resource-group $RESOURCE_GROUP

View the application through a dashboard

1. Create a custom role definition.

   az role definition create --role-definition '{
       "Name": "<YOUR_ROLE_NAME>",
       "IsCustom": true,
       "Description": "Can access managed Java Component dashboards in managed environments",
       "Actions": [
           "Microsoft.App/managedEnvironments/write"
       ],
       "AssignableScopes": ["/subscriptions/<SUBSCRIPTION_ID>"]
   }'
   

   Make sure to replace the <SUBSCRIPTION_ID> placeholder in the AssignableScopes value with your subscription ID.

2. Assign the custom role to your account on a managed environment resource.

   Get the resource ID of the managed environment:

   export ENVIRONMENT_ID=$(az containerapp env show \
       --name $ENVIRONMENT --resource-group $RESOURCE_GROUP \
       --query id \
       --output tsv)
   

3. Assign the role to your account.

   Before you run this command, replace the placeholders - indicated by the <> brackets - with your user or service principal ID and your role name.

   az role assignment create \
       --assignee <USER_OR_SERVICE_PRINCIPAL_ID> \
       --role "<ROLE_NAME>" \
       --scope $ENVIRONMENT_ID
   

   Note

   The <USER_OR_SERVICE_PRINCIPAL_ID> value usually should be the identity that you use to access the Azure portal. The <ROLE_NAME> value is the name that you assigned in step 1.

4. Get the URL of the Eureka Server for Spring dashboard.

   az containerapp env java-component eureka-server-for-spring show \
       --environment $ENVIRONMENT \
       --resource-group $RESOURCE_GROUP \
       --name $EUREKA_COMPONENT_NAME \
       --query properties.ingress.fqdn \
       --output tsv
   

   This command returns the URL that you can use to access the Eureka Server for Spring dashboard. With the dashboard, you can also see your container app, as shown in the following screenshot.

   

Optional: Integrate the Eureka Server for Spring and Admin for Spring Java components

If you want to integrate the Eureka Server for Spring and the Admin for Spring Java components, see Integrate the managed Admin for Spring with Eureka Server for Spring.

Clean up resources

The resources created in this tutorial have an effect on your Azure bill. If you aren't going to use these services long term, run the following command to remove everything you created in this tutorial.

az group delete --resource-group $RESOURCE_GROUP

Allowed configuration list for your Eureka Server for Spring

The following sections describe the supported configurations. For more information, see Spring Cloud Eureka Server.

Configuration options

The az containerapp update command uses the --configuration parameter to control how the Eureka Server for Spring is configured. You can use multiple parameters at once as long as they're separated by a space. For more information, see Spring Cloud Eureka Server.

The following configuration settings are available on the eureka.server configuration property:

Common configurations

• Logging related configurations:
  • logging.level.*
  • logging.group.*
  • Any other configurations under the logging.* namespace should be forbidden - for example, writing log files by using logging.file should be forbidden.

Call between applications

This example shows you how to write Java code to call between applications registered with the Eureka Server for Spring component. When container apps are bound with Eureka, they communicate with each other through the Eureka server.

The example creates two applications, a caller and a callee. Both applications communicate among each other using the Eureka Server for Spring component. The callee application exposes an endpoint that is called by the caller application.

1. Create the callee application. Enable the Eureka client in your Spring Boot application by adding the @EnableDiscoveryClient annotation to your main class.

   @SpringBootApplication
   @EnableDiscoveryClient
   public class CalleeApplication {
     public static void main(String[] args) {
       SpringApplication.run(CalleeApplication.class, args);
     }
   }
   

2. Create an endpoint in the callee application that is called by the caller application.

   @RestController
   public class CalleeController {
   
       @GetMapping("/call")
       public String calledByCaller() {
           return "Hello from Application callee!";
       }
   }
   

3. Set the callee application's name in the application configuration file - for example, in application.yml.

   spring.application.name=callee
   

4. Create the caller application.

   Add the @EnableDiscoveryClient annotation to enable Eureka client functionality. Also, create a WebClient.Builder bean with the @LoadBalanced annotation to perform load-balanced calls to other services.

   @SpringBootApplication
   @EnableDiscoveryClient
   public class CallerApplication {
     public static void main(String[] args) {
       SpringApplication.run(CallerApplication.class, args);
     }
   
     @Bean
     @LoadBalanced
     public WebClient.Builder loadBalancedWebClientBuilder() {
       return WebClient.builder();
     }
   }
   

5. Create a controller in the caller application that uses the WebClient.Builder to call the callee application using its application name, callee.

   @RestController
   public class CallerController {
       @Autowired
       private WebClient.Builder webClientBuilder;
   
       @GetMapping("/call-callee")
       public Mono<String> callCallee() {
           return webClientBuilder.build()
               .get()
               .uri("http://callee/call")
               .retrieve()
               .bodyToMono(String.class);
       }
   }
   

Now you have a caller and callee application that communicate with each other using Eureka Server for Spring Java components. Make sure both applications are running and bind with the Eureka server before testing the /call-callee endpoint in the caller application.

Limitations

The Eureka Server Java component comes with a default configuration, eureka.server.enable-self-preservation, set to false. This default configuration helps avoid times when instances aren't deleted after self-preservation is enabled. If instances are deleted too early, some requests might be directed to nonexistent instances. If you want to change this setting to true, you can overwrite it by setting your own configurations in the Java component.

Next steps

Related content

Integrate the managed Admin for Spring with Eureka Server for Spring