cloud-run-faq VS Pyramid

I kind of miss the point of this. So if I'm reading this right, fly.io practically only exposes the Pods API, but Kubernetes is really much more than that. I'm not very familiar with any serious company that directly uses Pods API to launch containers, so if their reimplementation of Pods API is just a shim, and they're not going to be able to implement ever-growing set of features in Kubernetes Pod lifecycle/configuration (starting from /logs, /exec, /proxy...) why even bother branding it Kubernetes? Instead they could do what Google does with Cloud Run (https://cloud.run/) which Fly.io is already doing?

I don't know why would anyone would be like "here's a container execution platform, let me go ahead and use their fake Pods API instead of their official API".

I agree with this sentiment. If your model is available as a file, yes you can use GCS and have your Cloud Function fetch it from its bucket upon start-up, but if performance matters, you should consider bundling your function into a container and running with Cloud Run instead, because you have filesystem access there (no need to make an API call to GCS if you can read it as a file).

I am building a HTTP Service running in Google Cloud Run in Go and wanted an easy way to log stuff to Google Cloud Logging.

Datastore mode had its start in App Engine's early days (launched in 2008), where its Datastore was the original scalable NoSQL database provided for all App Engine apps. In 2013, Datastore was made available all developers outside of App Engine, and "re-launched" as Cloud Datastore. In 2014, Google acquired Firebase for its RTDB (real-time database). Both teams worked together for the next 4 years, and in 2017, the next generation of Cloud Datastore was released, having merged in some of the Firebase RTDB features, and was re-branded as Cloud Firestore (in Datastore mode). This mode targets cloud compute as its users, whether serverless (App Engine, Cloud Functions, Cloud Run) or "serverful" (Compute Engine VMs, GKE/Kubernetes/Knative-compliant systems). If you provide a service via compute, use this mode.

You don't need to learn about containers unless that's something you wish to explicitly use to put together your app in a consistent, reproducible manner. Cloud Run is the service that can host your containerized app. If you are in this camp and have learned Docker, you can use that if you wish, but it's optional. Cloud Run (well, Cloud Build, the tool that builds your container for Cloud Run) can build your app by detecting what's in your app so a Dockerfile isn't needed. So like App Engine, Cloud Run can host your full-on web apps if desired. You don't even need to build the container image yourself. Both App Engine and Cloud Run deploy source code directly from the command-line, and along w/Cloud Functions, your app is generally deployed and available globally in less than 60 seconds.

Next to the docs, this page also is quite useful: https://github.com/ahmetb/cloud-run-faq

Actually meant to link this "unofficial" one.. Hope it helps a bit: https://github.com/ahmetb/cloud-run-faq

https://github.com/ahmetb/cloud-run-faq#can-i-mount-storage-volumes-or-disks-on-cloud-run

You don't need a framework for a single page. That being said, using a framework is probably a good idea if you intend to be on a growth curve.

Pyramid is a framework written to scale from a small, single-file site to a site that has grown horizontally scaled across multiple servers. If I understand your needs correctly, Pyramid is probably worth a look, here's a link: https://trypyramid.com/

Pyramid is under active development, and it has a large, helpful, welcoming user community.

Pyramid (https://trypyramid.com/) is nice in that it has URL dispatch predicates, like @view_config(header="HX-Target-Name=foo") which lets you have HTMX-specific view functions, which return only what is needed

Another option my professional web friends like is Pyramid: https://trypyramid.com/ -- it's for professional-level websites/apps that can't use Django for some reason.

Building, constructing, and maintaining websites is a broad definition of web development. A front-end, which communicates with the client, and a back-end, which contains business logic and interacts with a database, are typical components of web development. Python also supports quite a percentage of the total websites, web apps and software running in the world wide web. The libraries that are applied in web development include: Django, Flask, Pyramid and Turbogears and Web2Py

Pyramid

I've been looking for an alternative to Flask and found Pyramid (https://github.com/Pylons/pyramid). API looks great, lots of good design, almost everything I'm looking for, but it looks like this project is near dead. Not much movement since release 2.0, last commit 15th March 2021 (https://github.com/Pylons/pyramid/graphs/contributors).

i been messing with Laravel lately, and it's ass. and/or the entire modern stack is ass. i actually had this app built for me, and i asked the dev to try to strip out as much shit as possible, including, obviously, tailwind. dev did a good job, but it's still a disaster.

flask looks like a dream comparatively.

but. is there a middle ground?

i was a product manager-type on a (python) pylons pyramid project -- https://trypyramid.com/ -- "the start small, finish big, stay finished framework" -- the message sounds good.

seemed fine, but i wasn't a dev on it, and we still had plenty of moving parts for what was a relatively simple e-commerce cms (that, admittedly, had a lot of functionality).

what i really want is a straightjacket -- some framework that says, 'oh, you want to plug in a different templating engine? how about fuck you? will fuck you work for you?'

but i guess that doesn't earn many github stars.

if i had to pick one or recommend one with no other qualifiers, i'd pick sinatra. that way i could do it my way.

For Python, I would recommend Pyramid as a lightweight framework.

If your app is really small/short, you're only fetching crime data and rendering a static image, you can probably do it all with a Cloud Function. This way you don't even need to have nor learn about nor use full web frameworks like Flask, Django, Pyramid, etc. Just raw code plus an HTML template and perhaps a tiny bit of Flask/Jinja2 to render the template.