Added Exoscale as Provider

Gopkg.toml

@@ -68,6 +68,10 @@ ignored = ["github.com/kubernetes/repo-infra/kazel"]
   name = "github.com/nesv/go-dynect"
   version = "0.6.0"
 
+[[constraint]]
+  name = "github.com/exoscale/egoscale"
+  version = "~0.9.31"
+
 [[constraint]]
   name = "github.com/oracle/oci-go-sdk"
   version = "1.8.0"

README.md

@@ -36,6 +36,7 @@ ExternalDNS' current release is `v0.5`. This version allows you to keep selected
 * [OpenStack Designate](https://docs.openstack.org/designate/latest/)
 * [PowerDNS](https://www.powerdns.com/)
 * [CoreDNS](https://coredns.io/)
+* [Exoscale](https://www.exoscale.com/dns/)
 * [Oracle Cloud Infrastructure DNS](https://docs.cloud.oracle.com/iaas/Content/DNS/Concepts/dnszonemanagement.htm)
 
 From this release, ExternalDNS can become aware of the records it is managing (enabled via `--registry=txt`), therefore ExternalDNS can safely manage non-empty hosted zones. We strongly encourage you to use `v0.5` (or greater) with `--registry=txt` enabled and `--txt-owner-id` set to a unique value that doesn't change for the lifetime of your cluster. You might also want to run ExternalDNS in a dry run mode (`--dry-run` flag) to see the changes to be submitted to your DNS Provider API.
@@ -58,6 +59,7 @@ The following tutorials are provided:
 * Google Container Engine
 	* [Using Google's Default Ingress Controller](docs/tutorials/gke.md)
 	* [Using the Nginx Ingress Controller](docs/tutorials/nginx-ingress.md)
+* [Exoscale](docs/tutorials/exoscale.md)
 * [Oracle Cloud Infrastructure (OCI) DNS](docs/tutorials/oracle.md)
 
 ## Running Locally

docs/tutorials/exoscale.md

@@ -0,0 +1,155 @@
+# Setting up ExternalDNS for Exoscale
+
+## Prerequisites
+
+Exoscale provider support was added via [this PR](https://github.com/kubernetes-incubator/external-dns/pull/625), thus you need to use external-dns v0.5.5.
+
+The Exoscale provider expects that your Exoscale zones, you wish to add records to, already exists
+and are configured correctly. It does not add, remove or configure new zones in anyway.
+
+To do this pease refer to the [Exoscale DNS documentation](https://community.exoscale.com/documentation/dns/).
+
+Additionally you will have to provide the Exoscale...:
+
+* API Key
+* API Secret
+* API Endpoint
+* Elastic IP address, to access the workers
+
+## Deployment
+
+Deploying external DNS for Exoscale is actually nearly identical to deploying
+it for other providers. This is what a sample `deployment.yaml` looks like:
+
+```yaml
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: external-dns
+spec:
+  strategy:
+    type: Recreate
+  template:
+    metadata:
+      labels:
+        app: external-dns
+    spec:
+      # Only use if you're also using RBAC
+      # serviceAccountName: external-dns
+      containers:
+      - name: external-dns
+        image: registry.opensource.zalan.do/teapot/external-dns:v0.5.5
+        args:
+        - --source=ingress # or service or both
+        - --provider=exoscale
+        - --domain-filter={{ my-domain }}
+        - --policy=sync # if you want DNS entries to get deleted as well
+        - --txt-owner-id={{ owner-id-for-this-external-dns }}
+        - --exoscale-endpoint={{ endpoint }} # usually https://api.exoscale.ch/dns
+        - --exoscale-apikey={{ api-key}}
+        - --exoscale-apisecret={{ api-secret }}
+```
+
+## RBAC
+
+If your cluster is RBAC enabled, you also need to setup the following, before you can run external-dns:
+
+```yaml
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: external-dns
+  namespace: default
+
+---
+
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRole
+metadata:
+  name: external-dns
+rules:
+- apiGroups: [""]
+  resources: ["services"]
+  verbs: ["get","watch","list"]
+- apiGroups: [""]
+  resources: ["pods"]
+  verbs: ["get","watch","list"]
+- apiGroups: ["extensions"]
+  resources: ["ingresses"]
+  verbs: ["get","watch","list"]
+
+---
+
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRoleBinding
+metadata:
+  name: external-dns-viewer
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: external-dns
+subjects:
+- kind: ServiceAccount
+  name: external-dns
+  namespace: default
+```
+
+## Testing and Verification
+
+**Important!**: Remember to change `example.com` with your own domain throughout the following text.
+
+Spin up a simple nginx HTTP server with the following spec (`kubectl apply -f`):
+
+```yaml
+apiVersion: extensions/v1beta1
+kind: Ingress
+metadata:
+  name: nginx
+  annotations:
+    kubernetes.io/ingress.class: nginx
+    external-dns.alpha.kubernetes.io/target: {{ Elastic-IP-address }}
+spec:
+  rules:
+  - host: via-ingress.example.com
+    http:
+      paths:
+      - backend:
+          serviceName: nginx
+          servicePort: 80
+
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: nginx
+spec:
+  ports:
+  - port: 80
+    targetPort: 80
+  selector:
+    app: nginx
+
+---
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    metadata:
+      labels:
+        app: nginx
+    spec:
+      containers:
+      - image: nginx
+        name: nginx
+        ports:
+        - containerPort: 80
+```
+
+**Important!**: Don't run dig, nslookup or similar immediately (until you've
+confirmed the record exists). You'll get hit by [negative DNS caching](https://tools.ietf.org/html/rfc2308), which is hard to flush.
+
+Wait about 30s-1m (interval for external-dns to kick in), then check Exoscales [portal](https://portal.exoscale.com/dns/example.com)... via-ingress.example.com should appear as a A and TXT record with your Elastic-IP-address.

main.go

@@ -151,6 +151,8 @@ func main() {
 		)
 	case "coredns", "skydns":
 		p, err = provider.NewCoreDNSProvider(domainFilter, cfg.DryRun)
+	case "exoscale":
+		p, err = provider.NewExoscaleProvider(cfg.ExoscaleEndpoint, cfg.ExoscaleAPIKey, cfg.ExoscaleAPISecret, cfg.DryRun, provider.ExoscaleWithDomain(domainFilter), provider.ExoscaleWithLogging()), nil
 	case "inmemory":
 		p, err = provider.NewInMemoryProvider(provider.InMemoryInitZones(cfg.InMemoryZones), provider.InMemoryWithDomain(domainFilter), provider.InMemoryWithLogging()), nil
 	case "designate":

pkg/apis/externaldns/types.go

@@ -86,6 +86,9 @@ type Config struct {
 	MetricsAddress           string
 	LogLevel                 string
 	TXTCacheInterval         time.Duration
+	ExoscaleEndpoint         string
+	ExoscaleAPIKey           string
+	ExoscaleAPISecret        string
 }
 
 var defaultConfig = &Config{
@@ -134,6 +137,9 @@ var defaultConfig = &Config{
 	LogFormat:                "text",
 	MetricsAddress:           ":7979",
 	LogLevel:                 logrus.InfoLevel.String(),
+	ExoscaleEndpoint:         "https://api.exoscale.ch/dns",
+	ExoscaleAPIKey:           "",
+	ExoscaleAPISecret:        "",
 }
 
 // NewConfig returns new Config object
@@ -187,7 +193,7 @@ func (cfg *Config) ParseFlags(args []string) error {
 	app.Flag("connector-source-server", "The server to connect for connector source, valid only when using connector source").Default(defaultConfig.ConnectorSourceServer).StringVar(&cfg.ConnectorSourceServer)
 
 	// Flags related to providers
-	app.Flag("provider", "The DNS provider where the DNS records will be created (required, options: aws, aws-sd, google, azure, cloudflare, digitalocean, dnsimple, infoblox, dyn, designate, coredns, skydns, inmemory, pdns, oci)").Required().PlaceHolder("provider").EnumVar(&cfg.Provider, "aws", "aws-sd", "google", "azure", "cloudflare", "digitalocean", "dnsimple", "infoblox", "dyn", "designate", "coredns", "skydns", "inmemory", "pdns", "oci")
+	app.Flag("provider", "The DNS provider where the DNS records will be created (required, options: aws, aws-sd, google, azure, cloudflare, digitalocean, dnsimple, infoblox, dyn, designate, coredns, skydns, inmemory, pdns, oci, exoscale)").Required().PlaceHolder("provider").EnumVar(&cfg.Provider, "aws", "aws-sd", "google", "azure", "cloudflare", "digitalocean", "dnsimple", "infoblox", "dyn", "designate", "coredns", "skydns", "inmemory", "pdns", "oci", "exoscale")
 	app.Flag("domain-filter", "Limit possible target zones by a domain suffix; specify multiple times for multiple domains (optional)").Default("").StringsVar(&cfg.DomainFilter)
 	app.Flag("zone-id-filter", "Filter target zones by hosted zone id; specify multiple times for multiple zones (optional)").Default("").StringsVar(&cfg.ZoneIDFilter)
 	app.Flag("google-project", "When using the Google provider, current project is auto-detected, when running on GCP. Specify other project with this. Must be specified when running outside GCP.").Default(defaultConfig.GoogleProject).StringVar(&cfg.GoogleProject)
@@ -220,6 +226,10 @@ func (cfg *Config) ParseFlags(args []string) error {
 	app.Flag("tls-client-cert", "When using TLS communication, the path to the certificate to present as a client (not required for TLS)").Default(defaultConfig.TLSClientCert).StringVar(&cfg.TLSClientCert)
 	app.Flag("tls-client-cert-key", "When using TLS communication, the path to the certificate key to use with the client certificate (not required for TLS)").Default(defaultConfig.TLSClientCertKey).StringVar(&cfg.TLSClientCertKey)
 
+	app.Flag("exoscale-endpoint", "Provide the endpoint for the Exoscale provider").Default(defaultConfig.ExoscaleEndpoint).StringVar(&cfg.ExoscaleEndpoint)
+	app.Flag("exoscale-apikey", "Provide your API Key for the Exoscale provider").Default(defaultConfig.ExoscaleAPIKey).StringVar(&cfg.ExoscaleAPIKey)
+	app.Flag("exoscale-apisecret", "Provide your API Secret for the Exoscale provider").Default(defaultConfig.ExoscaleAPISecret).StringVar(&cfg.ExoscaleAPISecret)
+
 	// Flags related to policies
 	app.Flag("policy", "Modify how DNS records are sychronized between sources and providers (default: sync, options: sync, upsert-only)").Default(defaultConfig.Policy).EnumVar(&cfg.Policy, "sync", "upsert-only")
 

pkg/apis/externaldns/types_test.go

@@ -68,6 +68,9 @@ var (
 		MetricsAddress:          ":7979",
 		LogLevel:                logrus.InfoLevel.String(),
 		ConnectorSourceServer:   "localhost:8080",
+		ExoscaleEndpoint:        "https://api.exoscale.ch/dns",
+		ExoscaleAPIKey:          "",
+		ExoscaleAPISecret:       "",
 	}
 
 	overriddenConfig = &Config{
@@ -114,6 +117,9 @@ var (
 		MetricsAddress:          "127.0.0.1:9099",
 		LogLevel:                logrus.DebugLevel.String(),
 		ConnectorSourceServer:   "localhost:8081",
+		ExoscaleEndpoint:        "https://api.foo.ch/dns",
+		ExoscaleAPIKey:          "1",
+		ExoscaleAPISecret:       "2",
 	}
 )
 
@@ -184,6 +190,9 @@ func TestParseFlags(t *testing.T) {
 				"--metrics-address=127.0.0.1:9099",
 				"--log-level=debug",
 				"--connector-source-server=localhost:8081",
+				"--exoscale-endpoint=https://api.foo.ch/dns",
+				"--exoscale-apikey=1",
+				"--exoscale-apisecret=2",
 			},
 			envVars:  map[string]string{},
 			expected: overriddenConfig,
@@ -235,6 +244,9 @@ func TestParseFlags(t *testing.T) {
 				"EXTERNAL_DNS_METRICS_ADDRESS":            "127.0.0.1:9099",
 				"EXTERNAL_DNS_LOG_LEVEL":                  "debug",
 				"EXTERNAL_DNS_CONNECTOR_SOURCE_SERVER":    "localhost:8081",
+				"EXTERNAL_DNS_EXOSCALE_ENDPOINT":          "https://api.foo.ch/dns",
+				"EXTERNAL_DNS_EXOSCALE_APIKEY":            "1",
+				"EXTERNAL_DNS_EXOSCALE_APISECRET":         "2",
 			},
 			expected: overriddenConfig,
 		},