Upload Website via FTP to webspace from pipeline

[sebastian-sommerfeld-io]

As a maintainer of the Krokidile project, I want to automate the deployment of the documentation website so that it updates on krokidile.sommerfeld.io every time a new version is released.

Acceptance Criteria

• [ ] Triggering: The deployment process is triggered automatically upon the release of a new version of Krokidile.
• [ ] Deployment: The updated documentation is deployed to krokidile.sommerfeld.io and is accessible to users.

Todos

• [ ] Implement in release.yml
• [ ] Try to avoid duplicating the build logic in the pipeline. Use the Dockerfile somehow?
• [ ] Update Link to the Terms of Use in the Krokidile sidebar (should point to docs page, not Github)
• [ ] Update the tags that should be part of the docs (exclude old tags, just start with one of the more recent versions)

[sebastian-sommerfeld-io]

Alternative: Cloud

For your requirements, you have several cloud providers and services to choose from that allow you to host a single Docker container with minimal setup. Here's a summary of some suitable options:

1. AWS Fargate (with Amazon ECS)

AWS Fargate allows you to run containers directly without having to manage the underlying infrastructure. You can use AWS ECS (Elastic Container Service) with Fargate to run your Docker container.

• Pros:
  • No need to manage servers.
  • Pay for what you use.
  • Integration with AWS services.
• Cons:
  • AWS ecosystem might have a learning curve if you're not familiar.

Terraform Example:

provider "aws" {
  region = "us-west-2"
}

resource "aws_ecs_cluster" "example" {
  name = "example"
}

resource "aws_ecs_task_definition" "example" {
  family                   = "example"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = "256"
  memory                   = "512"

  container_definitions = jsonencode([
    {
      name  = "example"
      image = "nginx:latest"
      essential = true
      portMappings = [
        {
          containerPort = 80
          hostPort      = 80
          protocol      = "tcp"
        }
      ]
    }
  ])
}

resource "aws_ecs_service" "example" {
  name            = "example"
  cluster         = aws_ecs_cluster.example.id
  task_definition = aws_ecs_task_definition.example.arn
  desired_count   = 1

  network_configuration {
    subnets = ["subnet-xxxxxxxx"]
    security_groups = ["sg-xxxxxxxx"]
  }
}

2. Google Cloud Run

Google Cloud Run allows you to run stateless containers that are triggered by HTTP requests. It's fully managed and scales automatically.

• Pros:
  • Fully managed.
  • Scales to zero (pay only for usage).
  • Simple deployment process.
• Cons:
  • Limited to stateless applications.

Terraform Example:

provider "google" {
  project = "my-gcp-project"
  region  = "us-central1"
}

resource "google_cloud_run_service" "example" {
  name     = "example"
  location = "us-central1"

  template {
    spec {
      containers {
        image = "gcr.io/my-gcp-project/example:latest"
      }
    }
  }

  traffic {
    percent         = 100
    latest_revision = true
  }
}

3. Azure Container Instances (ACI)

Azure Container Instances allows you to run containers directly without VM management.

• Pros:
  • Quick deployment.
  • Pay per second.
  • No VM management.
• Cons:
  • Limited to Azure ecosystem.

Terraform Example:

provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "example" {
  name     = "example-resources"
  location = "West US"
}

resource "azurerm_container_group" "example" {
  name                = "example-containergroup"
  location            = azurerm_resource_group.example.location
  resource_group_name = azurerm_resource_group.example.name
  os_type             = "Linux"

  container {
    name   = "example-container"
    image  = "nginx:latest"
    cpu    = "0.5"
    memory = "1.5"

    ports {
      port     = 80
      protocol = "TCP"
    }
  }

  ip_address {
    type            = "Public"
    ports {
      port     = 80
      protocol = "TCP"
    }
  }
}

Summary

• AWS Fargate: Good for those already in the AWS ecosystem and looking for serverless container solutions.
• Google Cloud Run: Ideal for stateless applications with automatic scaling.
• Azure Container Instances: Quick and easy container deployment in Azure.

Each of these services meets your requirement of not needing to manage the underlying infrastructure and can be deployed using Infrastructure as Code (IaC) tools like Terraform. Choose the one that fits best with your current or preferred cloud ecosystem.

[sebastian-sommerfeld-io]

Infrastructure as Code

• Deploy / update the app from the release.ym, workflow.
• Do not use terraform. I do. It want to manage the terraform state
• Pulumi probably also is oversized
• Use something more simple like gcloud (googles cloud cli) or maybe even plain webservices.
• make sure the https url from all-inkl points to the real app in the cloud. The url should remain the same. Do nut just redirect to some cryptic url.

[sebastian-sommerfeld-io]

https://youtu.be/AL2rAmWFZjM?si=RS77hF6YwuhbyVVI

https://youtu.be/nhwYc4StHIc?si=ilZX13rU02XVSHoc