Merge pull request #303032 from linglingye001/go/quickstart/fix

Update quickstarts

Author: ttorble

articles/azure-app-configuration/enable-dynamic-configuration-gin-web-app.md

@@ -40,7 +40,7 @@ Finish the quickstart: [Create a Gin web app with Azure App Configuration](./qui
     > [!TIP]
     > You can set the `Interval` property of the `RefreshOptions` to specify the minimum time between configuration refreshes. In this example, you use the default value of 30 seconds. Adjust to a higher value if you need to reduce the number of requests made to your App Configuration store.
 
-2. Update your `main.go` file to register a callback function for configuration updates:
+1. Update your `main.go` file to register a callback function for configuration updates:
 
     ```golang
     // Existing code
@@ -59,11 +59,21 @@ Finish the quickstart: [Create a Gin web app with Azure App Configuration](./qui
             return
         }
     })
+
+    // The rest of existing code
+    //... ...
     ```
 
-3. Add a configuration refresh middleware. Update *`main.go`* with the following code.
+1. Add a configuration refresh middleware. Update *`main.go`* with the following code.
 
     ```golang
+    // Existing code
+    // ... ...
+    type App struct {
+        Name      string
+        Port      int
+    }
+
     func configRefreshMiddleware(provider *azureappconfiguration.AzureAppConfiguration) gin.HandlerFunc {
         return func(c *gin.Context) {
             // Start refresh in a goroutine to avoid blocking the request
@@ -79,9 +89,12 @@ Finish the quickstart: [Create a Gin web app with Azure App Configuration](./qui
             c.Next()
         }
     }
+
+    // The rest of existing code
+    //... ...
     ```
 
-4. Use the configuration refresh middleware:
+1. Use the configuration refresh middleware:
 
     ```golang
     // Existing code
@@ -110,20 +123,21 @@ Now that you've set up dynamic configuration refresh, let's test it to see it in
 1. Run the application.
 
    ```bash
-   go run main.go
+    go mod tidy
+    go run .
    ```
 
-2. Open a web browser and navigate to `http://localhost:8080` to access your application. The web page looks like this:
+1. Open a web browser and navigate to `http://localhost:8080` to access your application. The web page looks like this:
 
     :::image type="content" source="./media/quickstarts/gin-app-refresh-before.png" alt-text="Screenshot of the gin web app refresh before.":::
 
-3. Navigate to your App Configuration store and update the value of the `Config.Message` key.
+1. Navigate to your App Configuration store and update the value of the `Config.Message` key.
 
     | Key                    | Value                                  | Content type       |
     |------------------------|----------------------------------------|--------------------|
     | *Config.Message*       | *Hello from Azure App Configuration - now with live updates!*               | Leave empty        |
 
-4. After refreshing the browser a few times, you'll see the updated content once the ConfigMap is updated in 30 seconds.
+1. After refreshing the browser a few times, you'll see the updated content once the ConfigMap is updated in 30 seconds.
 
     :::image type="content" source="./media/quickstarts/gin-app-refresh-after.png" alt-text="Screenshot of the gin web app refresh after.":::
 

articles/azure-app-configuration/enable-dynamic-configuration-go-console-app.md

@@ -41,26 +41,27 @@ In this quickstart, you'll enhance a basic Go console application to dynamically
     > [!TIP]
     > You can set the `Interval` property of the `RefreshOptions` to specify the minimum time between configuration refreshes. In this example, you use the default value of 30 seconds. Adjust to a higher value if you need to reduce the number of requests made to your App Configuration store.
 
-2. Open the file *`unmarshal_sample.go`* and add the following code to your main function:
+2. Open the file *`main.go`* and add the following code to your main function:
 
     ```golang
-    // Existing code in unmarshal_sample.go
+    // Existing code in main.go
     // ... ...
-    fmt.Printf("Timeout: %d seconds\n", config.App.Settings.Timeout)
-    fmt.Printf("Retry Count: %d\n", config.App.Settings.RetryCount)
-
-    // Register refresh callback to update and display the configuration
-    provider.OnRefreshSuccess(func() {
-        // Re-unmarshal the configuration
-        err := appCfgProvider.Unmarshal(&updatedConfig, nil)
-        if err != nil {
-            log.Printf("Error unmarshalling updated configuration: %s", err)
-            return
-        }
-        
-        // Display the updated configuration
-        displayConfig(config)
-    })
+	fmt.Println("\nRaw JSON Configuration:")
+	fmt.Println("------------------------")
+	fmt.Println(string(jsonBytes))
+	
+    // Register refresh callback to update the configuration
+	provider.OnRefreshSuccess(func() {
+		var updatedConfig Config
+		// Re-unmarshal the configuration
+		err := provider.Unmarshal(&updatedConfig, nil)
+		if err != nil {
+			log.Printf("Error unmarshalling updated configuration: %s", err)
+			return
+		}
+
+		fmt.Printf("Message: %s\n", updatedConfig.Message)
+	})
 
     // Setup a channel to listen for termination signals
     done := make(chan os.Signal, 1)
@@ -99,7 +100,8 @@ In this quickstart, you'll enhance a basic Go console application to dynamically
 1. Run your application:
 
    ```bash
-   go run unmarshal_sample.go
+    go mod tidy
+    go run .
    ```
 
 2. Keep the application running.

articles/azure-app-configuration/quickstart-feature-flag-go-console.md

@@ -164,7 +164,8 @@ Add a feature flag called *Beta* to the App Configuration store and leave **Labe
 1. Run the application:
 
     ```console
-    go run main.go
+    go mod tidy
+    go run .
     ```
     ---
 

articles/azure-app-configuration/quickstart-feature-flag-go-gin.md

@@ -243,7 +243,7 @@ Add a feature flag called *Beta* to the App Configuration store and leave **Labe
         betaEnabled := c.GetBool("betaEnabled")
 
         c.HTML(http.StatusOK, "index.html", gin.H{
-            "title":       "Feature Management Demo",
+            "title":       "Feature Management Example App",
             "betaEnabled": betaEnabled,
         })
     }
@@ -311,7 +311,8 @@ Add a feature flag called *Beta* to the App Configuration store and leave **Labe
 1. [Set the environment variable for authentication](./quickstart-go-web-app.md#run-the-web-application) and run the application.
 
     ```console
-    go run main.go
+    go mod tidy
+    go run .
     ```
 
 1. Open a browser window, and go to `http://localhost:8080`. Your browser should display a page similar to the image below.

articles/azure-app-configuration/quickstart-go-console-app.md

@@ -68,16 +68,14 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"log"
 	"os"
-	"time"
 
 	"github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
 	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
 )
 
-func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.Azureappconfiguration, error) {
+func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
 	// Get the endpoint from environment variable
 	endpoint := os.Getenv("AZURE_APPCONFIG_ENDPOINT")
 	if endpoint == "" {
@@ -124,15 +122,13 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"log"
 	"os"
-	"time"
 
 	"github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
 )
 
-func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.Azureappconfiguration, error) {
+func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
 	// Get the connection string from environment variable
 	connectionString := os.Getenv("AZURE_APPCONFIG_CONNECTION_STRING")
 	if connectionString == "" {
@@ -171,7 +167,7 @@ func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.Azur
 
 The `Unmarshal` method provides a type-safe way to load configuration values into Go structs. This approach prevents runtime errors from mistyped configuration keys and makes your code more maintainable. `Unmarshal` is particularly valuable for complex configurations with nested structures, different data types, or when working with microservices that require clear configuration contracts across components.
 
-Create a file named `unmarshal_sample.go` with the following content:
+Create a file named `main.go` with the following content:
 
 ```golang
 package main
@@ -183,7 +179,6 @@ import (
 	"time"
 )
 
-// Configuration structure that matches your key-values in App Configuration
 type Config struct {
 	Message string
 	App     struct {
@@ -228,30 +223,13 @@ func main() {
 
 The `GetBytes` method retrieves your configuration as raw JSON data, offering a flexible alternative to struct binding. This approach seamlessly integrates with existing JSON processing libraries like the standard `encoding/json` package or configuration frameworks such as [`viper`](https://github.com/spf13/viper). It's particularly useful when working with dynamic configurations, when you need to store configuration temporarily, or when integrating with existing systems that expect JSON input. Using GetBytes gives you direct access to your configuration in a universally compatible format while still benefiting from Azure App Configuration's centralized management capabilities.
 
-Create a file named `getbytes_sample.go` with the following content:
+Update `main.go` with the following content:
 
 ```golang
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"time"
-	
-	"github.com/spf13/viper"
-)
-
-func main() {
-	// Create a context with timeout
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
-	// Load configuration using the common function
-	provider, err := loadAzureAppConfiguration(ctx)
-	if err != nil {
-		log.Fatalf("Error loading configuration: %v", err)
-	}
+	// Existing code in main.go
+	// ... ...
+	fmt.Printf("Timeout: %d seconds\n", config.App.Settings.Timeout)
+	fmt.Printf("Retry Count: %d\n", config.App.Settings.RetryCount)
 
 	// Get configuration as JSON bytes
 	jsonBytes, err := provider.GetBytes(nil)
@@ -274,7 +252,6 @@ func main() {
 
 	// Use viper to access your configuration
 	// ...
-}
 ```
 
 ## Run the application
@@ -331,10 +308,11 @@ func main() {
     
     ---
 
-2. After the environment variable is properly set, run the following command to run the *Unmarshal* example:
+2. After the environment variable is properly set, run the following command to run the *Unmarshal* and *GetBytes* example:
 
     ```bash
-    go run unmarshal_sample.go
+    go mod tidy
+    go run .
     ```
 
     You should see output similar to the following:
@@ -347,17 +325,7 @@ func main() {
     Debug Mode: true
     Timeout: 30 seconds
     Retry Count: 3
-    ```
-
-3. Run the *GetBytes* example:
-
-    ```bash
-    go run getbytes_sample.go
-    ```
-
-    You should see output similar to the following:
 
-    ```Output
     Raw JSON Configuration:
     ------------------------
     {"App":{"Debug":true,"Name":"Go Console App","Settings":{"retryCount":3,"timeout":30}},"Message":"Hello World!"}

articles/azure-app-configuration/quickstart-go-web-app.md

@@ -119,16 +119,14 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"log"
 	"os"
-	"time"
 
 	"github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
 	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
 )
 
-func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.Azureappconfiguration, error) {
+func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
 	// Get the endpoint from environment variable
 	endpoint := os.Getenv("AZURE_APPCONFIG_ENDPOINT")
 	if endpoint == "" {
@@ -175,15 +173,13 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"log"
 	"os"
-	"time"
 
 	"github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
 )
 
-func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.Azureappconfiguration, error) {
+func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
 	// Get the connection string from environment variable
 	connectionString := os.Getenv("AZURE_APPCONFIG_CONNECTION_STRING")
 	if connectionString == "" {
@@ -343,7 +339,8 @@ func main() {
 2. Run the application. 
 
     ```bash
-    go run main.go
+    go mod tidy
+    go run .
     ```
 
     You should see output similar to this: