Configure once, run everywhere 2016

BASEL BERN BRUGG DÜSSELDORF FRANKFURT A.M. FREIBURG I.BR. GENF HAMBURG KOPENHAGEN LAUSANNE MÜNCHEN STUTTGART WIEN ZÜRICH

Configure Once, run everyhere!Configurationwith ApacheTamaya

Configure once, run everywhere6.09.16

Anatole TreschPrincipal Consultant, Trivadis AG (Switzerland) Star Spec LeadTechnical Architect, Lead EngineerPPMC Member Apache Tamaya

@atsticksanatole@apache.organatole.tresch@trivadis.com

About Me

Agenda

● Motivation

● Requirements

● The API

● Configuration Backends

● Demo

● Extensions

Motivation

Configure once, run everywhere6.09.16 5

What is Configuration ?

Simple Key/value pairs?

Typed values?

When is Configuration useful?

Use Cases?

How is it stored?

Remotely or locally?Classpath, file or ...?

Which format?All of the above (=multiple sources) ?

When to configure?

Develpment time ?Build/deployment time?

Startup?Dynamic, anytime?

Configuration Lifecycle ?

Static ?Refreshing ?

Changes triggered ?

Do I need a runtime ?

Java SE?Java EE?

Bezeichnung Präsentation6.09.16

Requirements

● Developer‘s Perspective

● Architectural/Design Requirements

● Operational Aspects

● Other Aspects

Requirements

● Easy to use.

● Developers want defaults.

● Developers don‘t care about the runtime (for configuration only).

● Developers are the ultimate source of truth

● Type Safety

Developer‘s Requirements

Architectural/Design Requirements

Decouple code that consumes configuration from

● Backends Used

● Storage Format

● Distribution

● Lifecycle and versioning

● Security Aspects

● Enable Transparency:

● What configuration is available ?

● What are the current values and which sources provided the value ?

● Documentation

● Manageable:

● Configuration changes without redeployment or restart.

● Solution must integrate with existing environment

Operational‘s Requirements

● Support Access Constraints and Views

● No accidential logging of secrets

● Dynamic changes

● Configuration Validation

Other Aspects

Accessing Configuration

The API

● Leverage existing functionality where

useful

● Only one uniform API for access on all platforms!

● Defaults provided by developer during development

(no interaction with operations or external dependencies)

API Requirements

● Environment Properties

● System Properties

● CLI arguments

● Properties, xml-Properties

Existing Mechanisms

Dependencies - API & Core

<dependency> <groupId>org.apache.tamaya</groupId> <artifactId>tamayaapi</artifactId> <version>0.2SNAPSHOT</version></dependency><dependency> <groupId>org.apache.tamaya</groupId> <artifactId>tamayacore</artifactId> <version>0.2SNAPSHOT</version></dependency>

Programmatic API

● Add dependency org.apache.tamaya:core: 0.2-incubating● Add Config to META-INF/javaconfiguration.properties● GO!

Configuration config = ConfigurationProvider.getConfiguration();

// single property accessString name = config.getOrDefault("name", "John");int ChildNum = config.get("childNum", int.class);

// Multi property accessMap<String,String> properties = config.getProperties();

// Templates (provided by extension)MyConfig config = ConfigurationInjection.getConfigurationInjector() .getConfig(MyConfig.class);

Dependencies – Injection SE

<dependency> <groupId>org.apache.tamaya.ext</groupId> <artifactId>tamayainjectionapi</artifactId> <version>0.2SNAPSHOT</version></dependency><dependency> <groupId>org.apache.tamaya.ext</groupId> <artifactId>tamayainjection</artifactId> <version>0.2SNAPSHOT</version></dependency>

@Config(value=„admin.server“, defaultValue=“127.0.0.1“)private String server;

@Config(value=“admin.port“, defaultValue=“8080“)private int port;

@Config(value=“admin.connections“)private int connections = 5;

@Config(„address“)private Address address;

MyTenant t = new MyTenant();ConfigurationInjection .getConfigurationInjector() .configure(t);

Configuration Backends

● Support existing mechanisms OOTB

● Provide a simple SPI for (multiple) property sources

● Define a mechanism to prioritize different property sources

● Allow different strategies to combine values

● Support Filtering

● Support Type Conversion

Configuration Backends

So what is a property source ?

PropertySource

● Add dependency org.apache.tamaya:core: 0.2-incubating● Add Config to META-INF/java Map<String,String> getProperties();configuration.properties● GO!

public interface PropertySource {

PropertyValue get(String key); Map<String,String> getProperties(); boolean isScannable(); String getName(); int getOrdinal();}public final class PropertyValue{ public String getKey(); public String getValue(); public String get(String key); public Map<String,String> getConfigEntries(); ...}

Are there predefined property sources ?

Of course.

● System & Environment Properties

● (CLI Arguments)

● Files: ${configDir}/*.properties

● Classpath Resources: /METAINF/javaconfiguration.properties

And how about remote configuration…?

Especially with Containers?

● Configuration is read from remote source, e.g.

● Etcd cluster

● Consul cluster

● Any Web URL

● ...

Remote configuration

Service Location Layer

Configuration Cluster

<dependency> <groupId>org.apache.tamaya.ext</groupId> <artifactId>tamayaetcd</artifactId> <version>...</version></dependency>

● In fact, it doesn‘t matter ! Configure once, run everywhere !

What kind of runtime I need ?

Configuration Cluster

Java EETamaya

Java SETamaya

Tamaya

Vertx.io

TamayaTomEE

Tamaya

Spring

Tamaya

● Configuration on deployment by environment properties:

docker run e stage prod d n MyApp user/image

● or Dockerfile/Docker Image:

FROM java:8jre...ENV stage prod

Excourse: Configuring Containers

How to add custom configuration ?

Other files...

Or resources...

My self-written super fancy config database ?

Whatever I like ?

Use the SPI !

Property sources

● Mostly map to exact one file, resource or backend

● Have a unique name

● Must be thread safe

● Can be dynamic

● Provide an ordinal

● Can be scannable

PropertySource

PropertySource – Example

● Add dependency

public class MyPropertySource extends BasePropertySource{ private Map<String,String> props = new HashMap<>(); public SimplePropertySource() throws IOException { URL url = getClass().getClassLoader().getResource( “/METAINF/myFancyConfig.xml“); // read config properties into props ... }

@Override public String getName() { return “/METAINF/myFancyConfig.xml“; };

@Override public Map<String, String> getProperties() { return props; }}

PropertySource - Registration

● Add dependency

● By default, register it using the java.util.ServiceLoader

→ /METAINF/services/org.apache.tamaya.spi.PropertySource

MyPropertySource

Property source provider

● Allow dynamic registration of multiple property sources

● E.g. all files found in a config directory

● Are evaluated once and then discarded

● Are also registered using the ServiceLoader.

PropertySource Provider

PropertySourceProvider

● Add dependency public interface PropertySourceProvider{ public Collection<PropertySource> getPropertySources();

Furthermore Tamaya uses

● Filters for filtering values evaluated (remove, map, change)

● Converters for converting String values to non-String types

● A ValueCombinationPolicy

● determines how values evaluated are combined to a final value

(defaults to overriding)

More SPI artifacts

And how these pieces all fit together ?

Apache Tamaya in 120 seconds...

1.Configuration = ordered list of PropertySources

2.Properties found are combined using a CombinationPolicy

3.Raw properties are filtered by PropertyFilter4.For typed access PropertyConverters

have to do work5.Extensions add more features

(discussed later)6.Component Lifecycle is controlled by the ServiceContextManager

ConfigurationContext

PropertyFilters

PropertySource

Configuration

yPropertyProviders<provides>

PropertyConverter

So we have:

files, resources, sys- and env-properties

& an SPI to implement and register them ?

What else do we need ?

Easy Configuration:

„Meta“-Configuration !

● Configuration that configures configuration

● E.g. at METAINF/tamayaconfig.xml

● Allows easy and quick setup of your configuration environment

● Allows dynamic enablement of property sources

● ...

Meta-Configuration DRAFT !

<configuration> <context> <context-param name="stage">DEV</context-param> </context> <sources> <source type="env-properties" enabled="${stage=TEST || stage=PTA || stage=PROD}" ordinal="200"/> <source type="sys-properties" /> <source type="file"> <observe period="20000">true</observe> <location>./config.json</location> </source> <source type="resources" multiple="true"> <multiple>true</multiple> <location>/META-INF/application-config.yml</location> </source> <source type="ch.mypack.MyClassSource"> <locale>de</locale> </source> <source type="includes" enabled="${context.cstage==TEST}"> <include>TEST.properties</include> </source> </sources></configuration>

DRAFT !

● 1 Microservice

● Running on Java EE 7 (Wildfly)

● Multiple Configuration Sources:● Environment Properties● System Properties● Classpath● Files● Etcd Server

There is more!

Tamaya Extensions

Property resolution...

java.home=/usr/lib/java

compiler=${ref:java.home}/bin/javac

<dependency> <groupId>org.apache.tamaya.ext</groupId> <artifactId>tamayaresolver</artifactId> <version>...</version></dependency>

Resource expressions…public class MyProvider extends AbstractPathPropertySourceProvider{

public MyProvider(){

super(“classpath:/METAINF/config/**/*.properties“);

@Override

protected Collection<PropertySource> getPropertySources(URL url) {

// TODO map resource to property sources

return Collections.emptySet();

<dependency> <groupId>org.apache.tamaya.ext</groupId> <artifactId>tamayaresources</artifactId> <version>...</version></dependency>

And more: a topic on its own!

● Tamaya-spi-support: Some handy base classes to implement SPIs● Tamaya-functions: Functional extension points (e.g. remapping, scoping)● Tamaya-events: Detect and publish ConfigChangeEvents● Tamaya-optional: Minimal access layer with optional Tamaya support● Tamaya-filter: Thread local filtering● Tamaya-inject-api: Tamaya Configuration Injection Annotations● Tamaya-inject: Configuration Injection and Templates SE Implementation (lean, no CDI)● Format Extensions: yaml, json, ini, … including formats-SPI● Integrations with CDI, Spring, OSGI*, Camel, etcd● Tamaya-mutable-config*: Writable ConfigChangeRequests● Tamaya-model*: Configuration Model and Auto Documentation● Tamaya-collections*: Collection Support● Tamaya-resolver: Expression resolution, placeholders, dynamic values● Tamaya-resources: Ant styled resource resolution•... * experimental

Summary

Summarizing...

A Complete thread- and type-safe Configuration API

● Compatible with all major runtimes

● Simple, but extendible design

● Extensible

● Small footprint

● Base for current Java EE 8 spec ?

You like it ?

„It is your turn !“

● Use it● Evangelize it● Join the force!

Links●Project Page: http://tamaya.incubator.apache.org ●Twitter: @tamayaconfig● Blog: http://javaeeconfig.blogspot.com ● Presentation by Mike Keith on JavaOne 2013: https://oracleus.activeevents.com/2013/connect/sessionDetail.ww?SESSION_ID=7755 ● Apache Deltaspike: http://deltaspike.apache.org ● Java Config Builder: https://github.com/TNG/config-builder ● Apache Commons Configuration: http://commons.apache.org/proper/commons-configuration/ ● Jfig: http://jfig.sourceforge.net/ ● Carbon Configuration: http://carbon.sourceforge.net/modules/core/docs/config/Usage.html ● Comparison on Carbon and Others: http://www.mail-archive.com/commons-dev@jakarta.apache.org/msg37597.html ● Spring Framework: http://projects.spring.io/spring-framework/● Owner: http://owner.aeonbits.org/

Thank you! @atsticks anatole@apache.org

Anatole TreschTrivadis AGPrincipal ConsultantTwitter/Google+: @atsticks anatole@apache.org anatole.tresch@trivadis.com

Configure once, run everywhere 2016

Software

Transcript of Configure once, run everywhere 2016

Certified Once Accepted Everywhere Multilateral Recognition Agreement (MLA) Annual Report 2013 Certified Once Accepted Everywhere IAF Multilateral Recognition Arrangement (MLA) Annual

Configuration with Apache Tamaya · 6.09.16 Configure once, run everywhere Programmatic API 21 Add dependency org.apache.tamaya:core: 0.2-incubating Add Config to META-INF/javaconfiguration.properties

The Secret to Being Everywhere at Once...with Unity3D!

Mobile Java with MGWT, "Still Write Once Run Everywhere"

Create Once Publish Everywhere Anytime

Write Once, Run Everywhere

The Xen-Blanket: Virtualize Once, Run Everywhere

Create Once Publish Everywhere Anytime (version française)

Code once, play everywhere

Сергей Моренец: "Gradle. Write once, build everywhere"

Dion Almaer & Ben Galbraith - Build Once, Deploy Everywhere

Create Once, Publish Everywhere

UNSWTV: Publishing Everywhere at Once

Do-it-once, Do-it-right, Do-it-everywhere.

JavaFX 8 everywhere; write once run anywhere by Mohamed Taman

Create once, publish everywhere | Sam Gough | May 2015

COPEing Mechanisms: The Peril and Promise of Create Once, Publish Everywhere

Stewart Longhurst, Dulux - code once, deliver everywhere

Reforming everywhere and all at once: transitioning to ...

Servlets made easy. Write once and run everywhere.