Skip to main content

This question takes a Spring Boot service as an example, but it could be any technology.

Assuming the following:

  • Environments (dev/qaQA/prod) are owned by different teams. This means dev must not have access to prod configuration.
  • Configuration (letslet's say application.properties) is externalized, ie not part of the binary
  • The same binary/package (letslet's say service.jar) is deployed in each environment and controlled by automated deployment

While changes to the binary artefactartifact (service.jar) getsget automatically propagated to each environment, changes to configuration still needsneed manual intervention, which inevitably ends up being de-synchronized in each environment.

For example, letslet's say dev team adds a few key-value pairs to application.properties in their environment. What would be the best way to record these new keys, so that when the deployment occurs in the ops team they know exactly which keys to add, so the risk of starting the new service and seeing it failed because of a missing key is minimized  ?

I know there will be manual steps involved, but I would like to know how people deals with this, and find the most effective way.

This question takes a Spring Boot service as an example, but it could be any technology.

Assuming the following:

  • Environments (dev/qa/prod) are owned by different teams. This means dev must not have access to prod configuration.
  • Configuration (lets say application.properties) is externalized, ie not part of the binary
  • The same binary/package (lets say service.jar) is deployed in each environment and controlled by automated deployment

While changes to the binary artefact (service.jar) gets automatically propagated to each environment, changes to configuration still needs manual intervention, which inevitably ends up being de-synchronized in each environment.

For example, lets say dev team adds a few key-value pairs to application.properties in their environment. What would be the best way to record these new keys, so that when the deployment occurs in the ops team they know exactly which keys to add, so the risk of starting the new service and seeing it failed because of a missing key is minimized  ?

I know there will be manual steps involved, but I would like to know how people deals with this, and find the most effective way.

This question takes a Spring Boot service as an example, but it could be any technology.

Assuming the following:

  • Environments (dev/QA/prod) are owned by different teams. This means dev must not have access to prod configuration.
  • Configuration (let's say application.properties) is externalized, ie not part of the binary
  • The same binary/package (let's say service.jar) is deployed in each environment and controlled by automated deployment

While changes to the binary artifact (service.jar) get automatically propagated to each environment, changes to configuration still need manual intervention, which inevitably ends up being de-synchronized in each environment.

For example, let's say dev team adds a few key-value pairs to application.properties in their environment. What would be the best way to record these new keys, so that when the deployment occurs in the ops team they know exactly which keys to add, so the risk of starting the new service and seeing it failed because of a missing key is minimized?

I know there will be manual steps involved, but I would like to know how people deals with this and find the most effective way.

Tweeted twitter.com/StackSoftEng/status/832836516120555520
Source Link

Effectively tracking changes to configuration from dev to prod

This question takes a Spring Boot service as an example, but it could be any technology.

Assuming the following:

  • Environments (dev/qa/prod) are owned by different teams. This means dev must not have access to prod configuration.
  • Configuration (lets say application.properties) is externalized, ie not part of the binary
  • The same binary/package (lets say service.jar) is deployed in each environment and controlled by automated deployment

While changes to the binary artefact (service.jar) gets automatically propagated to each environment, changes to configuration still needs manual intervention, which inevitably ends up being de-synchronized in each environment.

For example, lets say dev team adds a few key-value pairs to application.properties in their environment. What would be the best way to record these new keys, so that when the deployment occurs in the ops team they know exactly which keys to add, so the risk of starting the new service and seeing it failed because of a missing key is minimized ?

I know there will be manual steps involved, but I would like to know how people deals with this, and find the most effective way.