add custom domain support for containers

thomas-tacquet · thomas-tacquet · commit 94d0b51ad75d · 2022-09-05T13:49:32.000+02:00
diff --git a/README.md b/README.md
@@ -32,7 +32,9 @@ serverless invoke --function first
 
 Serverless Framework handles everything from creating namespaces to function/code deployment by calling APIs endpoint under the hood.
 
-- [Serverless Framework: Deploy on Scaleway Functions](#serverless-framework-deploy-on-scaleway-functions)
+- [Scaleway Plugin for Serverless Framework](#scaleway-plugin-for-serverless-framework)
+  - [Quick-start](#quick-start)
+  - [Contents](#contents)
   - [Requirements](#requirements)
   - [Create a Project](#create-a-project)
   - [Configure your functions](#configure-your-functions)
@@ -341,7 +343,8 @@ You may refer to the follow examples:
 
 Custom domains allows users to use their own domains.
 
-For domain configuration please [Refer to Scaleway Documentation](https://www.scaleway.com/en/docs/compute/functions/how-to/add-a-custom-domain-name-to-a-function/)
+For domain configuration please refer to [custom domains on Function](https://www.scaleway.com/en/docs/compute/functions/how-to/add-a-custom-domain-name-to-a-function/) or
+[custom domains on Container](https://www.scaleway.com/en/docs/compute/containers/how-to/add-a-custom-domain-to-a-container/)
 
 Integration with serverless framework example :
 
diff --git a/deploy/lib/createContainers.js b/deploy/lib/createContainers.js
@@ -24,6 +24,84 @@ module.exports = {
     });
   },
 
+  applyDomains(containerId, customDomains) {
+    // we make a diff to know which domains to add or delete
+    const domainsToCreate = [];
+    const domainsIdToDelete = [];
+    const existingDomains = [];
+
+    this.listDomainsContainer(containerId).then((domains) => {
+      domains.forEach((domain) => {
+        existingDomains.push({ hostname: domain.hostname, id: domain.id });
+      });
+
+      if (
+        customDomains !== undefined &&
+        customDomains !== null &&
+        customDomains.length > 0
+      ) {
+        customDomains.forEach((customDomain) => {
+          domainsIdToDelete.push(customDomain.id);
+
+          let domainFound = false;
+
+          existingDomains.forEach((existingDom) => {
+            if (existingDom.hostname === customDomain) {
+              domainFound = true;
+              return false;
+            }
+          });
+          if (!domainFound) {
+            domainsToCreate.push(customDomain);
+          }
+        });
+      }
+
+      existingDomains.forEach((existingDomain) => {
+        if (
+          (customDomains === undefined || customDomains === null) &&
+          existingDomain.id !== undefined
+        ) {
+          domainsIdToDelete.push(existingDomain.id);
+        } else if (!customDomains.includes(existingDomain.hostname)) {
+          domainsIdToDelete.push(existingDomain.id);
+        }
+      });
+
+      domainsToCreate.forEach((newDomain) => {
+        const createDomainParams = { container_id: containerId, hostname: newDomain };
+
+        this.createDomain(createDomainParams)
+          .then((res) => {
+            this.serverless.cli.log(`Creating domain ${res.hostname}`);
+          })
+          .then(
+            () => {},
+            (reason) => {
+              this.serverless.cli.log(
+                `Error on domain : ${newDomain}, reason : ${reason.message}`
+              );
+
+              if (reason.message.includes("could not validate")) {
+                this.serverless.cli.log(
+                  "Ensure CNAME configuration is ok, it can take some time for a record to propagate"
+                );
+              }
+            }
+          );
+      });
+
+      domainsIdToDelete.forEach((domainId) => {
+        if (domainId === undefined) {
+          return;
+        }
+        this.deleteDomain(domainId).then((res) => {
+          this.serverless.cli.log(`Deleting domain ${res.hostname}`);
+        });
+      });
+    });
+  },
+
   createOrUpdateContainers(foundContainers) {
     const { containers } = this.provider.serverless.service.custom;
 
@@ -67,6 +145,14 @@ module.exports = {
       port: container.port,
     };
 
+    // checking if there is custom_domains set on container creation.
+    if (container.custom_domains && container.custom_domains.length > 0) {
+      this.serverless.cli.log("WARNING: custom_domains are available on container update only. "+
+        "Redeploy your container to apply custom domains. Doc : https://www.scaleway.com/en/docs/compute/containers/how-to/add-a-custom-domain-to-a-container/")
+    }
+
+    this.serverless.cli.log(`Creating function ${func.name}...`);
+
     this.serverless.cli.log(`Creating container ${container.name}...`);
 
     return this.createContainer(params)
@@ -91,6 +177,10 @@ module.exports = {
     };
 
     this.serverless.cli.log(`Updating container ${container.name}...`);
+
+    // assign domains
+    this.applyDomains(foundContainer.id, container.custom_domains);
+
     return this.updateContainer(foundContainer.id, params)
       .then(response => Object.assign(response, { directory: container.directory }));
   },
diff --git a/deploy/lib/createFunctions.js b/deploy/lib/createFunctions.js
@@ -59,7 +59,7 @@ module.exports = {
     const domainsIdToDelete = [];
     const existingDomains = [];
 
-    this.listDomains(funcId).then((domains) => {
+    this.listDomainsFunction(funcId).then((domains) => {
       domains.forEach((domain) => {
         existingDomains.push({ hostname: domain.hostname, id: domain.id });
       });
@@ -201,7 +201,7 @@ module.exports = {
     params.runtime = this.validateRuntime(
       func,
       availableRuntimes,
-      this.serverless.cli
+      this.serverless.cli,
     );
 
     // checking if there is custom_domains set on function creation.
diff --git a/deploy/lib/deployContainers.js b/deploy/lib/deployContainers.js
@@ -4,24 +4,41 @@ const BbPromise = require('bluebird');
 
 module.exports = {
   deployContainers() {
-    this.serverless.cli.log('Deploying Containers...');
+    this.serverless.cli.log("Deploying Containers...");
     return BbPromise.bind(this)
       .then(this.deployEachContainer)
-      .then(() => this.serverless.cli.log('Waiting for container deployments, this may take multiple minutes...'))
+      .then(() =>
+        this.serverless.cli.log(
+          "Waiting for container deployments, this may take multiple minutes..."
+        )
+      )
       .then(this.printContainerEndpointsAfterDeployment);
   },
 
   deployEachContainer() {
-    const promises = this.containers.map(
-      container => this.deployContainer(container.id),
+    const promises = this.containers.map((container) =>
+      this.deployContainer(container.id)
     );
     return Promise.all(promises);
   },
 
   printContainerEndpointsAfterDeployment() {
-    return this.waitContainersAreDeployed(this.namespace.id)
-      .then(containers => containers.forEach(
-        container => this.serverless.cli.log(`Container ${container.name} has been deployed to: https://${container.domain_name}`),
-      ));
+    return this.waitContainersAreDeployed(this.namespace.id).then(
+      (containers) => {
+        containers.forEach((container) => {
+          this.serverless.cli.log(
+            `Container ${container.name} has been deployed to: https://${container.domain_name}`
+          );
+
+          this.serverless.cli.log("Waiting for domains deployment...");
+
+          this.waitDomainsAreDeployedContainer(container.id).then((domains) => {
+            domains.forEach((domain) => {
+              this.serverless.cli.log(`Domain ready : ${domain.hostname}`);
+            });
+          });
+        });
+      }
+    );
   },
 };
diff --git a/deploy/lib/deployFunctions.js b/deploy/lib/deployFunctions.js
@@ -40,7 +40,7 @@ module.exports = {
             'Waiting for domains deployment...',
           );
 
-          this.waitDomainsAreDeployed(func.id)
+          this.waitDomainsAreDeployedFunction(func.id)
             .then((domains) => {
               domains.forEach((domain) => {
                 this.serverless.cli.log(`Domain ready : ${domain.hostname}`);
diff --git a/shared/api/domain.js b/shared/api/domain.js
@@ -5,10 +5,10 @@ const { manageError } = require("./utils");
 module.exports = {
   /**
    * listDomains is used to read all domains of a wanted function.
-   * @param {Number} functionId the id of the function to read domains. 
+   * @param {Number} functionId the id of the function to read domains.
    * @returns a Promise with request result.
    */
-  listDomains(functionId) {
+  listDomainsFunction(functionId) {
     const domainsUrl = `domains?function_id=${functionId}`;
 
     return this.apiManager
@@ -17,6 +17,20 @@ module.exports = {
       .catch(manageError);
   },
 
+  /**
+   * listDomains is used to read all domains of a wanted container.
+   * @param {Number} containerId the id of the container to read domains.
+   * @returns a Promise with request result.
+   */
+   listDomainsContainer(containerId) {
+    const domainsUrl = `domains?container_id=${containerId}`;
+
+    return this.apiManager
+      .get(domainsUrl)
+      .then((response) => response.data.domains)
+      .catch(manageError);
+  },
+
   /**
    * createDomain is used to call for domain creation, warning : this
    * function does not wait for the domain
@@ -48,29 +62,64 @@ module.exports = {
 
   /**
    * Waiting for all domains to be ready on a function
-   * @param {Number} functionId
+   * @param {UUID} functionId
    * @returns
    */
-  waitDomainsAreDeployed(functionId) {
+  waitDomainsAreDeployedFunction(functionId) {
     return this.listDomains(functionId)
       .then((domains) => {
-        let domainssAreReady = true;
+        let domainsAreReady = true;
+
+        for (let i = 0; i < domains.length; i += 1) {
+          const domain = domains[i];
+
+          if (domain.status === 'error') {
+            throw new Error(domain.error_message);
+          }
+
+          if (domain.status !== 'ready') {
+            domainsAreReady = false;
+            break;
+          }
+        }
+        if (!domainsAreReady) {
+          return new Promise((resolve) => {
+            setTimeout(() => resolve(this.waitDomainsAreDeployedFunction(functionId)), 5000);
+          });
+        }
+        return domains;
+      });
+  },
+
+  /**
+  * Waiting for all domains to be ready on a container
+  * @param {UUID} containerId
+  * @returns
+  */
+  waitDomainsAreDeployedContainer(containerId) {
+    return this.listDomains(containerId)
+      .then((domains) => {
+        let domainsAreReady = true;
+
         for (let i = 0; i < domains.length; i += 1) {
           const domain = domains[i];
+
           if (domain.status === 'error') {
             throw new Error(domain.error_message);
           }
+
           if (domain.status !== 'ready') {
-            domainssAreReady = false;
+            domainsAreReady = false;
             break;
           }
         }
-        if (!domainssAreReady) {
+        if (!domainsAreReady) {
           return new Promise((resolve) => {
-            setTimeout(() => resolve(this.waitDomainsAreDeployed(functionId)), 5000);
+            setTimeout(() => resolve(this.waitDomainsAreDeployedContainer(containerId)), 5000);
           });
         }
         return domains;
       });
   },
+  
 };
