485 lines
16 KiB
Go
485 lines
16 KiB
Go
package ecs
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"strconv"
|
|
"strings"
|
|
"text/template"
|
|
|
|
"github.com/BurntSushi/ty/fun"
|
|
"github.com/aws/aws-sdk-go/aws"
|
|
"github.com/containous/traefik/log"
|
|
"github.com/containous/traefik/provider"
|
|
"github.com/containous/traefik/provider/label"
|
|
"github.com/containous/traefik/types"
|
|
)
|
|
|
|
// buildConfiguration fills the config template with the given instances
|
|
func (p *Provider) buildConfiguration(services map[string][]ecsInstance) (*types.Configuration, error) {
|
|
var ecsFuncMap = template.FuncMap{
|
|
// Backend functions
|
|
"getHost": getHost,
|
|
"getPort": getPort,
|
|
"getCircuitBreaker": getCircuitBreaker,
|
|
"getLoadBalancer": getLoadBalancer,
|
|
"getMaxConn": getMaxConn,
|
|
"getHealthCheck": getHealthCheck,
|
|
"getBuffering": getBuffering,
|
|
"getServers": getServers,
|
|
|
|
// TODO Deprecated [breaking]
|
|
"getProtocol": getFuncStringValue(label.TraefikProtocol, label.DefaultProtocol),
|
|
// TODO Deprecated [breaking]
|
|
"getWeight": getFuncIntValue(label.TraefikWeight, label.DefaultWeightInt),
|
|
// TODO Deprecated [breaking]
|
|
"getLoadBalancerMethod": getFuncFirstStringValue(label.TraefikBackendLoadBalancerMethod, label.DefaultBackendLoadBalancerMethod),
|
|
// TODO Deprecated [breaking]
|
|
"getSticky": getSticky,
|
|
// TODO Deprecated [breaking]
|
|
"hasStickinessLabel": getFuncFirstBoolValue(label.TraefikBackendLoadBalancerStickiness, false),
|
|
// TODO Deprecated [breaking]
|
|
"getStickinessCookieName": getFuncFirstStringValue(label.TraefikBackendLoadBalancerStickinessCookieName, label.DefaultBackendLoadbalancerStickinessCookieName),
|
|
// TODO Deprecated [breaking]
|
|
"hasHealthCheckLabels": hasFuncFirst(label.TraefikBackendHealthCheckPath),
|
|
// TODO Deprecated [breaking]
|
|
"getHealthCheckPath": getFuncFirstStringValue(label.TraefikBackendHealthCheckPath, ""),
|
|
// TODO Deprecated [breaking]
|
|
"getHealthCheckInterval": getFuncFirstStringValue(label.TraefikBackendHealthCheckInterval, ""),
|
|
|
|
// Frontend functions
|
|
"filterFrontends": filterFrontends,
|
|
"getFrontendRule": p.getFrontendRule,
|
|
"getPassHostHeader": getFuncBoolValue(label.TraefikFrontendPassHostHeader, label.DefaultPassHostHeaderBool),
|
|
"getPassTLSCert": getFuncBoolValue(label.TraefikFrontendPassTLSCert, label.DefaultPassTLSCert),
|
|
"getPriority": getFuncIntValue(label.TraefikFrontendPriority, label.DefaultFrontendPriorityInt),
|
|
"getBasicAuth": getFuncSliceString(label.TraefikFrontendAuthBasic),
|
|
"getEntryPoints": getFuncSliceString(label.TraefikFrontendEntryPoints),
|
|
"getRedirect": getRedirect,
|
|
"getErrorPages": getErrorPages,
|
|
"getRateLimit": getRateLimit,
|
|
"getHeaders": getHeaders,
|
|
"getWhiteList": getWhiteList,
|
|
}
|
|
return p.GetConfiguration("templates/ecs.tmpl", ecsFuncMap, struct {
|
|
Services map[string][]ecsInstance
|
|
}{
|
|
Services: services,
|
|
})
|
|
}
|
|
|
|
func (p *Provider) getFrontendRule(i ecsInstance) string {
|
|
defaultRule := "Host:" + strings.ToLower(strings.Replace(i.Name, "_", "-", -1)) + "." + p.Domain
|
|
return getStringValue(i, label.TraefikFrontendRule, defaultRule)
|
|
}
|
|
|
|
// TODO: Deprecated
|
|
// replaced by Stickiness
|
|
// Deprecated
|
|
func getSticky(instances []ecsInstance) bool {
|
|
if hasFirst(instances, label.TraefikBackendLoadBalancerSticky) {
|
|
log.Warnf("Deprecated configuration found: %s. Please use %s.", label.TraefikBackendLoadBalancerSticky, label.TraefikBackendLoadBalancerStickiness)
|
|
}
|
|
return getFirstBoolValue(instances, label.TraefikBackendLoadBalancerSticky, false)
|
|
}
|
|
|
|
// TODO: Deprecated
|
|
// replaced by Stickiness
|
|
// Deprecated
|
|
func getStickyOne(instance ecsInstance) bool {
|
|
if hasLabel(instance, label.TraefikBackendLoadBalancerSticky) {
|
|
log.Warnf("Deprecated configuration found: %s. Please use %s.", label.TraefikBackendLoadBalancerSticky, label.TraefikBackendLoadBalancerStickiness)
|
|
}
|
|
return getBoolValue(instance, label.TraefikBackendLoadBalancerSticky, false)
|
|
}
|
|
|
|
func getHost(i ecsInstance) string {
|
|
return aws.StringValue(i.machine.PrivateIpAddress)
|
|
}
|
|
|
|
func getPort(i ecsInstance) string {
|
|
if value := getStringValue(i, label.TraefikPort, ""); len(value) > 0 {
|
|
return value
|
|
}
|
|
return strconv.FormatInt(aws.Int64Value(i.container.NetworkBindings[0].HostPort), 10)
|
|
}
|
|
|
|
func filterFrontends(instances []ecsInstance) []ecsInstance {
|
|
byName := make(map[string]struct{})
|
|
|
|
return fun.Filter(func(i ecsInstance) bool {
|
|
_, found := byName[i.Name]
|
|
if !found {
|
|
byName[i.Name] = struct{}{}
|
|
}
|
|
return !found
|
|
}, instances).([]ecsInstance)
|
|
}
|
|
|
|
func getCircuitBreaker(instance ecsInstance) *types.CircuitBreaker {
|
|
expression := getStringValue(instance, label.TraefikBackendCircuitBreakerExpression, "")
|
|
if len(expression) == 0 {
|
|
return nil
|
|
}
|
|
|
|
return &types.CircuitBreaker{Expression: expression}
|
|
}
|
|
|
|
func getLoadBalancer(instance ecsInstance) *types.LoadBalancer {
|
|
if !hasPrefix(instance, label.TraefikBackendLoadBalancer) {
|
|
return nil
|
|
}
|
|
|
|
method := getStringValue(instance, label.TraefikBackendLoadBalancerMethod, label.DefaultBackendLoadBalancerMethod)
|
|
|
|
lb := &types.LoadBalancer{
|
|
Method: method,
|
|
Sticky: getStickyOne(instance),
|
|
}
|
|
|
|
if getBoolValue(instance, label.TraefikBackendLoadBalancerStickiness, false) {
|
|
cookieName := getStringValue(instance, label.TraefikBackendLoadBalancerStickinessCookieName, label.DefaultBackendLoadbalancerStickinessCookieName)
|
|
lb.Stickiness = &types.Stickiness{CookieName: cookieName}
|
|
}
|
|
|
|
return lb
|
|
}
|
|
|
|
func getMaxConn(instance ecsInstance) *types.MaxConn {
|
|
amount := getInt64Value(instance, label.TraefikBackendMaxConnAmount, math.MinInt64)
|
|
extractorFunc := getStringValue(instance, label.TraefikBackendMaxConnExtractorFunc, label.DefaultBackendMaxconnExtractorFunc)
|
|
|
|
if amount == math.MinInt64 || len(extractorFunc) == 0 {
|
|
return nil
|
|
}
|
|
|
|
return &types.MaxConn{
|
|
Amount: amount,
|
|
ExtractorFunc: extractorFunc,
|
|
}
|
|
}
|
|
|
|
func getHealthCheck(instance ecsInstance) *types.HealthCheck {
|
|
path := getStringValue(instance, label.TraefikBackendHealthCheckPath, "")
|
|
if len(path) == 0 {
|
|
return nil
|
|
}
|
|
|
|
port := getIntValue(instance, label.TraefikBackendHealthCheckPort, label.DefaultBackendHealthCheckPort)
|
|
interval := getStringValue(instance, label.TraefikBackendHealthCheckInterval, "")
|
|
|
|
return &types.HealthCheck{
|
|
Path: path,
|
|
Port: port,
|
|
Interval: interval,
|
|
}
|
|
}
|
|
|
|
func getBuffering(instance ecsInstance) *types.Buffering {
|
|
if !hasPrefix(instance, label.TraefikBackendBuffering) {
|
|
return nil
|
|
}
|
|
|
|
return &types.Buffering{
|
|
MaxRequestBodyBytes: getInt64Value(instance, label.TraefikBackendBufferingMaxRequestBodyBytes, 0),
|
|
MaxResponseBodyBytes: getInt64Value(instance, label.TraefikBackendBufferingMaxResponseBodyBytes, 0),
|
|
MemRequestBodyBytes: getInt64Value(instance, label.TraefikBackendBufferingMemRequestBodyBytes, 0),
|
|
MemResponseBodyBytes: getInt64Value(instance, label.TraefikBackendBufferingMemResponseBodyBytes, 0),
|
|
RetryExpression: getStringValue(instance, label.TraefikBackendBufferingRetryExpression, ""),
|
|
}
|
|
}
|
|
|
|
func getServers(instances []ecsInstance) map[string]types.Server {
|
|
var servers map[string]types.Server
|
|
|
|
for _, instance := range instances {
|
|
if servers == nil {
|
|
servers = make(map[string]types.Server)
|
|
}
|
|
|
|
protocol := getStringValue(instance, label.TraefikProtocol, label.DefaultProtocol)
|
|
host := getHost(instance)
|
|
port := getPort(instance)
|
|
|
|
serverName := provider.Normalize(fmt.Sprintf("server-%s-%s", instance.Name, instance.ID))
|
|
servers[serverName] = types.Server{
|
|
URL: fmt.Sprintf("%s://%s:%s", protocol, host, port),
|
|
Weight: getIntValue(instance, label.TraefikWeight, 0),
|
|
}
|
|
}
|
|
|
|
return servers
|
|
}
|
|
|
|
func getWhiteList(instance ecsInstance) *types.WhiteList {
|
|
ranges := getSliceString(instance, label.TraefikFrontendWhiteListSourceRange)
|
|
if len(ranges) > 0 {
|
|
return &types.WhiteList{
|
|
SourceRange: ranges,
|
|
UseXForwardedFor: getBoolValue(instance, label.TraefikFrontendWhiteListUseXForwardedFor, false),
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func getRedirect(instance ecsInstance) *types.Redirect {
|
|
permanent := getBoolValue(instance, label.TraefikFrontendRedirectPermanent, false)
|
|
|
|
if hasLabel(instance, label.TraefikFrontendRedirectEntryPoint) {
|
|
return &types.Redirect{
|
|
EntryPoint: getStringValue(instance, label.TraefikFrontendRedirectEntryPoint, ""),
|
|
Permanent: permanent,
|
|
}
|
|
}
|
|
|
|
if hasLabel(instance, label.TraefikFrontendRedirectRegex) &&
|
|
hasLabel(instance, label.TraefikFrontendRedirectReplacement) {
|
|
return &types.Redirect{
|
|
Regex: getStringValue(instance, label.TraefikFrontendRedirectRegex, ""),
|
|
Replacement: getStringValue(instance, label.TraefikFrontendRedirectReplacement, ""),
|
|
Permanent: permanent,
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func getErrorPages(instance ecsInstance) map[string]*types.ErrorPage {
|
|
labels := mapPToMap(instance.containerDefinition.DockerLabels)
|
|
if len(labels) == 0 {
|
|
return nil
|
|
}
|
|
|
|
prefix := label.Prefix + label.BaseFrontendErrorPage
|
|
return label.ParseErrorPages(labels, prefix, label.RegexpFrontendErrorPage)
|
|
}
|
|
|
|
func getRateLimit(instance ecsInstance) *types.RateLimit {
|
|
extractorFunc := getStringValue(instance, label.TraefikFrontendRateLimitExtractorFunc, "")
|
|
if len(extractorFunc) == 0 {
|
|
return nil
|
|
}
|
|
|
|
labels := mapPToMap(instance.containerDefinition.DockerLabels)
|
|
prefix := label.Prefix + label.BaseFrontendRateLimit
|
|
limits := label.ParseRateSets(labels, prefix, label.RegexpFrontendRateLimit)
|
|
|
|
return &types.RateLimit{
|
|
ExtractorFunc: extractorFunc,
|
|
RateSet: limits,
|
|
}
|
|
}
|
|
|
|
func getHeaders(instance ecsInstance) *types.Headers {
|
|
headers := &types.Headers{
|
|
CustomRequestHeaders: getMapString(instance, label.TraefikFrontendRequestHeaders),
|
|
CustomResponseHeaders: getMapString(instance, label.TraefikFrontendResponseHeaders),
|
|
SSLProxyHeaders: getMapString(instance, label.TraefikFrontendSSLProxyHeaders),
|
|
AllowedHosts: getSliceString(instance, label.TraefikFrontendAllowedHosts),
|
|
HostsProxyHeaders: getSliceString(instance, label.TraefikFrontendHostsProxyHeaders),
|
|
STSSeconds: getInt64Value(instance, label.TraefikFrontendSTSSeconds, 0),
|
|
SSLRedirect: getBoolValue(instance, label.TraefikFrontendSSLRedirect, false),
|
|
SSLTemporaryRedirect: getBoolValue(instance, label.TraefikFrontendSSLTemporaryRedirect, false),
|
|
STSIncludeSubdomains: getBoolValue(instance, label.TraefikFrontendSTSIncludeSubdomains, false),
|
|
STSPreload: getBoolValue(instance, label.TraefikFrontendSTSPreload, false),
|
|
ForceSTSHeader: getBoolValue(instance, label.TraefikFrontendForceSTSHeader, false),
|
|
FrameDeny: getBoolValue(instance, label.TraefikFrontendFrameDeny, false),
|
|
ContentTypeNosniff: getBoolValue(instance, label.TraefikFrontendContentTypeNosniff, false),
|
|
BrowserXSSFilter: getBoolValue(instance, label.TraefikFrontendBrowserXSSFilter, false),
|
|
IsDevelopment: getBoolValue(instance, label.TraefikFrontendIsDevelopment, false),
|
|
SSLHost: getStringValue(instance, label.TraefikFrontendSSLHost, ""),
|
|
CustomFrameOptionsValue: getStringValue(instance, label.TraefikFrontendCustomFrameOptionsValue, ""),
|
|
ContentSecurityPolicy: getStringValue(instance, label.TraefikFrontendContentSecurityPolicy, ""),
|
|
PublicKey: getStringValue(instance, label.TraefikFrontendPublicKey, ""),
|
|
ReferrerPolicy: getStringValue(instance, label.TraefikFrontendReferrerPolicy, ""),
|
|
CustomBrowserXSSValue: getStringValue(instance, label.TraefikFrontendCustomBrowserXSSValue, ""),
|
|
}
|
|
|
|
if !headers.HasSecureHeadersDefined() && !headers.HasCustomHeadersDefined() {
|
|
return nil
|
|
}
|
|
|
|
return headers
|
|
}
|
|
|
|
// Label functions
|
|
|
|
func getFuncStringValue(labelName string, defaultValue string) func(i ecsInstance) string {
|
|
return func(i ecsInstance) string {
|
|
return getStringValue(i, labelName, defaultValue)
|
|
}
|
|
}
|
|
|
|
func getFuncBoolValue(labelName string, defaultValue bool) func(i ecsInstance) bool {
|
|
return func(i ecsInstance) bool {
|
|
return getBoolValue(i, labelName, defaultValue)
|
|
}
|
|
}
|
|
|
|
func getFuncIntValue(labelName string, defaultValue int) func(i ecsInstance) int {
|
|
return func(i ecsInstance) int {
|
|
return getIntValue(i, labelName, defaultValue)
|
|
}
|
|
}
|
|
|
|
func getFuncSliceString(labelName string) func(i ecsInstance) []string {
|
|
return func(i ecsInstance) []string {
|
|
return getSliceString(i, labelName)
|
|
}
|
|
}
|
|
|
|
// Deprecated
|
|
func hasFuncFirst(labelName string) func(instances []ecsInstance) bool {
|
|
return func(instances []ecsInstance) bool {
|
|
return hasFirst(instances, labelName)
|
|
}
|
|
}
|
|
|
|
// Deprecated
|
|
func getFuncFirstStringValue(labelName string, defaultValue string) func(instances []ecsInstance) string {
|
|
return func(instances []ecsInstance) string {
|
|
return getFirstStringValue(instances, labelName, defaultValue)
|
|
}
|
|
}
|
|
|
|
// Deprecated
|
|
func getFuncFirstBoolValue(labelName string, defaultValue bool) func(instances []ecsInstance) bool {
|
|
return func(instances []ecsInstance) bool {
|
|
if len(instances) < 0 {
|
|
return defaultValue
|
|
}
|
|
return getBoolValue(instances[0], labelName, defaultValue)
|
|
}
|
|
}
|
|
|
|
func hasLabel(i ecsInstance, labelName string) bool {
|
|
value, ok := i.containerDefinition.DockerLabels[labelName]
|
|
return ok && value != nil && len(aws.StringValue(value)) > 0
|
|
}
|
|
|
|
func hasPrefix(i ecsInstance, prefix string) bool {
|
|
for name, value := range i.containerDefinition.DockerLabels {
|
|
if strings.HasPrefix(name, prefix) && value != nil && len(aws.StringValue(value)) > 0 {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func getStringValue(i ecsInstance, labelName string, defaultValue string) string {
|
|
if v, ok := i.containerDefinition.DockerLabels[labelName]; ok {
|
|
if v == nil {
|
|
return defaultValue
|
|
}
|
|
if len(aws.StringValue(v)) == 0 {
|
|
return defaultValue
|
|
}
|
|
return aws.StringValue(v)
|
|
}
|
|
return defaultValue
|
|
}
|
|
|
|
func getBoolValue(i ecsInstance, labelName string, defaultValue bool) bool {
|
|
rawValue, ok := i.containerDefinition.DockerLabels[labelName]
|
|
if ok {
|
|
if rawValue != nil {
|
|
v, err := strconv.ParseBool(aws.StringValue(rawValue))
|
|
if err == nil {
|
|
return v
|
|
}
|
|
}
|
|
}
|
|
return defaultValue
|
|
}
|
|
|
|
func getIntValue(i ecsInstance, labelName string, defaultValue int) int {
|
|
rawValue, ok := i.containerDefinition.DockerLabels[labelName]
|
|
if ok {
|
|
if rawValue != nil {
|
|
v, err := strconv.Atoi(aws.StringValue(rawValue))
|
|
if err == nil {
|
|
return v
|
|
}
|
|
}
|
|
}
|
|
return defaultValue
|
|
}
|
|
|
|
func getInt64Value(i ecsInstance, labelName string, defaultValue int64) int64 {
|
|
rawValue, ok := i.containerDefinition.DockerLabels[labelName]
|
|
if ok {
|
|
if rawValue != nil {
|
|
v, err := strconv.ParseInt(aws.StringValue(rawValue), 10, 64)
|
|
if err == nil {
|
|
return v
|
|
}
|
|
}
|
|
}
|
|
return defaultValue
|
|
}
|
|
|
|
func getSliceString(i ecsInstance, labelName string) []string {
|
|
if value, ok := i.containerDefinition.DockerLabels[labelName]; ok {
|
|
if value == nil {
|
|
return nil
|
|
}
|
|
if len(aws.StringValue(value)) == 0 {
|
|
return nil
|
|
}
|
|
return label.SplitAndTrimString(aws.StringValue(value), ",")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func getMapString(i ecsInstance, labelName string) map[string]string {
|
|
if value, ok := i.containerDefinition.DockerLabels[labelName]; ok {
|
|
if value == nil {
|
|
return nil
|
|
}
|
|
if len(aws.StringValue(value)) == 0 {
|
|
return nil
|
|
}
|
|
return label.ParseMapValue(labelName, aws.StringValue(value))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Deprecated
|
|
func hasFirst(instances []ecsInstance, labelName string) bool {
|
|
if len(instances) == 0 {
|
|
return false
|
|
}
|
|
return hasLabel(instances[0], labelName)
|
|
}
|
|
|
|
// Deprecated
|
|
func getFirstStringValue(instances []ecsInstance, labelName string, defaultValue string) string {
|
|
if len(instances) == 0 {
|
|
return defaultValue
|
|
}
|
|
return getStringValue(instances[0], labelName, defaultValue)
|
|
}
|
|
|
|
// Deprecated
|
|
func getFirstBoolValue(instances []ecsInstance, labelName string, defaultValue bool) bool {
|
|
if len(instances) == 0 {
|
|
return defaultValue
|
|
}
|
|
return getBoolValue(instances[0], labelName, defaultValue)
|
|
}
|
|
|
|
func mapPToMap(src map[string]*string) map[string]string {
|
|
result := make(map[string]string)
|
|
for key, value := range src {
|
|
if value != nil && len(aws.StringValue(value)) > 0 {
|
|
result[key] = aws.StringValue(value)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func isEnabled(i ecsInstance, exposedByDefault bool) bool {
|
|
return getBoolValue(i, label.TraefikEnable, exposedByDefault)
|
|
}
|