Can I run `arm64` images in railway?

RAILWAY_DOCKERFILE_PATH='Dockerfile' railway up --service 'api' --detach --environment 'production'

RAILWAY_DOCKERFILE_PATH='Dockerfile' railway up --service 'api' --detach --environment 'production'

FROM ipfs/kubo:latest as KUBO_BINARY
FROM ipfs/bifrost-gateway as BIFROST_BINARY

FROM --platform=linux/amd64 amd64/alpine:latest as ALPINE_BUILDER

RUN apk add --no-cache gcompat && \
  rm -rf /var/cache/apk/* && \
  rm -rf /tmp/*

COPY --from=KUBO_BINARY /usr/local/bin/ipfs /usr/local/bin/ipfs
COPY --from=BIFROST_BINARY /usr/local/bin/bifrost-gateway /usr/local/bin/bifrost-gateway

RUN which ipfs && \
  ipfs --version && \
  ipfs init

VOLUME /data/ipfs
VOLUME /export

EXPOSE 4001/tcp
EXPOSE 4001/udp
EXPOSE 5001/tcp
EXPOSE 8080/tcp

COPY ./scripts/entrypoint.sh /entrypoint.sh

RUN chmod +x /entrypoint.sh && cat /entrypoint.sh

ENTRYPOINT ["/entrypoint.sh"]

FROM ipfs/kubo:latest as KUBO_BINARY
FROM ipfs/bifrost-gateway as BIFROST_BINARY

FROM --platform=linux/amd64 amd64/alpine:latest as ALPINE_BUILDER

RUN apk add --no-cache gcompat && \
  rm -rf /var/cache/apk/* && \
  rm -rf /tmp/*

COPY --from=KUBO_BINARY /usr/local/bin/ipfs /usr/local/bin/ipfs
COPY --from=BIFROST_BINARY /usr/local/bin/bifrost-gateway /usr/local/bin/bifrost-gateway

RUN which ipfs && \
  ipfs --version && \
  ipfs init

VOLUME /data/ipfs
VOLUME /export

EXPOSE 4001/tcp
EXPOSE 4001/udp
EXPOSE 5001/tcp
EXPOSE 8080/tcp

COPY ./scripts/entrypoint.sh /entrypoint.sh

RUN chmod +x /entrypoint.sh && cat /entrypoint.sh

ENTRYPOINT ["/entrypoint.sh"]

ARG DENO_VERSION=1.36.1
FROM denoland/deno:bin-${DENO_VERSION} AS deno_bin

FROM ipfs/kubo:latest AS kubo_binary
FROM ipfs/bifrost-gateway:latest AS bifrost_binary

FROM debian:stable-slim AS final

ENV PORT="3031"
ENV ENV="production"
ENV IPFS_GATEWAY_HOST="http://127.0.0.1:8081"
ENV PROXY_GATEWAY_URL="http://127.0.0.1:8080"

# copy ipfs/kubo
COPY --from=kubo_binary /usr/local/bin/ipfs /usr/local/bin/ipfs
# # copy ipfs/bifrost-gateway
COPY --from=bifrost_binary /usr/local/bin/bifrost-gateway /usr/local/bin/bifrost-gateway
# # copy deno binary
COPY --from=deno_bin /deno /usr/local/bin/deno

WORKDIR /app

COPY ./scripts/entrypoint.sh ./src/* /app/

RUN chmod +x /app/entrypoint.sh

ENTRYPOINT ["/app/entrypoint.sh"]

ARG DENO_VERSION=1.36.1
FROM denoland/deno:bin-${DENO_VERSION} AS deno_bin

FROM ipfs/kubo:latest AS kubo_binary
FROM ipfs/bifrost-gateway:latest AS bifrost_binary

FROM debian:stable-slim AS final

ENV PORT="3031"
ENV ENV="production"
ENV IPFS_GATEWAY_HOST="http://127.0.0.1:8081"
ENV PROXY_GATEWAY_URL="http://127.0.0.1:8080"

# copy ipfs/kubo
COPY --from=kubo_binary /usr/local/bin/ipfs /usr/local/bin/ipfs
# # copy ipfs/bifrost-gateway
COPY --from=bifrost_binary /usr/local/bin/bifrost-gateway /usr/local/bin/bifrost-gateway
# # copy deno binary
COPY --from=deno_bin /deno /usr/local/bin/deno

WORKDIR /app

COPY ./scripts/entrypoint.sh ./src/* /app/

RUN chmod +x /app/entrypoint.sh

ENTRYPOINT ["/app/entrypoint.sh"]

package main

import (
    "fmt"
    "net/http"
    "os"
    "strings"

    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
)

func main() {
    ipfsGatewayHost, exists := os.LookupEnv("IPFS_GATEWAY_HOST")
    if !exists {
        fmt.Println("Error: IPFS_GATEWAY_HOST environment variable not set")
        os.Exit(1)
    }

    allowOrigins := strings.Split(os.Getenv("ALLOW_ORIGINS"), ",")

    r := chi.NewRouter()
    r.Use(middleware.Logger)

    r.Route("/", func(r chi.Router) {
        r.Use(corsMiddleware(allowOrigins))

        r.Get("/*", func(w http.ResponseWriter, r *http.Request) {
            // TODO
        })
    })

    http.ListenAndServe(":3031", r)
}

func corsMiddleware(allowOrigins []string) func(next http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            origin := r.Header.Get("Origin")
            for _, allowedOrigin := range allowOrigins {
                if origin == allowedOrigin {
                    w.Header().Set("Access-Control-Allow-Origin", origin)
                    break
                }
            }
            w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS, HEAD")
            w.Header().Set("Access-Control-Allow-Headers", "Content-Type")

            if r.Method == "OPTIONS" {
                w.WriteHeader(http.StatusNoContent)
                return
            }

            next.ServeHTTP(w, r)
        })
    }
}

package main

import (
    "fmt"
    "net/http"
    "os"
    "strings"

    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
)

func main() {
    ipfsGatewayHost, exists := os.LookupEnv("IPFS_GATEWAY_HOST")
    if !exists {
        fmt.Println("Error: IPFS_GATEWAY_HOST environment variable not set")
        os.Exit(1)
    }

    allowOrigins := strings.Split(os.Getenv("ALLOW_ORIGINS"), ",")

    r := chi.NewRouter()
    r.Use(middleware.Logger)

    r.Route("/", func(r chi.Router) {
        r.Use(corsMiddleware(allowOrigins))

        r.Get("/*", func(w http.ResponseWriter, r *http.Request) {
            // TODO
        })
    })

    http.ListenAndServe(":3031", r)
}

func corsMiddleware(allowOrigins []string) func(next http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            origin := r.Header.Get("Origin")
            for _, allowedOrigin := range allowOrigins {
                if origin == allowedOrigin {
                    w.Header().Set("Access-Control-Allow-Origin", origin)
                    break
                }
            }
            w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS, HEAD")
            w.Header().Set("Access-Control-Allow-Headers", "Content-Type")

            if r.Method == "OPTIONS" {
                w.WriteHeader(http.StatusNoContent)
                return
            }

            next.ServeHTTP(w, r)
        })
    }
}

resp, err := http.Get(...)
if err != nil{
    //handle the error
    return
}

defer resp.Body.Close()

io.Copy(rw, resp.Body)

resp, err := http.Get(...)
if err != nil{
    //handle the error
    return
}

defer resp.Body.Close()

io.Copy(rw, resp.Body)

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "path"
    "regexp"
    "strings"

    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
)

func main() {
    ipfsGatewayHost, exists := os.LookupEnv("IPFS_GATEWAY_HOST")
    if !exists {
        fmt.Println("Error: IPFS_GATEWAY_HOST environment variable not set")
        os.Exit(1)
    }

    allowOrigins := strings.Split(os.Getenv("ALLOW_ORIGINS"), ",")

    r := chi.NewRouter()
    r.Use(middleware.Logger)

    r.Route("/", func(r chi.Router) {
        r.Use(corsMiddleware(allowOrigins))

        r.Get("/*", func(w http.ResponseWriter, r *http.Request) {
            cid := path.Base(r.URL.Path)
            if !isPossiblyCID(cid) {
                http.Error(w, fmt.Sprintf("Invalid pathname: %s", r.URL.Path), http.StatusBadRequest)
                return
            }

            ipfsURL := fmt.Sprintf("%s/ipfs/%s", ipfsGatewayHost, cid)
            resp, err := http.Get(ipfsURL)
            if err != nil {
                http.Error(w, fmt.Sprintf("Failed to fetch IPFS URL: %s", ipfsURL), http.StatusBadRequest)
                return
            }
            defer resp.Body.Close()

            io.Copy(w, resp.Body)
        })
    })

    http.ListenAndServe(":3031", r)
}

func corsMiddleware(allowOrigins []string) func(next http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            origin := r.Header.Get("Origin")
            for _, allowedOrigin := range allowOrigins {
                if origin == allowedOrigin {
                    w.Header().Set("Access-Control-Allow-Origin", origin)
                    break
                }
            }
            w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS, HEAD")
            w.Header().Set("Access-Control-Allow-Headers", "Content-Type")

            if r.Method == "OPTIONS" {
                w.WriteHeader(http.StatusNoContent)
                return
            }

            next.ServeHTTP(w, r)
        })
    }
}

func isPossiblyCID(possibleCID string) bool {
    cidRegex := regexp.MustCompile(`Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,}`)
    return cidRegex.MatchString(possibleCID)
}

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "path"
    "regexp"
    "strings"

    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
)

func main() {
    ipfsGatewayHost, exists := os.LookupEnv("IPFS_GATEWAY_HOST")
    if !exists {
        fmt.Println("Error: IPFS_GATEWAY_HOST environment variable not set")
        os.Exit(1)
    }

    allowOrigins := strings.Split(os.Getenv("ALLOW_ORIGINS"), ",")

    r := chi.NewRouter()
    r.Use(middleware.Logger)

    r.Route("/", func(r chi.Router) {
        r.Use(corsMiddleware(allowOrigins))

        r.Get("/*", func(w http.ResponseWriter, r *http.Request) {
            cid := path.Base(r.URL.Path)
            if !isPossiblyCID(cid) {
                http.Error(w, fmt.Sprintf("Invalid pathname: %s", r.URL.Path), http.StatusBadRequest)
                return
            }

            ipfsURL := fmt.Sprintf("%s/ipfs/%s", ipfsGatewayHost, cid)
            resp, err := http.Get(ipfsURL)
            if err != nil {
                http.Error(w, fmt.Sprintf("Failed to fetch IPFS URL: %s", ipfsURL), http.StatusBadRequest)
                return
            }
            defer resp.Body.Close()

            io.Copy(w, resp.Body)
        })
    })

    http.ListenAndServe(":3031", r)
}

func corsMiddleware(allowOrigins []string) func(next http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            origin := r.Header.Get("Origin")
            for _, allowedOrigin := range allowOrigins {
                if origin == allowedOrigin {
                    w.Header().Set("Access-Control-Allow-Origin", origin)
                    break
                }
            }
            w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS, HEAD")
            w.Header().Set("Access-Control-Allow-Headers", "Content-Type")

            if r.Method == "OPTIONS" {
                w.WriteHeader(http.StatusNoContent)
                return
            }

            next.ServeHTTP(w, r)
        })
    }
}

func isPossiblyCID(possibleCID string) bool {
    cidRegex := regexp.MustCompile(`Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,}`)
    return cidRegex.MatchString(possibleCID)
}