Wash helps you deal with all your remote or cloud-native infrastructure using the UNIX-y patterns and tools you already know and love.
Wash aims to:
- make navigating stuff like servers, containers, or APIs as easy as navigating a local filesystem
- make scripting across your new-fangled infrastructure as easy as writing a local shell script
- render into text that which can be rendered into text (cuz text is a universal interface!) for easy viewing, editing, and UNIXy slicing-and-dicing
- build equivalents of basic, UNIX tools to support the above goals (but reuse existing ones if they work!)
- let you easily extend the system in whatever language you want
- be extremely simple to get up-and-running; if it takes you more than a few minutes, let us know!
Exploring, understanding, and inspecting modern infrastructure should be simple and straightforward. Whether it’s containers, VMs, network devices, IoT stuff, or anything in between…they all have different ways of enumerating what you have, getting a stream of output, running commands, etc. Every vendor has its own tools and APIs that expose these features, each one different, each one bespoke. Thus, they are difficult to compose together to solve higher-level problems. And that’s no fun at all!
UNIX’s philosophy and abstractions have worked for decades. They’re pretty good, and more importantly, they’re familiar to millions of people. Wash intends to apply those same philosophies and abstractions to modern, distributed infrastructure.
Wash is distributed as a single binary, and the only prerequisite is
libfuse. Thus, getting going is pretty simple:
- Download the Wash binary for your platform
- or install with
brew install puppetlabs/puppet/wash
- or install with
libfuse, if you haven’t already
- E.g. on MacOS using homebrew:
brew cask install osxfuse
- E.g. on CentOS:
yum install fuse fuse-libs
- E.g. on Ubuntu:
apt-get install fuse
- E.g. on MacOS using homebrew:
- Start Wash
At this point, if you haven’t already, you should fire up some resources that Wash can actually introspect. Otherwise, as Han Solo would say, “this is going to be a real short trip”. So fire up some Docker containers, create some EC2 instances, toss some files into S3, launch a Kubernetes pod, etc.
For more of a guided tour that includes spinning up some resources Wash can talk to, check out our
docker compose example.
Once the server is up, you can use vanilla
cd, etc. to explore. You can then start experimenting with Wash commands, like
wash ls and
wash tail, to navigate that filesystem in a more Wash-optimized way. Wash provides wrappers for some of these; you can usually find the native POSIX variants in
When you’re done,
exit the shell.
Wash does a lot already, with more to come:
- presents a filesystem hierarchy for all of your resources, letting you navigate them in normal, filesystem-y ways
- preserves history of all executed commands, facilitating debugging
- serves up an HTTP API for everything
- caches information, for better performance
We’ve implemented a number of handy Wash commands (docs):
wash ls- a version of
lsthat uses our API to enhance directory listings with Wash-specific info
- e.g. show you what primitives are supported for each resource
wash meta- emits a resource’s metadata to standard out
wash exec- uses the
execprimitive to let you invoke commands against resources
wash find- find resources using powerful selection predicates
wash tail -f- follow updates to resources that support the
streamprimitive as well as normal files
wash ps- lists running processes on indicated compute instances that support the
wash history- lists all activity through Wash;
wash history <id>can be used to view logs for a specific activity
wash clear- clears cached data for a subhierarchy rooted at the supplied path so Wash will re-request it
- docker: containers and volumes
- kubernetes: pods, containers, and persistent volume claims
- aws: EC2 and S3
- Wash allows for easy creation of out-of-process plugins using any language you want, from
goor anything in-between!
- Wash handles the plugin lifecycle. it invokes your plugin with a certain calling convention; all you have to do is supply the business logic
- users interact with external plugins the exact same way as core plugins; they are first-class citizens
For more information about future direction, see our Roadmap!
There are tons of ways to get involved with Wash, whether or not you’re a programmer!
Come and hang out with us on Slack! Feel free to ask questions, answer questions from other folks, or just lurk. Come and talk to us about things about modern infra you find complex or infuriating, or what your favorite hacking movie scenes are, or the best monospaced font.
Have something cool that you’d like connect up to Wash? We’d love to hear your ideas, and help you figure out how to do it! We don’t care if you want Wash to talk to a network device, a smart lightbulb, your bluetooth-enabled espresso scale, or just more types of resources from cloud providers.
Are you an artist? Design some Wash-related artwork or a logo, and we’ll see about putting it into the rotation for the site!
Are you an old skool command-line gearhead with, like, opinions about how things should work on a command line? We’d love your help figuring out how the shell experience for Wash should work. How can our unixy Wash commands behave better? Are there new commands we should build? What colors and formatting should we use for
wash ls? If we implemented
wash fortune, what quotes should be in there?!
Did you script something cool that usees Wash under the hood? Please let us know, and how we can help!
Can you sling HTML, or Markdown? This site is built using Hugo, and the source is in our github repo. We’d love help documenting stuff!
Did you give a talk or presentation on Wash? Give us the link, so we can help promote it!