Insert explicit ids for headers

docs/modules/ROOT/pages/adapters/aws-intro.adoc

@@ -1,5 +1,6 @@
 :branch: master
 
+[[aws-lambda]]
 === AWS Lambda
 
 The https://aws.amazon.com/[AWS] adapter takes a Spring Cloud Function app and converts it to a form that can run in AWS Lambda.
@@ -7,6 +8,7 @@ The https://aws.amazon.com/[AWS] adapter takes a Spring Cloud Function app and c
 The details of how to get stared with AWS Lambda is out of scope of this document, so the expectation is that user has some familiarity with
 AWS and AWS Lambda and wants to learn what additional value spring provides.
 
+[[getting-started]]
 ==== Getting Started
 
 One of the goals of Spring Cloud Function framework is to provide necessary infrastructure elements to enable a _simple function application_
@@ -56,6 +58,7 @@ isolating you from the specifics of AWS Lambda API, for some cases you may want
 to use. The next section will explain you how you can accomplish just that.
 
 
+[[aws-request-handlers]]
 ==== AWS Request Handlers
 
 The adapter has a couple of generic request handlers that you can use. The most generic is (and the one we used in the Getting Started section)
@@ -69,6 +72,7 @@ property or environment variable. The functions are extracted from the Spring Cl
 the framework will attempt to find a default following the search order where it searches first for `Function` then `Consumer` and finally `Supplier`).
 
 
+[[aws-function-routing]]
 ==== AWS Function Routing
 
 One of the core features of Spring Cloud Function is https://docs.spring.io/spring-cloud-function/docs/{project-version}/reference/html/spring-cloud-function.html#_function_routing_and_filtering[routing] 
@@ -90,10 +94,12 @@ Also, note that since AWS does not allow dots `.` and/or hyphens`-` in the name
 dots with underscores and hyphens with camel case.  So for example `spring.cloud.function.definition` becomes `spring_cloud_function_definition`
 and `spring.cloud.function.routing-expression` becomes `spring_cloud_function_routingExpression`. 
 
+[[aws-function-routing-with-custom-runtime]]
 ===== AWS Function Routing with Custom Runtime
 
 When using <<Custom Runtime>> Function Routing works the same way. All you need is to specify `functionRouter` as AWS Handler the same way you would use the name of the function as handler. 
 
+[[notes-on-jar-layout]]
 ==== Notes on JAR Layout
 
 You don't need the Spring Cloud Function Web or Stream adapter at runtime in Lambda, so you might
@@ -158,12 +164,14 @@ then additional transformers must be configured as part of the maven-shade-plugi
 </plugin>
 ----
 
+[[build-file-setup]]
 ==== Build file setup
 
 In order to run Spring Cloud Function applications on AWS Lambda, you can leverage Maven or Gradle
  plugins offered by the cloud platform provider.
 
 
+[[maven]]
 ===== Maven
 
 In order to use the adapter plugin for Maven, add the plugin dependency to your `pom.xml`
@@ -202,6 +210,7 @@ You can use the Spring Boot Maven Plugin to generate the <<thin-jar>>.
 You can find the entire sample `pom.xml` file for deploying Spring Cloud Function
 applications to AWS Lambda with Maven https://github.com/spring-cloud/spring-cloud-function/blob/{branch}/spring-cloud-function-samples/function-sample-aws/pom.xml[here].
 
+[[gradle]]
 ===== Gradle
 
 In order to use the adapter plugin for Gradle, add the dependency to your `build.gradle` file:
@@ -270,6 +279,7 @@ assemble.dependsOn = [thinJar]
 You can find the entire sample `build.gradle` file for deploying Spring Cloud Function
 applications to AWS Lambda with Gradle https://github.com/spring-cloud/spring-cloud-function/blob/{branch}/spring-cloud-function-samples/function-sample-aws/build.gradle[here].
 
+[[upload]]
 ==== Upload
 
 Build the sample under `spring-cloud-function-samples/function-sample-aws` and upload the `-aws` jar file to Lambda. The handler can be `example.Handler` or `org.springframework.cloud.function.adapter.aws.SpringBootStreamHandler` (FQN of the class, _not_ a method reference, although Lambda does accept method references).
@@ -295,6 +305,7 @@ The input type for the function in the AWS sample is a Foo with a single propert
 NOTE: The AWS sample app is written in the "functional" style (as an `ApplicationContextInitializer`). This is much faster on startup in Lambda than the traditional `@Bean` style, so if you don't need `@Beans` (or `@EnableAutoConfiguration`) it's a good choice. Warm starts are not affected.
 
 
+[[type-conversion]]
 ==== Type Conversion
 
 Spring Cloud Function will attempt to transparently handle type conversion between the raw
@@ -306,6 +317,7 @@ incoming stream event to an instance of `Foo`.
 In the event type is not known or can not be determined (e.g., `Function<?, ?>`) we will attempt to
 convert an incoming stream event to a generic `Map`.
 
+[[raw-input]]
 ====== Raw Input
 
 There are times when you may want to have access to a raw input. In this case all you need is to declare your

docs/modules/ROOT/pages/adapters/aws.adoc

@@ -3,10 +3,12 @@
 
 The https://aws.amazon.com/[AWS] adapter takes a Spring Cloud Function app and converts it to a form that can run in AWS Lambda.
 
+[[introduction]]
 == Introduction
 
 include::adapters/aws-intro.adoc[]
 
+[[functional-bean-definitions]]
 == Functional Bean Definitions
 
 Your functions will start much quicker if you can use functional bean definitions instead of `@Bean`. To do this make your main class
@@ -37,6 +39,7 @@ public class FuncApplication implements ApplicationContextInitializer<GenericApp
 }
 ```
 
+[[aws-context]]
 == AWS Context
 
 In a typical implementation of AWS Handler user has access to AWS _context_ object. With function approach you can have the same experience if you need it.
@@ -44,8 +47,10 @@ Upon each invocation the framework will add `aws-context` message header contain
 you can simply have `Message<YourPojo>` as an input parameter to your function and then access `aws-context` from message headers. 
 For convenience we provide AWSLambdaUtils.AWS_CONTEXT constant.
 
+[[platform-specific-features]]
 == Platform Specific Features
 
+[[http-and-api-gateway]]
 === HTTP and API Gateway
 
 AWS has some platform-specific data types, including batching of messages, which is much more efficient than processing each one individually. To make use of these types you can write a function that depends on those types. Or you can rely on Spring to extract the data from the AWS types and convert it to a Spring `Message`. To do this you tell AWS that the function is of a specific generic handler type (depending on the AWS service) and provide a bean of type `Function<Message<S>,Message<T>>`, where `S` and `T` are your business data types. If there is more than one bean of type `Function` you may also need to configure the Spring Boot property `function.name` to be the name of the target bean (e.g. use `FUNCTION_NAME` as an environment variable).
@@ -62,6 +67,7 @@ The supported AWS services and generic handler types are listed below:
 
 For example, to deploy behind an API Gateway, use `--handler org.springframework.cloud.function.adapter.aws.SpringBootApiGatewayRequestHandler` in your AWS command line (in via the UI) and define a `@Bean` of type `Function<Message<Foo>,Message<Bar>>` where `Foo` and `Bar` are POJO types (the data will be marshalled and unmarshalled by AWS using Jackson).
 
+[[custom-runtime]]
 == Custom Runtime
 
 You can also benefit from https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html[AWS Lambda custom runtime] feature of AWS Lambda 

docs/modules/ROOT/pages/adapters/azure-intro.adoc

@@ -1,5 +1,6 @@
 :branch: master
 
+[[microsoft-azure-functions]]
 == Microsoft Azure Functions
 :sectnums:
 
@@ -19,10 +20,12 @@ With the Azure Web Adapter you can deploy any Spring Web application as an Azure
 This adapter hides the Azure annotations complexity and uses the familiar https://docs.spring.io/spring-boot/docs/current/reference/html/web.html[Spring Web] programming model instead.
 For further information follow the <<azure.web.adapter,Azure Web Adapter>> section below.
 
+[[azure-adapter]]
 == Azure Adapter
 
 Provides `Spring` & `Spring Cloud Function` integration for Azure Functions.
 
+[[dependencies]]
 === Dependencies
 
 In order to enable the Azure Function integration add the azure adapter dependency to your `pom.xml` or `build.gradle`
@@ -127,6 +130,7 @@ public class HttpTriggerDemoApplication {
 <1> The `@SpringBootApplication` annotated class is used as a `Main-Class` as explained in <<star-class-configuration, main class configuration>>.
 <2> Functions auto-wired and used in the Azure function handlers.
 
+[[function-catalog]]
 ==== Function Catalog
 
 The Spring Cloud Function supports a range of type signatures for user-defined functions, while providing a consistent execution model.
@@ -137,6 +141,7 @@ But those are treated as plain Java class instances, not as a canonical Spring C
 
 To leverage Spring Cloud Function and have access to the canonical function representations, you need to auto-wire the `FunctionCatalog` and use it in your handler, like the `functionCatalog` instance the `springCloudFunction()` handler above.
 
+[[accessing-azure-executioncontext]]
 ==== Accessing Azure ExecutionContext
 
 Some time there is a need to access the target execution context provided by the Azure runtime in the form of `com.microsoft.azure.functions.ExecutionContext`.
@@ -186,6 +191,7 @@ Usually the Azure Maven (or Gradle) plugins are used to generate the necessary c
 IMPORTANT: The Azure https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-java?tabs=bash%2Cconsumption#folder-structure[packaging format] is not compatible with the default Spring Boot packaging (e.g. `uber jar`).
 The <<disable.spring.boot.plugin,Disable Spring Boot Plugin>> section below explains how to handle this.
 
+[[azure-maven/gradle-plugins]]
 ==== Azure Maven/Gradle Plugins
 
 Azure provides https://github.com/microsoft/azure-maven-plugins/tree/develop/azure-functions-maven-plugin[Maven] and https://github.com/microsoft/azure-gradle-plugins/tree/master/azure-functions-gradle-plugin[Gradle] plugins to process the annotated classes, generate the necessary configurations and produce the expected package layout.
@@ -327,6 +333,7 @@ For local runs, add the `MAIN_CLASS` variable to your `local.settings.json` file
 
 IMPORTANT: If the `MAIN_CLASS` variable is not set, the Azure adapter lookups the `MANIFEST/META-INFO` attributes from the jars found on the classpath and selects the first `Main-Class:` annotated with either a `@SpringBootApplication` or `@SpringBootConfiguration` annotation.
 
+[[metadata-configuration]]
 ==== Metadata Configuration
 
 You can use a shared https://learn.microsoft.com/en-us/azure/azure-functions/functions-host-json[host.json] file to configure the function app.
@@ -346,6 +353,7 @@ The host.json metadata file contains configuration options that affect all funct
 
 TIP: If the file is not in the project top folder you need to configure your plugins accordingly (like `hostJson` maven attribute).
 
+[[samples]]
 === Samples
 
 Here is a list of various Spring Cloud Function Azure Adapter samples you can explore:
@@ -389,6 +397,7 @@ dependencies {
 The same <<azure.configuration, Configuration>> and <<azure.usage,Usage>> instructions apply to the `Azure Web Adapter` as well.
 
 
+[[samples]]
 === Samples
 
 For further information, explore the following, Azure Web Adapter, sample:
@@ -400,6 +409,7 @@ For further information, explore the following, Azure Web Adapter, sample:
 
 Common instructions for building and deploying both, `Azure Adapter` and `Azure Web Adapter` type of applications.
 
+[[build]]
 === Build
 
 ====
@@ -416,6 +426,7 @@ Common instructions for building and deploying both, `Azure Adapter` and `Azure
 ----
 ====
 
+[[running-locally]]
 === Running locally
 
 To run locally on top of `Azure Functions`, and to deploy to your live Azure environment, you will need `Azure Functions Core Tools` installed along with the Azure CLI (see https://docs.microsoft.com/en-us/azure/azure-functions/create-first-function-cli-java?tabs=bash%2Cazure-cli%2Cbrowser#configure-your-local-environment[here]).
@@ -437,6 +448,7 @@ Then run the sample:
 ----
 ====
 
+[[running-on-azure]]
 === Running on Azure
 
 Make sure you are logged in your Azure account.
@@ -461,6 +473,7 @@ and deploy
 ----
 ====
 
+[[debug-locally]]
 === Debug locally
 
 Run the function in debug mode.
@@ -516,12 +529,14 @@ Here is snippet for a `VSCode` remote debugging configuration:
 }
 ----
 
+[[functioninvoker-deprecated]]
 == FunctionInvoker (deprecated)
 
 WARNING: The legacy `FunctionInvoker` programming model is deprecated and will not be supported going forward.
 
 For additional documentation and samples about the Function Integration approach follow the https://github.com/spring-cloud/spring-cloud-function/tree/main/spring-cloud-function-samples/function-sample-azure/[azure-sample] README and code.
 
+[[relevant-links]]
 == Relevant Links
 
 - https://learn.microsoft.com/en-us/azure/developer/java/spring-framework/getting-started-with-spring-cloud-function-in-azure[Spring Cloud Function in Azure]
@@ -530,4 +545,4 @@ For additional documentation and samples about the Function Integration approach
 - https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-java?tabs=bash%2Cconsumption[Azure Functions Java developer guide]
 - https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference?tabs=blob[Azure Functions developer guide]
 
-:sectnums!:
+:sectnums!:

docs/modules/ROOT/pages/adapters/gcp-intro.adoc

@@ -1,10 +1,12 @@
 :branch: master
 
+[[google-cloud-functions]]
 === Google Cloud Functions
 
 The Google Cloud Functions adapter enables Spring Cloud Function apps to run on the https://cloud.google.com/functions[Google Cloud Functions] serverless platform.
 You can either run the function locally using the open source https://github.com/GoogleCloudPlatform/functions-framework-java[Google Functions Framework for Java] or on GCP.
 
+[[project-dependencies]]
 ==== Project Dependencies
 
 Start by adding the `spring-cloud-function-adapter-gcp` dependency to your project.
@@ -62,10 +64,12 @@ NOTE: The function target should always be set to `org.springframework.cloud.fun
 
 A full example of a working `pom.xml` can be found in the https://github.com/spring-cloud/spring-cloud-function/blob/master/spring-cloud-function-samples/function-sample-gcp-http/pom.xml[Spring Cloud Functions GCP sample].
 
+[[http-functions]]
 ==== HTTP Functions
 
 Google Cloud Functions supports deploying https://cloud.google.com/functions/docs/writing/http[HTTP Functions], which are functions that are invoked by HTTP request. The sections below describe instructions for deploying a Spring Cloud Function as an HTTP Function.
 
+[[getting-started]]
 ===== Getting Started
 
 Let’s start with a simple Spring Cloud Function example:
@@ -106,6 +110,7 @@ Invoke the HTTP function:
 curl http://localhost:8080/ -d "hello"
 ----
 
+[[deploy-to-gcp]]
 ===== Deploy to GCP
 
 Start by packaging your application.
@@ -158,6 +163,7 @@ public Function<String, Message<String>> function() {
 
 
 
+[[background-functions]]
 ==== Background Functions
 
 Google Cloud Functions also supports deploying https://cloud.google.com/functions/docs/writing/background[Background Functions] which are invoked indirectly in response to an event, such as a message on a https://cloud.google.com/pubsub[Cloud Pub/Sub] topic, a change in a https://cloud.google.com/storage[Cloud Storage] bucket, or a https://firebase.google.com/[Firebase] event.
@@ -167,6 +173,7 @@ The `spring-cloud-function-adapter-gcp` allows for functions to be deployed as b
 The sections below describe the process for writing a Cloud Pub/Sub topic background function.
 However, there are a number of different event types that can trigger a background function to execute which are not discussed here; these are described in the https://cloud.google.com/functions/docs/calling[Background Function triggers documentation].
 
+[[getting-started]]
 ===== Getting Started
 
 Let’s start with a simple Spring Cloud Function which will run as a GCF background function:
@@ -259,6 +266,7 @@ curl localhost:8080 -H "Content-Type: application/json" -d '{"data":"hello"}'
 
 Verify that the function was invoked by viewing the logs.
 
+[[deploy-to-gcp]]
 ===== Deploy to GCP
 
 In order to deploy your background function to GCP, first package your application.
@@ -287,6 +295,7 @@ Google Cloud Function will now invoke the function every time a message is publi
 
 For a walkthrough on testing and verifying your background function, see the instructions for running the https://github.com/spring-cloud/spring-cloud-function/tree/master/spring-cloud-function-samples/function-sample-gcp-background/[GCF Background Function sample].
 
+[[sample-functions]]
 ==== Sample Functions
 
 The project provides the following sample functions as reference: