home.social

Search

4 results for “wingman”

  1. RTL Nieuws @[email protected]

    𝗪𝗶𝗲𝗴𝗺𝗮𝗻 𝗯𝗹𝗶𝗷𝗳𝘁 𝗯𝗼𝗻𝗱𝘀𝗰𝗼𝗮𝗰𝗵 𝗘𝗻𝗴𝗲𝗹𝘀𝗲 𝘃𝗼𝗲𝘁𝗯𝗮𝗹𝘀𝘁𝗲𝗿𝘀 𝘁𝗼𝘁 𝗲𝗻 𝗺𝗲𝘁 𝗘𝗞 2029

    Sarina Wiegman blijft langer bondscoach van de Engelse voetbalsters. De 56-jarige Wiegman lag vast tot en met het WK van 2027 en heeft een nieuw contract getekend tot en met het EK van 2029.

    rtl.nl/nieuws/sport/artikel/56

    #Wiegman #bondscoach #EK2029

    #wiegman #bondscoach #ek2029
  2. Ayana Scroll @[email protected]

    Sarina Wiegman has signed a two-year contract extension with England Women, keeping her as Lionesses head coach until after Euro 2029.

    #Football #england #sarinawiegman #footballnews2026

    mondiaries.com/2026/10/lioness

    #footballnews2026 #sarinawiegman #england #football
  3. BBC News Top Stories @[email protected]

    Building Lionesses 2.0 - Wiegman's new challenge awaits

    England head coach Sarina Wiegman has changed women's football in the country, so what does she face after signing a contract extension?

    bbc.co.uk/sport/football/artic

    (c) #BBC #News #Sport #Football

    #bbc #news #sport #football
  4. Dev Community @[email protected]

    Coolify: The Open-Source Self-Hosted PaaS That Replaces Vercel, Heroku, and Netlify


    You deploy to Vercel. It works. Then the bill arrives. Or you hit a limit. Or you need a database that isn't on their approved list. Or you just want to run something on a $5 VPS you already own.

    Most developers know the managed PaaS names. Fewer know there's a 63k-star open-source alternative that gives you the same push-to-deploy experience on your own servers — with 360+ one-click services, automatic HTTPS, preview deployments, and zero vendor lock-in.

    That alternative is Coolify.

    What Coolify Actually Is


    Coolify is an open-source, self-hostable Platform-as-a-Service. You install it on a server (VPS, bare metal, Raspberry Pi, anything with SSH), and it becomes your personal Vercel/Heroku/Netlify.

    But the architecture is fundamentally different from managed platforms:

    Managed PaaS (Vercel/Heroku)Coolify (Self-Hosted)Control plane + runtime + infrastructure bundledControl plane only — you provide the serversYou deploy to their cloudYou deploy through Coolify to your serversVendor lock-in: configs, data, routing all live with themYour configs stay on your servers. Stop using Coolify? Your apps keep running.Pricing scales with usageFree (Apache 2.0). You pay only for your VPS.


    The key insight: Coolify separates the control plane from the workload runtime. The Coolify instance stores configuration and coordinates actions via SSH. Docker on each connected server runs your actual applications, databases, and services.

    Your application traffic never passes through the Coolify server. Requests hit the reverse proxy (Traefik or Caddy) on the resource server directly.

    The Architecture: Control Path vs. Traffic Path


    This is the part most developers misunderstand.

    Control Path (Coolify → Your Server)


    • You click "Deploy" in the dashboard (or push to Git)
    • Coolify reads config from its PostgreSQL database
    • Queues the job via Laravel Horizon + Redis
    • SSHes into the target server
    • Runs Docker commands: build, pull, start containers, configure networks


    Traffic Path (User → Your App)


    • DNS points your domain to the resource server (not the Coolify server)
    • coolify-proxy container (Traefik/Caddy) terminates TLS
    • Routes request over Docker network to your app container
    • Coolify control plane is not in the request path

    This means:

    • If the Coolify dashboard goes down, your running apps stay up
    • If you lose SSH to a server, existing containers keep serving traffic
    • You can run Coolify on one $5 VPS and deploy to ten other servers


    What You Can Deploy


    Applications (from Git):

    • Static sites (Next.js, Astro, Vite, Hugo, etc.)
    • Node.js, Python, Go, Rust, PHP, Ruby, Java, .NET, Bun, Deno
    • Dockerfile, Docker Compose, Nixpacks, Railpack, or prebuilt images
    • Automatic framework detection via Nixpacks/Railpack

    Databases (one-click, managed):

    • PostgreSQL, MySQL, MariaDB, MongoDB, Redis, KeyDB, Dragonfly, ClickHouse
    • Persistent volumes, automated S3-compatible backups, optional public access

    360+ One-Click Services:

    • Analytics: Plausible, Umami, PostHog
    • Auth: Logto, PocketBase, Authentik
    • Databases: Supabase, NocoDB, Baserow
    • AI: Ollama, Open WebUI, AnythingLLM
    • Dev tools: GitLab, Gitea, Drone, Woodpecker
    • Productivity: Nextcloud, Outline, Cal.com, N8n
    • Monitoring: Uptime Kuma, Grafana, Prometheus
    • And hundreds more — each with generated credentials, persistent storage, and health checks


    Build Methods: How Your Code Becomes a Container


    Coolify doesn't force one build system. Pick per project:

    MethodUse WhenNixpacksZero-config builds for most frameworks (auto-detects Node, Python, Go, etc.)RailpackFaster, Rust-based alternative to Nixpacks (beta)DockerfileFull control — you write the DockerfileDocker ComposeMulti-container apps (app + db + redis + worker)StaticPre-built static sites (output folder → nginx)Docker ImagePull ghcr.io/user/app:v1.2.3 — no build step


    Smart caching: For Git sources using Nixpacks/Railpack/Dockerfile, Coolify tags images with the commit SHA. If the commit and build config haven't changed, it skips the build entirely and reuses the existing image.

    Build servers: Offload builds to a dedicated server (saves resources on small VPS). The build server pushes the image to a registry; deployment servers pull it.

    Deployment Strategies: Zero-Downtime by Default


    For single-container apps, Coolify uses rolling updates:

    1. Build/pull new image (current container keeps running)
    2. Start new container on same Docker network
    3. If health check configured → wait for healthy
    4. Switch proxy routing to new container
    5. Remove old container

    Stop-then-start fallback when rolling isn't possible (host port mappings, fixed container names, preview deployments).

    Docker Compose uses docker compose up reconciliation. Swarm uses docker stack deploy.

    Instant rollback: Every successful deployment retains its image. One click → previous version running in seconds. (Does not restore database data — keep separate backups.)

    Networking: Three Paths, Clear Boundaries

    1. Public HTTP/HTTPS (via Coolify Proxy)


    • Domain → DNS → Resource Server IP
    • coolify-proxy (Traefik/Caddy) on port 80/443
    • TLS via Let's Encrypt (automatic)
    • Proxy forwards over Docker network to container port


    2. Private Container Traffic


    • Shared Docker network (coolify by default)
    • Containers talk via service name + internal port
    • No public exposure, no host ports
    • Databases, internal APIs, worker queues


    3. Direct Host Ports


    • host_port:container_port mapping
    • Bypasses proxy entirely
    • For non-HTTP protocols (TCP/UDP, databases with external clients)
    • Disables rolling updates for that resource

    Your responsibility: DNS records, firewall/security groups (80, 443, SSH, any direct ports), making apps listen on the configured container port.

    Data Persistence: What Survives a Redeploy

    LayerLocationSurvives Redeploy?Coolify config (projects, env vars, credentials)Coolify instance (PostgreSQL)YesDocker images, build artifacts, containersConnected serverImages yes, containers replacedApplication data (uploads, SQLite, generated files)Docker volumes / bind mountsYes — if configuredDatabase dataDocker volumes or external managed DBYesReverse proxy config + TLS certsResource serverYes


    Critical: Unmounted container filesystem data is lost on redeploy. Configure persistent volumes for anything that must survive.

    The MCP Integration: AI Agents That Can Deploy


    Coolify exposes an MCP (Model Context Protocol) server at https://your-coolify/mcp. Connect Claude, Cursor, or any MCP client — your AI agent can:

    • List resources, servers, deployments
    • Trigger deployments
    • Read logs, restart services
    • Troubleshoot failed deployments

    All with the same API tokens and team permissions you already use. This is a genuinely useful AI integration — not a gimmick.

    What You Actually Need to Run It


    Minimum self-hosted setup:

    • 1 server for Coolify (2 GB RAM, 2 vCPU, 30 GB disk)
    • 1+ servers for deployed resources (scale as needed)
    • Docker Engine 24+
    • SSH access (key-based)
    • Domain for the Coolify dashboard (for HTTPS)

    Install:

    curl -fsSL cdn.coollabs.io/coolify/instal… | bash

    That's it. The script sets up the three base containers (coolify, coolify-db, coolify-redis), the reverse proxy, and the coolify Docker network.

    What Coolify Does NOT Give You (And That's Fine)


    • Managed infrastructure — you provision, secure, and monitor your VPS
    • Global edge network — your app runs where your server is (add Cloudflare CDN if needed)
    • Automatic horizontal scaling — you add servers, Coolify deploys to them
    • Built-in CI/CD beyond Git push — webhooks integrate with GitHub Actions/GitLab CI
    • SLA or support contract — it's open source (Coolify Cloud exists if you want managed)


    The Trade-offs, Honestly

    Coolify WinsManaged PaaS WinsZero vendor lock-inZero ops burdenRun anything Docker supportsGlobal edge by defaultPredictable cost (VPS pricing)Automatic scalingFull data ownershipManaged databases with HA360+ services one-clickEnterprise compliance certsMCP for AI agentsTeam SSO/SAML (Coolify has 2FA + OAuth)

    Why This Matters for Developers


    You've deployed to Vercel. You've paid for Heroku dynos. You've configured Netlify build plugins.

    Coolify lets you own the platform layer without building it from scratch. It's not "Kubernetes the hard way" — it's a Laravel + Docker control plane that speaks SSH and gives you a dashboard, API, CLI, and now MCP.

    For side projects, client work, internal tools, or production apps where you want control over infrastructure: Coolify is the middle ground between "manual Docker on a VPS" and "$500/month managed PaaS."

    The repository: github.com/coollabsio/coolify (63.2k stars, 698 contributors, Apache 2.0)#opensource #selfhosted #paas #docker #software #coding #development #engineering #inclusive #community
    Coolify: The Open-Source Self-Hosted PaaS That Replaces Vercel, Heroku, and Netlify

    #paas #inclusive #docker #engineering #development #coding
Share on Mastodon

Enter the server where you have an account.