App and deployment in Azure Spring Apps

App and Deployment are the two key concepts in the resource model of Azure Spring Apps. In Azure Spring Apps, an App is an abstraction of one business app. One version of code or binary deployed as the App runs in a Deployment. Apps run in an Azure Spring Apps service instance, or simply service instance, as shown next.

You can have multiple service instances within a single Azure subscription, but the Azure Spring Apps Service is easiest to use when all of the Apps that make up a business app reside within a single service instance. One reason is that the Apps are likely to communicate with each other. They can easily do that by using Eureka service registry in the service instance.

The Azure Spring Apps Standard plan allows one App to have one production deployment and one staging deployment, so that you can do blue/green deployment on it easily.

App

The following features/properties are defined on app level.

Deployment

The following features/properties are defined on the deployment level, and are exchanged when swapping the production and staging deployment.

Environment

Azure Spring Apps mounts some read-only YAML files to your deployed apps. These files contain the Azure context of a deployment. The following list shows the paths and contents of these YAML files:

• /etc/azure-spring-cloud/context/azure-spring-apps.yml

  AZURE_SPRING_APPS:
      SUBSCRIPTION_ID:  <your-azure-subscription-id>
      RESOURCE_GROUP: <your-resource-group-name>
      NAME: <your-azure-spring-apps-name>
  

• /etc/azure-spring-cloud/context/azure-spring-apps-deployment.yml

  AZURE_SPRING_APPS:
       APP:
          NAME: <your-app-name>
       DEPLOYMENT:
          NAME: <your-deployment-name>
          ACTIVE: true # true if the deployment is in production, false if in staging
  

If your app is a Spring Boot app, these two file paths are added to the SPRING_CONFIG_ADDITIONAL_LOCATION environment variable. This way, your app can load these properties as configurations and use them in your code. For example, you can use the @ConfigurationProperties annotation to bind the YAML properties to a Java class. The following code snippet shows how to create a @Configuration class that represents the Azure context:

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "azure-spring-apps")
@Data
public class AzureSpringAppsContext {

    private String subscriptionId;
    private String resourceGroup;
    private String name;

    private AppContext app;
    private DeploymentContext deployment;

    @Data
    public static class AppContext {
        private String name;
    }

    @Data
    public static class DeploymentContext {
        private String name;
        private boolean active;
    }
}

For any other polyglot apps, you may need to read and access corresponding properties by using the corresponding file read/write libraries in your apps.

Restrictions

• An app must have one production deployment. The API blocks the deletion of a production deployment. You should swap a deployment to staging before deleting it.
• An app can have at most two deployments. The API blocks the creation of more than two deployments. Deploy your new binary to either the existing production or staging deployment.
• Deployment management isn't available in the Basic plan. Use the Standard for blue-green deployment capability.

Next steps

• Set up a staging environment in Azure Spring Apps