Resin App Store


#1

I would love to see an app store for Resin.io apps. Docker just opened up the Docker store (https://store.docker.com) and it would be nice if we had somewhere we could easily publish our work for others to use without having to go through the git clone/remote add resin/push resin dance.
Taking unnecessary steps out of the middle may lead to broader adoption, and make Resin more generally accessible to less technical folks.
I think the ideal process would look like this:

  1. Image and install the SD card
  2. Create an app in the Resin dashboard
    • User has the option of using an existing, published app or getting a git endpoint to deploy their own
  3. If the user selects a pre-made app, they get an email notification when a new version is published and has a visual call to action, in the dashboard page for the application, to upgrade their app to the latest version.

Thoughts?


#2

Hey @ashmastaflash, interesting idea. Could think of a couple of hackish ways to test some of the aspects out.

I know it does not go all the way, but if would it help somewhat if people could deploy apps directly from github? Then it would be a matter of fork+deploy, something like:

  1. Create an application
  2. Download and flash the SD card image
  3. Fork an app’s repo on github, and use a (not yet created) integration to tie it to the app
  4. Deploy (single click or automatic)
  5. Future versions can me merged from upstream, and deployed the same way.

Not a full solution of course, though, might have an advantage for some of the apps that there’s a clear place to build a community around it (github/issues/pull requests/forks & network/gitter chat integration), which might get them to a larger audience too. This compared to when apps “live” inside resin.io and need to be curated, maintained, etc…

The notifications are also pretty doable (probably:) in this case as well.

These are just some thoughts how to get going and try it out the quickest. Do you have some ideas what apps you’d like to see? If yes, some could be good testing ground, build some proof-of-concept solutions (either as above, or any other way based on the experience building it). I’m excited :smiley:


#3

Do you need the ‘fork’ part? In the app case, lots of people would be deploying apps they didn’t intend to change the images for. You could plausible set up an integration that lets projects add a “Deploy to Resin” button to their Github projects, identically to the Deploy to Heroku buttons for web apps.

With that, you get the forking workflow for free on top too (after you fork it the button is still there and valid, it’s just now it’s in your repo so you can push updates too).

As an example, I’ve just set up https://github.com/resin-io-playground/resin-kodi on an rpi3 at home. I had to fork it, push it and set up my own env vars to get it working nicely. Doing all that in one click would’ve been great (and there’s a quite large rpi+kodi community that would jump on that like a flash I expect).


#4

Definitely a good aspect to explore!

I think it’s the matter of what is available for GitHub integrations. Those mostly work on your own repos, not other people’s repos. So my own repo should be associated with my own resin.io user. On the other hand, I can imaging an external service that can get around the forking. The use cases can be tricky, though, just as a starter, would you always-always want to run the latest version of a code? If it’s self service like the GitHub workaround, then I’d like to have a way to use known-good versions (which the fork enables).

The community side of that was, that with the fork project creators know when their application become popular and been used by others. Just a potential upside.

Still yeah, needs more thinking (and prototyping, I’m sure)


#5

I’d be interested in hearing more about how folks would want to see an app store for resin.io work. To @imrehg and @tim’s point, would people be interested in modifying the applications before deploying them or simply grabbing something that exists and pushing it to devices? (I suppose if all you needed to change were configuration values of some sort you could use environment variables with no code change.)

@ashmastaflash, do you have an example of what you’d want to see this working with? E.g. a user story about an app you’d want to deploy and how the process would work.


#6

Hi @mccollam!
It would be awesome if a user could browse apps in a store-like environment (think https://store.docker.com/) but instead of checking out images, the user has a call to action that instantiates the app within their own Resin account. That app would be less verbose as far as the web UI goes- you wouldn’t see build logs or the git remote add bit. Put an app upgrade link in the upper-right that flashes if a newer version of the app is available, and let the consumer decide when to upgrade it. Ideally, the user will not have to touch the CLI for anything at all. Just check out the app, configure environment variables, and image the SD card. Using git doesn’t intimidate me, but I can see others being intimidated by the whole process. If you can stay away from the CLI, you can enable less technical folks to use the service. This will go a long way toward enabling a developer to deliver an application through your service to non-technical users.

An example app would be https://github.com/sitch-io/sensor . Nothing important happens between cloning down and pushing to resin, it’s just a thing that you do to get the app built in Resin. If a user could just image devices and configure device variables, it would go a long way toward flattening the learning curve, and getting the app in the hands of the user without requiring an understanding of the technology used to deliver the service.


#7

Interesting. Thanks for the description, @ashmastaflash!

I think we would need to consider what the UX would need to be for all of this but most of the underpinnings are there already – you can share applications with other users and move devices from one app to another in the platform as it stands. I think what you described is a sort of special case of this workflow in fewer discrete steps.

I’ll mention @shaunmulligan who might be interested in this as well!