Menu
A practical guide to Google Cloud's Parameter Manager

GCP – A practical guide to Google Cloud’s Parameter Manager

,

Every development team wants to build robust, secure, and scalable cloud applications, and that often means navigating complexity — especially when it comes to configuration management. Relying on hard-coded configurations and keys is a common practice that can expose sensitive security details. To move faster and stay secure, developers should use a centralized, secure service dedicated to managing application configurations.

Google Cloud’s solution is our Parameter Manager, designed to reduce unnecessarily sharing key cloud configurations, such as API keys, database passwords, and private encryption keys. Parameter Manager works with many types of data formats, including JSON, YAML, and other unformatted data.

It also includes format validation for JSON and YAML types to help eliminate concerns about configuration integrity. Parameter Manager also integrates with Secret Manager, to help ensure confidential data remains secure and separate.

How to use Parameter Manager

To help illustrate how easy and beneficial it can be to use Parameter Manager, we’ll guide you through a practical example: Building a simple weather application you can configure dynamically, including changing between Celsius and Fahrenheit, updating the default city, and managing your API key.

Here’s what we’ll cover:

  1. Obtaining a Weather API Key and securely storing it in Secret Manager.

  2. Creating a Parameter and Version to reference your API Key and hold other relevant parameters.

  3. Building a Simple UI and Backend that interacts with Parameter Manager.

To complete this project, you should have an active Google Cloud project. Here’s the Code Repository for your reference.

1. Obtaining a Weather API Key and storing it securely in Secret Manager

Use any weather API Key here.

Enable the Secret Manager and Parameter Manager APIs from the console. Both have monthly free tiers that should suffice for this walkthrough.

1. Secret Manager and Parameter Manager home page

Secret Manager and Parameter Manager home page.

Since the API Key is sensitive, store it in Secret Manager.

  • In the Google Cloud Console, search for “Secret Manager”.

  • Click on the “Create Secret” button.

  • On the creation form:

  • Define the secret name (such as weather-api-key.)

  • Paste your weather API Key into the “Secret value” section.

  • For this demo, use the default options. Feel free to explore other settings in the documentation if you wish.

  • Click “Create Secret.”

2. Storing Weather API key in Secret Manager

Storing Weather API key in Secret Manager

You’ve now created a Secret resource with a Secret Version containing your API Key. The interface will display its unique identifier, which will look something like this:

projects/<your-project>/secrets/weather-api-key

Copy this identifier. We’ll use it when creating our Parameter.

3. Copying Weather API key identifier

Copying Weather API key identifier.

2. Creating a Parameter and Version to reference your API Key and hold other relevant parameters

Access Parameter Manager from the Secret Manager home screen or by searching for it in the console.

4. Accessing Parameter Manager from Secret Manager console

Accessing Parameter Manager from the Secret Manager console.

Click on the “Create parameter” button.

5. Creating a parameter

Creating a parameter.

On the creation form:

  • Define the parameter name (such as my-weather-demo-parameter.)

  • Select “YAML” as the format type (Parameter Manager offers format validation for JSON and YAML formats) and submit the form.

  • As earlier, we’ll use the defaults for other options for this demo.

6. Parameter creation form

Parameter creation form.

Parameters offer the advantage of versioning, where each version captures a distinct snapshot of your configuration. This immutability is vital for safeguarding deployed applications against unintended breaking changes. When updates are necessary, a new version can be easily created. 

Create a new version for this Parameter by clicking on “New Version”.

7. Creating a parameter version

Creating a parameter version.

  • Provide a “Name” for your Parameter Version (such as v1 for your initial application version.) Pro tip: Iterate your version numbers to keep track of different versions.

  • In the payload section, paste the following YAML. Crucially, replace <your-project-number> with your actual Google Cloud project number and ensure the apiKey attribute correctly references your Secret Manager Secret’s identifier.

code_block
<ListValue: [StructValue([(‘code’, “version: ‘v1’rnapiKey: ‘__REF__(//secretmanager.googleapis.com/projects/<your-project-number>/secrets/weather-api-key/versions/1)’rnfahrenheit: falserndefaultLocation: ‘London’rnshowHumidity: falsern# dummy values, useful when the app is not connected to internet after going live & loading this config or when the weather API is downrndummyData:rn- rn city: ‘London’rn temperature: ’15°C’rn description: ‘Partly Cloudy’rn humidity: ‘70%’rn windSpeed: ’10 km/h’rn icon: ‘http://openweathermap.org/img/wn/02d@2x.png’rn- rn city: ‘New York’rn temperature: ’22°C’rn description: ‘Sunny’rn humidity: ‘55%’rn windSpeed: ’12 km/h’rn icon: ‘http://openweathermap.org/img/wn/03d@2x.png’rn-rn city: ‘Tokyo’rn temperature: ’28°C’rn description: ‘Clear Sky’rn humidity: ‘60%’rn windSpeed: ‘8 km/h’rn icon: ‘http://openweathermap.org/img/wn/04n@2x.png’rn-rn city: ‘Paris’rn temperature: ’18°C’rn description: ‘Light Rain’rn humidity: ‘85%’rn windSpeed: ’15 km/h’rn icon: ‘http://openweathermap.org/img/wn/04d@2x.png’rn-rn city: ‘Sydney’rn temperature: ’20°C’rn description: ‘Mostly Sunny’rn humidity: ‘65%’rn windSpeed: ‘9 km/h’rn icon: ‘http://openweathermap.org/img/wn/04n@2x.png'”), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f6220cbebe0>)])]>

Submit the form after specifying the above payload data.

8. Parameter version creation form

Parameter version creation form.

Key Point: Notice the __REF__ syntax for the apiKey. This is how Parameter Manager securely references data from Secret Manager:__REF__(//secretmanager.googleapis.com/projects/<your-project-number>/secrets/<secret-id>/versions/<version-id>)

You can also use the special alias “latest” instead of a specific version ID to always retrieve the most recently created Secret Version. (Learn more about Secret references in Parameter Manager documentation).

9. IAM principal identifier for a parameter

IAM principal identifier for a parameter.

For Parameter Manager to successfully resolve the Secret Manager reference, it needs permission to access your secret.

  • Navigate back to your Parameter’s list view and click on your newly created Parameter.

  • Go to the “Overview” section. Copy the “IAM Principal Identifier.” This is a unique service account associated with your Parameter.

  • Now, navigate back to your Secret Manager service and open the secret you created.

  • Go to the “Permissions” section and click “Grant Access.”

  • In the “New principals” field, paste the IAM Principal Identifier you copied from Parameter Manager.

  • Select the role “Secret Manager Secret Accessor.”

  • Click “Save.”

This step authorizes all Parameter Versions created under the Parameter to securely access and resolve the secret containing your API Key.

10. Granting Secret access permissions to Parameter’s IAM principal identifier

Granting Secret access permissions to Parameter’s IAM principal identifier.

Let’s confirm everything is set up correctly. Navigate to the Parameter Version you just created and click on “Render” from the “Actions”  menu.

11. Testing Secret References are working by performing a render operation

Testing Secret References are working by performing a render operation.

If your permissions are correctly configured, Parameter Manager will display the “Rendered output,” which will include your actual weather API Key securely retrieved from Secret Manager! This confirms your configuration is ready to be consumed by your application.

12. Verifying secret substitution in rendered output

Verifying secret substitution in rendered output.

Building a simple UI and backend that can talk to Parameter Manager

Now that our configurations are securely stored and managed, let’s build a simple application to consume them. We’ll create a React frontend and a Node.js backend.

code_block
<ListValue: [StructValue([(‘code’, ‘npx create-react-app parameter-manager-weather-apprncd parameter-manager-weather-apprnnpm install axios’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f621f2f5700>)])]>

Make sure your src/index.js looks something like:

code_block
<ListValue: [StructValue([(‘code’, “import React from ‘react’;rnimport ReactDOM from ‘react-dom/client’;rnimport ‘./index.css’;rnimport App from ‘./App’;rnimport reportWebVitals from ‘./reportWebVitals’;rnrnconst root = ReactDOM.createRoot(document.getElementById(‘root’));rnroot.render(rn <React.StrictMode>rn <App />rn </React.StrictMode>rn);rnrn// If you want to start measuring performance in your app, pass a functionrn// to log results (for example: reportWebVitals(console.log))rn// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitalsrnreportWebVitals();”), (‘language’, ‘lang-py’), (‘caption’, <wagtail.rich_text.RichText object at 0x7f621f2f5910>)])]>

Now, edit your src/App.js with the following code:

code_block
<ListValue: [StructValue([(‘code’, ‘import ‘./App.css’;rnimport React, { useState } from ‘react’;rnimport axios from ‘axios’;rnrnfunction App() {rn // State for the city input by the userrn const [city, setCity] = useState(”);rn // State for the weather data fetchedrn const [weatherData, setWeatherData] = useState(null);rn // State for loading indicatorrn const [loading, setLoading] = useState(false);rn // State for error messagesrn const [error, setError] = useState(”);rnrn // Function to simulate fetching weather datarn const fetchWeather = async (searchCity) => {rn setLoading(true); // Set loading to true when fetching startsrn setError(”); // Clear any previous errorsrn setWeatherData(null); // Clear previous weather datarnrn try {rn // Make Axios GET request to your Node.js backend serverrn const response = await axios.get(`http://localhost:5001/api/weather`, {rn params: {rn city: searchCityrn }rn });rnrn // Assuming your backend sends back data in a format like:rn // { city: ‘London’, temperature: ’15°C’, description: ‘Partly Cloudy’, humidity: ‘70%’, windSpeed: ’10 km/h’, icon: ‘…’ }rn setWeatherData(response.data);rn console.log(response.data)rn } catch (err) {rn console.error(‘Error fetching weather from backend:’, err);rn // Handle different error responses from the backendrn if (err.response && err.response.data && err.response.data.message) {rn setError(`Error: ${err.response.data.message}`);rn } else {rn setError(‘Failed to fetch weather data. Please ensure the backend server is running and try again.’);rn }rn } finally {rn setLoading(false); // Set loading to false once fetching is completern }rn };rnrn // Handle form submissionrn const handleSubmit = (e) => {rn e.preventDefault(); // Prevent default form submission behaviorrn if (city.trim()) { // Only fetch if city input is not emptyrn fetchWeather(city.trim());rn } else {rn setError(‘Please enter a city name.’);rn }rn };rnrn return (rn <div className=”min-h-screen bg-gradient-to-br from-blue-400 to-purple-600 flex items-center justify-center p-4 font-sans”>rn <div className=”bg-white bg-opacity-90 backdrop-filter backdrop-blur-lg rounded-2xl shadow-xl p-8 w-full max-w-md transform transition-all duration-300 hover:scale-105″>rn <h1 className=”text-4xl font-extrabold text-gray-800 mb-6 text-center”>rn Weather Apprn {(weatherData && weatherData.offline) && (rn <div className=”bg-red-100 border border-red-400 text-red-700 px-4 py-3 rounded-xl relative mb-4″ role=”alert”>rn <strong className=”font-bold”>Weather API is offline! showing dummy data from a default location.</strong>rn <span className=”block sm:inline ml-2″>{error}</span>rn </div>rn )}rn </h1>rnrn {/* City Search Form */}rn <form onSubmit={handleSubmit} className=”flex flex-col sm:flex-row gap-4 mb-8″>rn <inputrn type=”text”rn value={city}rn onChange={(e) => setCity(e.target.value)}rn placeholder=”Enter city name (e.g., London)”rn className=”flex-grow p-3 rounded-xl border border-gray-300 focus:ring-2 focus:ring-blue-500 focus:border-transparent outline-none text-gray-700″rn />rn <buttonrn type=”submit”rn className=”bg-blue-600 hover:bg-blue-700 text-white font-bold py-3 px-6 rounded-xl shadow-md transition-all duration-200 ease-in-out transform hover:-translate-y-1 hover:scale-105 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-opacity-75″rn disabled={loading} // Disable button while loadingrn >rn {loading ? ‘Searching…’ : ‘Get Weather’}rn </button>rn </form>rnrn {/* Loading and Error Messages */}rn {loading && (rn <div className=”flex items-center justify-center text-blue-700 font-semibold text-lg py-4″>rn <svg className=”animate-spin -ml-1 mr-3 h-6 w-6 text-blue-700″ xmlns=”http://www.w3.org/2000/svg” fill=”none” viewBox=”0 0 24 24″>rn <circle className=”opacity-25″ cx=”12″ cy=”12″ r=”10″ stroke=”currentColor” strokeWidth=”4″></circle>rn <path className=”opacity-75″ fill=”currentColor” d=”M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z”></path>rn </svg>rn Loading weather data…rn </div>rn )}rnrn {error && (rn <div className=”bg-red-100 border border-red-400 text-red-700 px-4 py-3 rounded-xl relative mb-4″ role=”alert”>rn <strong className=”font-bold”>Error!</strong>rn <span className=”block sm:inline ml-2″>{error}</span>rn </div>rn )}rnrn {/* Weather Display */}rn {weatherData && !loading && (rn <div className=”bg-gradient-to-r from-blue-500 to-indigo-600 text-white p-6 rounded-2xl shadow-lg transform transition-all duration-300 hover:shadow-xl”>rn <div className=”flex items-center justify-between mb-4″>rn <h2 className=”text-3xl font-bold”>{weatherData.city}</h2>rn <span className=”text-5xl”><imgrn src={weatherData.icon}rn alt=”new”rn /></span>rn </div>rn <p className=”text-6xl font-extrabold mb-4″>{weatherData.temperature}</p>rn <p className=”text-2xl mb-2″>{weatherData.description}</p>rn <div className=”grid grid-cols-2 gap-4 text-lg”>rn {weatherData.showHumidity && (<p>Humidity: <span className=”font-semibold”>{weatherData.humidity}</span></p>)}rn <p>Wind Speed: <span className=”font-semibold”>{weatherData.windSpeed}</span></p>rn </div>rn </div>rn )}rnrn {/* Initial message or no data message */}rn {!weatherData && !loading && !error && (rn <div className=”text-center text-gray-600 text-lg py-8″>rn Enter a city name above to get started!rn </div>rn )}rn </div>rn </div>rn );rn}rnrnexport default App;’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f621f2f5a00>)])]>

  • Clear the App.css file (or delete it & remove its references if required). We will be using tailwind so add the following in public/index.html, inside the <head> tag:

  • <script src=”https://cdn.tailwindcss.com”></script>

Your public/index.html would look something like:

code_block
<ListValue: [StructValue([(‘code’, ‘<!DOCTYPE html>rn<html lang=”en”>rn <head>rn <meta charset=”utf-8″ />rn <link rel=”icon” href=”%PUBLIC_URL%/favicon.ico” />rn <meta name=”viewport” content=”width=device-width, initial-scale=1″ />rn <meta name=”theme-color” content=”#000000″ />rn <metarn name=”description”rn content=”Web site created using create-react-app”rn />rn <link rel=”apple-touch-icon” href=”%PUBLIC_URL%/logo192.png” />rn <!–rn manifest.json provides metadata used when your web app is installed on arn user’s mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/rn –>rn <link rel=”manifest” href=”%PUBLIC_URL%/manifest.json” />rn <!–rn Notice the use of %PUBLIC_URL% in the tags above.rn It will be replaced with the URL of the `public` folder during the build.rn Only files inside the `public` folder can be referenced from the HTML.rn Unlike “/favicon.ico” or “favicon.ico”, “%PUBLIC_URL%/favicon.ico” willrn work correctly both with client-side routing and a non-root public URL.rn Learn how to configure a non-root public URL by running `npm run build`.rn –>rn <!– Add this Tailwind CSS CDN link –>rn <script src=”https://cdn.tailwindcss.com”></script>rn <title>React App</title>rn </head>rn <body>rn <noscript>You need to enable JavaScript to run this app.</noscript>rn <div id=”root”></div>rn <!–rn This HTML file is a template.rn If you open it directly in the browser, you will see an empty page.rn You can add webfonts, meta tags, or analytics to this file.rn The build step will place the bundled scripts into the <body> tag.rn To begin the development, run `npm start` or `yarn start`.rn To create a production bundle, use `npm run build` or `yarn build`.rn –>rn </body>rn</html>’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f62221e8310>)])]>

Now we need a server to serve weather API responses:

code_block
<ListValue: [StructValue([(‘code’, ‘mkdir weather-backendrnrncd weather-backendrnrnnpm init -yrnrnnpm install @google-cloud/parametermanagerrnrnnpm install cors express yamlrnrnnpm install node-fetch@2’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f62215a6f10>)])]>

Install gcloud by following the instructions at install-sdk if you don’t have it already.

Then run:

code_block
<ListValue: [StructValue([(‘code’, ‘gcloud auth application-default login’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f62215a6b80>)])]>

Now, within the weather-backend directory create a server.js file with the following code:

code_block
<ListValue: [StructValue([(‘code’, ‘// server.jsrnrn// Import necessary modulesrnconst express = require(‘express’); // Express.js for creating the serverrnconst cors = require(‘cors’); // CORS middleware to allow cross-origin requestsrnconst fetch = require(‘node-fetch’); // node-fetch for making HTTP requests (install with npm install node-fetch@2)rnconst YAML = require(‘yaml’);rn// Imports the Parametermanager libraryrnconst {ParameterManagerClient} = require(‘@google-cloud/parametermanager’).v1;rnrnconst app = express(); // Initialize Express apprnconst PORT = process.env.PORT || 5001; // Define the port for the serverrnconst startupConfigProject = “annular-text-460910-i0” // specify your own GCP project ID herernconst startupConfigLocation = “global” // specify region of the Parameter to usernconst startupConfigParameter = “my-weather-demo-parameter” // specify name of the Parameter to usernconst startupConfig = `projects/${startupConfigProject}/locations/${startupConfigLocation}/parameters/${startupConfigParameter}/versions/`rnconst appVersion = “v1″ // specify the name of the Parameter Verision to usern// Instantiates a clientrnconst parametermanagerClient = new ParameterManagerClient();rnlet CONFIG = undefinedrnrn// Middlewarernapp.use(cors()); // Enable CORS for all routes, allowing frontend to connectrnapp.use(express.json()); // Enable parsing of JSON request bodiesrnrn// You can get one from: https://openweathermap.org/api & store it in Secret Managerrn// & use Parameter Manager to fetch it along with other relevant configuration parameters.rnlet OPENWEATHER_API_KEY = ”; // set on server startup by fetching it from Parameter Managerrn// Base URL for OpenWeatherMap APIrnconst OPENWEATHER_BASE_URL = ‘https://api.openweathermap.org/data/2.5/weather’;rnrnasync function callRenderParameterVersion(name) {rn // Construct requestrn const request = {rn name,rn };rnrn // Run requestrn const [response] = await parametermanagerClient.renderParameterVersion(request);rn try {rn CONFIG = YAML.parse(response.renderedPayload.toString(‘utf8’));rn console.log(CONFIG);rn } catch (e) {rn console.error(‘Error parsing YAML parameters to utf8:’, e);rn }rn}rnrn/**rn * @route GET /api/weatherrn * @desc Fetches weather data for a given cityrn * @param {object} req – Express request object. Expects ‘city’ as a query parameter.rn * @param {object} res – Express response object. Sends weather data or error.rn */rnapp.get(‘/api/weather’, async (req, res) => {rn const city = req.query.city; // Get city from query parameters (e.g., /api/weather?city=London)rnrn if (!city) {rn // If no city is provided, send a 400 Bad Request errorrn return res.status(400).json({ message: ‘City parameter is required.’ });rn }rnrn try {rn // Construct the OpenWeatherMap API URLrn let unit = “metric”rn let temperatureSuffix = “°C”rn if (CONFIG.fahrenheit) {rn unit = “imperial”rn temperatureSuffix = “°F”rn }rn const apiUrl = `${OPENWEATHER_BASE_URL}?q=${city}&appid=${OPENWEATHER_API_KEY}&units=${unit}`; // units=metric for Celsiusrn console.log(apiUrl)rnrn // Make the API call to OpenWeatherMaprn const response = await fetch(apiUrl);rn const data = await response.json();rnrn // Check if the API call was successfulrn if (response.ok) {rn // Process the data to send a simplified, relevant response to the frontendrn const weatherData = {rn city: data.name,rn country: data.sys.country,rn temperature: `${Math.round(data.main.temp)}${temperatureSuffix}`, // Round temperaturern description: data.weather[0].description,rn humidity: `${data.main.humidity}%`,rn showHumidity: CONFIG.showHumidity,rn windSpeed: `${Math.round(data.wind.speed * 3.6)} km/h`, // Convert m/s to km/hrn icon: `http://openweathermap.org/img/wn/${data.weather[0].icon}@2x.png`, // OpenWeatherMap icon URLrn offline: falsern };rn res.json(weatherData); // Send processed data to frontendrn } else {rn // If OpenWeatherMap returns an error (e.g., city not found or API is down)rn console.error(‘OpenWeatherMap API Error:’, data);rnrn // return dummy data based on defaultLocationrn const dummyData = CONFIG.dummyData.find((d) => d.city === CONFIG.defaultLocation)rnrn const weatherData = {rn city: dummyData.city,rn temperature: `${dummyData.temperature}`,rn description: dummyData.description,rn humidity: `${dummyData.humidity}`,rn showHumidity: CONFIG.showHumidity,rn windSpeed: `${dummyData.windSpeed}`,rn icon: `${dummyData.icon}`, // OpenWeatherMap icon URLrn offline: truern };rnrn res.json(weatherData); // Send processed dummy data to frontendrn }rn } catch (error) {rn // Catch any network or server-side errorsrn console.error(‘Server error fetching weather:’, error);rn res.status(500).json({ message: ‘Internal server error.’ });rn }rn});rnrn// Start the serverrn(async () => {rn try {rn // Fetch the application parameters & set them in CONFIG variablern await callRenderParameterVersion(startupConfig + appVersion)rnrn app.listen(PORT, () => {rn OPENWEATHER_API_KEY = CONFIG.apiKeyrn console.log(`Node.js Weather Backend listening on port ${PORT}`);rn console.log(`Visit http://localhost:${PORT}/api/weather?city=London in your browser to test.`);rn });rn } catch (error) {rn console.error(‘Error during pre-server setup:’, error);rn process.exit(1); // Exit if critical setup failsrn }rn})();’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f6222454070>)])]>

This server is responsible for fetching the application parameters from Parameter Manager on startup. Use that to serve the necessary responses from the weather API. 

The parameters stored in Parameter Manager contain the weather API Key, metric system configuration, and other relevant application specific data. It also contains some dummy data that can be used by the server in events when the server is not connected to the weather API due to some issue.

Open two separate terminal shells:

code_block
<ListValue: [StructValue([(‘code’, ‘## In First Shell:rnrncd parameter-manager-weather-app/weather-backendrnrngcloud auth application-default loginrnrnnode server.js’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f6222454e20>)])]>

Your backend server will start, loading the configuration from Parameter Manager, including the securely resolved API Key from Secret Manager.

code_block
<ListValue: [StructValue([(‘code’, ‘## In Second Shell:rnrncd parameter-manager-weather-apprnrnnpm start’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7f62224543d0>)])]>

Your React frontend will launch, connect to your local backend, and start requesting weather information, dynamically configured by Parameter Manager.

13. Running the Application in browser

Running the Application in browser.

14. Viewing weather details in the application

Viewing weather details in the application.

Beyond the basics: Advanced use cases

Parameter Manager can help developers achieve their configuration security and compliance goals. It can help you:

  • Offer regional configurations: Imagine your app serves users globally. Some regions may prefer Celsius, others Fahrenheit. You can create regional Parameters in different Google Cloud regions, each with different values for Fahrenheit and defaultLocation. By setting the startupConfigLocation in your server.js (or in your deployment environment), your servers can automatically load the configuration relevant to that region.

  • Meet regional compliance requirements: Parameters can only reference Secrets from the same region. For this walkthrough, we used a global region for both Secrets and Parameters, but you can create Regional Secrets in, for example, us-central1, and expect that only Parameters in us-central1 can reference the Secret. This can help to ensure that your sensitive information never leaves the region of your choice.

  • Implement A/B testing and feature flags: To test a new feature with a subset of users, you can add a new attribute to a v2 Parameter Version. Then you can dynamically switch the appVersion constant in your backend (or via an environment variable in a deployed environment) based on your A/B testing strategy, and roll out new features to different user groups, gather feedback, and iterate quickly.

By using Google Cloud Parameter Manager and Secret Manager, you can gain a robust, secure, and flexible system for managing all your application configurations, empowering you to build more agile and resilient applications.

Read More for the details.

Related Posts