Modeling

As often I started sketching out a basic model of what I thought it should look like. The main reason to not just start building and “designing” on the fly was because I had no clue what the angles needed to be.

So my idea was to use leftover strips of a 2x4 and cut them into 16 pieces with the same dimensions. Since the overall shape is supposed to resemble roughly a circle, I needed to cut the mating surfaces with an angle of 78.75°. The math to get there is:

360°/16=22.5°

Since these 22.5° are equally split to the two sides, each of these sides is going to be 11.25° away from square, or 78.75° from the outer edge.

Materials & Tools

To build this tray I’ve used some offcuts from 2x4’s, a piece of 1/4” plywood, a pocket hole jig plus the respective screws, and glue. For the liner I cut up a red felt place mat.

BTW, today I know that gluing the wooden blocks together would have been enough since they are also glued to the plywood bottom. At the time (this build actually happened in May 2021) I was convinced the screws were necessary. Heck, I didn’t even have painters tape yet, so apparently I did use regular office adhesive tape. Well, we all have to start somewhere…

But I did have a corner band clamp, so I used that in the process, though this is particularly useful in cases where the angles are not cut accurately which leads to gaps - which this strap can help closing.

For the final finish I’ve used a spray can of lacquer as I was told this would give a nice and relatively durable finish that is easy to apply and doesn’t darken much over time.

Construction

The build itself was pretty straight forward. I cut the leftover strips of 2x4 into pieces of roughly 3” x 1.5” x 1”. After planing and sanding everything the final measurements were slightly below that, but didn’t matter too much anyway. I’ve just updated my 3D sketch to reflect the new measurements as well. in case I ever need to repair or remake it.

The angled ends of the blocks I’ve on the table saw using a miter gauge as that’s way safer than cutting such small parts with the miter saw. Unless one has a method of holding them in place properly without using their own fingers so close to the blade. Also, these small off-cuts like to turn into ninja-star-like projectiles on a miter saw…

Then I’ve put the pocket holes in using my Armor Tools jig.

Once all 16 parts were done I’ve taped and glued them together and tightened with the band clamp. After that I screwed them together while holding them down tight with clamps so nothing could move other than the screws.

The next task was to put a thin plywood panel on as a bottom and trim its edges. For that I cut the shape with a jigsaw, leaving it protruding by an eighth of an inch, then used a router and a trim bit to cut it flush. I glued on the panel, and then used three screws to secure it even more (again, not really necessary as the glue is plenty strong).

Wood Finish

As mentioned earlier I went with lacquer in a spray can to give the wood a nice finish. The application was easy and quick, and it has held up really well over the past three years. While the lacquer’s appearance is like that of a water-based polyurethane, the application is so much easier. It quickly dries, and multiple layers are easy to put on as well. The only thing to keep in mind is to not over-spray it - leave spots that still seem dry for the next layer to cover.

Liner

Now only one piece was still missing: a liner. For that I used one of our old place mats that which were made from red felt. These I saved from the garbage bin earlier that year, intending to use them for something exactly like this. I cut one piece that perfectly fit the inner bottom of the tray, and then a long strip that fit all around the inner side wall. I glued them on with a spray adhesive.

The Finished Project

Once the math was figured out the real difficulty for me at the time was once more the lack of experience. I used a lot of screws that weren’t really necessary - and also increased the weight quite a bit. However, this tray is now so sturdy, that I can pick it up with whatever somebody left on it without having to fear it coming apart.

In the years since the tray has seen quite some rounds of Dungeons & Dragons, Sorry! and others. It holds up very well, and the only minor nuisance is its size: with about 13.5” it sometimes appears a little too big to use it on a crowded desk or table, i.e. in a Zoom-D&D session. But on the other hand it is perfect for when we sit with the kids at the dining or coffee table and everybody can easily reach and use it.

I think I’ll make some more of these, maybe for next holiday season? But a little bit smaller and with different shapes, maybe…

However, when checking online for loft beds to buy we noticed that those actually available and of seemingly good quality are pretty expensive, and those which weren’t didn’t look like I would trust them with my kid’s life every night for years.

So I decided to build one myself, and there are plenty resources available online for inspiration.

Modeling

As so often in the past I started sketching out a basic model of what I considered a nice looking but also stable build on paper. Then my kid got some say in the final shape as well, and once we were on the same page I’ve built a respective model in SketchUp 2017.

Materials

The materials used in this project were basically construction lumber and hardware:

• 4 14’ long 2x12 pine boards
• 2 6’ long 1x1 strips of poplar
• a box of 2.5” long 3/8”-16 carriage bolts plus washers and locking nuts
• a couple dozen deck screws in lengths 3”, 2” and 1-1/4”
• a good dozen of 4” and 2=1/4” cabinet bolts each, plus the respective amount of barrel nuts

The slatted mattress base we’ve actually bought from a furniture store.

Preparation

Before I bought the boards, I’ve calculated the exact amount of wood I needed, then gathered information about what is available to me close by, that is of a decent quality and size. A local lumber yard had the perfectly sized pine boards available, and that to a reasonable price. So I put on the trailer and got these 4 boards, picking them from the lot by determining how I could make the most out of the material. I had to already figure how I would cut them so I could avoid knots that were too large to have them in the build in places where the structural integrity would suffer.

I was also planning on some pieces that I could rip in half to get double the amount of boards for the guard rails, as well as creating waste pieces which I then could cut other smaller pieces from. The “OpenCutList” plugin for SketchUp as well as the Cut List Optimizer were helping a lot with that. I only had to minimally alter the suggestions to account for knots and holes in the boards before making final cutting decisions.

Once I’ve known how to cut up each board I’ve marked all future parts clearly with respective marks on painters tape and noted the same marks down in the cutting plan.

Tools

For the most part the tools used for this build were quite basic for a more serious hobby-woodworker, I think: a table saw to cut up the boards, a planer to get nice surfaces (I used both, an benchtop planer as well as a hand plane), several power drills and impact drivers plus the respective drill, drive and forstner bits.

I did pre-drill and countersink the deck screws even though they are supposed to self-drill and -sink as I wanted to reduce the stress on these relatively delicate pieces. An electric brad nailer helped keeping the guard rails in place after aligning them with the legs, which made it so much easier to screw them on.

I did plane some parts with a hand plane as they were too short for the benchtop planer or had angled surfaces.

I’ve also used the router table to joint some parts, as well as a handheld router to route out the mortises where the ladder steps were set in. To create the necessary template first I’ve used a 1/4” spiral bit in combination with a pattern ring and a variable template. Once I got the template for the mortises right I used a 1/2” mortising bit with it on the ladder parts.

The forstner bit removed a part of the waste and created room for the router bit to get an easier start.

One tool I actually bought for this build is a drill guide that helped to repeatedly drill straight holes in a 90 degree angle as I needed to make sure they meet when putting two 1 to 1.5” thick boards together. As the boards were way to long to handle them inside my workshop on my small drill press the Milescraft drill aid I got for this proved to be extremely helpful.

Since I have the luxury of having a second table saw I can cut larger boards and sheets outside my shop, before taking the smaller parts inside. That saw is my previous table saw and is now mounted onto the unused rolling/folding stand of my current saw. This makes it easy to wheel around, so I put it up wherever I need it. For ripping long boards I temporarily attach my add-on fence from the other saw as it gives almost double the surface for the board to ride against. Otherwise I’d have to wheel out my table saw cabinet every time, and that would not be as much fun (though it would be possible).

Parts

The bed’s construction consists of three main parts: frame, legs, and guard rails. All of these parts were cut from the 4 boards I started with. The only “external” addition to that was a pair of 1x1 poplar runners that I screwed to the frame so the slatted mattress base can rest on them.

The frame

The main structural component of the bed is its horizontal frame. It is comprised of a set of 2x6 that are butt-joined with cabinet bolts and barrel nuts. Inside the frame are the poplar strips mounted to the long sides so the mattress base has something to sit on. The frame then also got a couple 3/8” through-holes where it then is mounted to the legs. These holes are bored out on the inside with a forstner bit so the hex nuts clear the mattress base.

The legs

In the back the bed stands on legs that are also cut as 2x6, while the front leg on one side is only 4.5”, so it appears a little less bulky. The other front leg actually is the ladder that allows the kid to climb up, plus another 2x4 to allow for easier mounting to the frame.

All legs incl. the ladder have a 1/2” recess cut into them all at the same height, so the frame sits inside of a half lap. This increases general stability and helps spreading the rocking and shearing forces away from the 2 carriage bolts each leg is mounted with. About 5” from the floor another frame stabilizes the construction at the bottom on three sides to further reduce possible movements.

The ladder

The ladder is an integral part of the bed’s structure as it replaces the fourth leg. The steps are set in 1” deep mortises, and fixed with deck screws from the outside. These screws are set in two different angles on each side to make the construction more durable.

The guard rails

This is the “fence” at the top of the bed that protects the occupant from falling off. It is made of 5/8 thick and 2x3 wide boards that are mounted to the frame with some 1.5” pieces of 2x3 and to the legs directly. They are also connected to each other via cabinet bolts and barrel nuts. The connection with the legs was originally intended to be done with short cabinet bolts and fitting nuts, but I forgot to account for the loss of thickness of the boards due to planing them. Since they were made by ripping 1.5” thick boards into supposedly 3/4” thick pieces, their thickness was already going to be at least half a saw blade kerf (which in this case would be 3/64” each) less than 3/4”, but then I had to plane them quite a bit as the cutting quality wasn’t optimal, and neither were the outer surfaces.

So I had to improvise and decided to go with deck screws instead. This has the benefit that the connection is sturdier by using three screws per joint instead of one bolt. On the other side the looks aren’t as good - on the inside one can see the screw heads, and on the outside the recurring element of the nice-looking flat cabinet bolt heads is missing. But I had to finish the bed so I didn’t have time to remake the respective parts from additional material, and my kid likely will never care about a certain type of fastener anyway.

Difficulties

I already mentioned the boards that were a tad too thin. Besides that there were other things that didn’t quite work out as expected. For instance I kept messing up where to drill the holes for the cabinet bolts, so I ended up filling holes by glueing in wooden dowels - which I also had to make first.

When trying to connect the stretchers at the bottom with the legs I had so many problems to get everything lined up and seated neatly I ran out of patience and ended up using 5” deck screws which I salvaged from an old workbench I’ve demolished recently. I screwed them in diagonally so they crossed each other, similar to how it’s done with beams in framing.

Then I forgot that I’ve used screws to put together the ladder, and promptly destroyed a brand new router bit when routing out the dados for the frame as - of course - I hit a screw. For a moment I was wondering why there were sparks everywhere before it dawned on me… However, the bit still finished its job relatively well, but required a little bit of cleanup afterwards as the corners of the carbide blades of the bit broke off. So I guess I won’t use that bit any longer.

ToDo

Paint

My kid has chosen a set of three colors of which I already bought a couple small cans, and which I will put on once we are sure there are no more changes required. Then I’ll put on these three paints plus a clear coat on top to make them more durable.

Subsequent changes

One change my kid has asked me to do after I’ve finished the actual build: widen the “entrance” at the top of the ladder a bit as it turned out to be too narrow. The gab between the ladder’s stiles is 12 inches, which is the maximum I could provide as there is a sleeper sofa that needs to fit between the ladder and the other leg when pulled out. For now the idea is to cut off a couple of inches at the upper ends of the ladder itself, and then smooth out the remaining surfaces and edges so it feels extra nice to the touch.

Additions planned

An addition that is already in my plan but hasn’t been done yet is a set of shelves the kid asked to build as well. They are going to be mounted to the head end of the bed, that not only provides space for a night light, a glass of water, a book, etc., but also allows for blocking out the sun when needed. We haven’t finalized the design just yet, so this may also take quite some more time to get done.

I’ll update this post once I’ve finished these tasks as well.

The (kind of) finished project

For a couple of weeks this bed is now already in use as we needed the sleeper sofa otherwise, and the kid loves it so far. It turned out quite nice, even without any paint on. The entire build took me about three weeks of work including the modeling and material purchasing runs.

Did it, in hindsight, make sense to build it myself? Absolutely, the passion and enthusiasm for a project like this is exactly what brought me into woodworking in the first place. Was it cheaper than buying a bed in a store? Not necessarily, as for the roughly $250 for the material we could have bought one that would at least get the job done. For something as nice and sturdy as I’ve built it the costs would have been at least twice as much, though there seems to be no upper limit.

As I have more time at my hands at the moment and want to build up more skills anyway I happily invested the time needed to plan and build this bed.

Some of that time I did kind of waste by working around the lack of certain tools (or knowledge). For instance a small pattern routing bit would have made routing out the mortises for the ladder steps so much easier. Another time I just made life harder on myself and had to remake the steps entirely because I removed too much material when cutting the tenons the first time, making them too weak for my liking. Or when I messed up the holes for the cabinet bolts…

And of course I got sidetracked multiple times, i.e. to build a miter saw station, or to make a new table saw sled, or to build a dado template.

However, the best of all in this is that my kid got to have a say in how it had to be designed and even was able to help with the assembly of some parts - and this is invaluable.

To be clear: this is not meant to be the “ultimate miter saw station” as many woodworking content creators seem to claim for their own builds and adaptations, but rather my own attempt to use the available space in my small shop as efficiently as possible.

Modeling

As so often I used the free SketchUp 2017 to create a model that was initially inspired by some tutorials I have seen in woodworking magazines. That means it has a similar bottom as my table saw stand, which consists of reinforced 3/4” plywood and sits on four 3” swivel casters.

Dust collection

Initially I was also planning to install a dust hood I have found in SketchUp’s 3D-model warehouse, which I intended to build from 1/4” plywood. But when I was finally ready to start with that part another interesting way became available: the YouTube content creator Shop Nation had developed a nice dust chute replacement for the miter saw model I have (Ridgid 4251 a.k.a. Delta Cruzer 12”) and added it to his online shop. As I also own a 3D printer I’ve bought the respective 3D print files from Shop Nation, then just printed that port and installed it - and I’m very pleased with how well it works. I might build the hood at a later point if it turns out I use the saw more often and the current solution couldn’t keep up well enough.

Materials

The building material in this project is mainly ACX plywood in the nominal thicknesses of 1/4”, 1/2” and 3/4”. Have I used mainly scraps for my shop projects in the past, this time around I’ve shelled out some money to buy good quality plywood from a local hardwood store, which all the structural parts and the drawers are made from. Just the drawer fronts are from some scraps of poplar plywood, which is a lot more lightweight than ACX, but looks a lot better, too.

Base cabinet

The cabinet consists of two sides, a wider bottom panel to increase stability, and two strips across the top, so basically just like a regular kitchen cabinet (except for the bottom). A 1/2” thick back panel gives the cabinet its rigidity.

Since the original plan included a dust hood, which was supposed to drop the dust and chips to the bottom of the cabinet’s rear, there is a gap between the upper three drawers and the rear end of the cabinet. This gap is closed off from the drawers by an additional panel, acting as a sort of dust/chips chute and has a hole on one side, where the hose of the dust collector was supposed to go. This has currently no function, but it still causes the upper three drawers to be a couple inches shorter. It isn’t a problem for me, so it likely will stay like that forever. Since this extra panel is also 3/4” thick it further increases the cabinet’s stability, which will be important when I have to wheel it in and out of the shop later.

To reinforce the bottom I’ve glued and screwed a piece of a 2x4 along each of the front and back edges underneath the bottom. This is enough to carry the weight of the cabinet, the drawer’s contents, the saw itself, and any workpieces on top of it.

All panels were joined with pocket hole screws.

Top

In addition there is another 3/4” panel screwed to the top stretchers to give the saw a flat surface to sit on. This panel covers the entire cabinet’s top and spreads the weight of the saw and everything else on top equally over both sides.

Drawers

The miter saw station has 5 drawers total, with 3 different heights. The two bottom drawers are the largest, with about 7.5” each. The next two drawers are only 6,5” high, and the top drawer is a little lower at almost 4”. This is different than what the SketchUp model shows, with the reason being my better understanding of my shop storage needs later into the build.

This setup allows me to store larger tools like routers and their bases in the bottom drawers, and smaller stuff incl. screws and other hardware to go into the upper ones.

The drawer parts were all joined with the 1/4-1/4-1/4 method: The sides get either a groove or a rabbet on both ends as well as a groove at the bottom, all being 1/4” wide. Once the router or the table saw are set up properly this allows for a continuous workflow, where everything is cut with just this one setting, and the orientation of the board dictates the actual cut being made. Then all pieces can be glued together - square, strong, and without any hardware.

Slides

For the slides I chose to go with some good quality soft-closing slides. Slides without this feature would cause a lot of stress on the cabinet structure when not handled carefully, and the last thing I want is for the station to become unstable. Shop furniture doesn’t need to be pretty, but it has to be sturdy at least.

It doesn’t have to be ugly either, so I’ve opted for some nice looking fronts, which also keep most of the dust out of the drawers.

Handles

The handles are also cut from ACX as I wasn’t willing to buy any from a hardware store and wanted to try making my own ones anyway. Their design is very basic, though I’ve tried to shape them so that I would have it as easy as possible when I try to open them while having my hands full. I also wonted them to have a shape that won’t cause my cargo pants to get hung up on their ends all the time when walking past them closely. Then they should also be sturdy enough to last a long time.

To ensure they are consistent I’ve first cut a template, and then used this to route the handles themselves on the router table with a trim bit after cutting off most of the waste with the band saw. A small round-over bit in the router table then cleaned up the edges, so everything is nice and smooth.

Side panels (“wings”)

On both sides of the cabinet is another panel installed, that can be folded up to provide extra support for longer work pieces, and down, so it gets out of the way when not needed - just like a wing.

Each wing has a frame that consists of a set of 2-5/8” wide strips of plywood that are butt-joined with trim screws. On top of that sits a 3/4” plywood panel that has a T-track inserted lengthwise to allow for movable stops to be used for repeated cuts on pieces that extend beyond the saw’s fences. The supports that hold each wing in the horizontal position rest on a french cleat at each side of the cabinet.

Fences

I’ve replaced the movable upper metal fence parts that were originally installed, with full-size Fences that sit in front of the original fences, and are held in place with T-bolts and can slide in and out as needed. The left fence now is just a piece of 3/4” plywood, while the right fence is a piece of 36” triple T-track that I bought some time ago with the idea to make it a fence of some sort, but then never did. Now it finally is used as originally intended and allows to operate a set of movable stops, even when the wings aren’t folded up.

The stops consist of an unused flip stop from an old table saw sled, as well as some other smaller stops that are meant to sit flat on a T-track.

The finished project

So, despite this being a relatively easy build it was the first time I had attempted to make an actual cabinet with more than one or two drawers. As expected I ran into some difficulties, mainly rooted in a lack of experience. So, for instance, I struggled with mounting the drawers and their respective slides in a consistent way. While likely nobody ever will notice any of the flaws I still want to improve the standards I hold myself to, so I’ll keep practicing.

Another difficulty was the mounting of the wings, which needed to be attached in a way that allows them to fold up far enough to allow the support cleat to be positioned as needed, as well as carrying the weight well enough to not just break off when placing a 4x6 on it, for instance. Then I also messed up the length of the wings by a 1/4 inch, which caused them to not fold down all the way as they were hitting the bottom. Instead of just cutting of the upper ends and make 2 new short strips to put in I’ve opted for two different ways to move the hinges so it created more clearance. I’ve also had to set the hinges into the top panel a bit to make them flush with the top so they won’t get in the way of the saw’s feet - yes, I made the cabinet about 1/2” too narrow.

The saw is usually bolted down with some 1/4” bolts with knobs and threaded inserts, but can easily be removed if needed.

Overall I am pretty satisfied with how everything turned out. The drawers are already well used, and the height is perfect for me whenever I need to use the miter saw. The additional space provided by the wings already came in handy when working with 6’ to 8’ long workpieces - or just to set the coffee mug on.

I’ve also used the chance and made a zero-clearance insert for the saw as the original insert has a really wide gab to account for beveled cuts and the additional space the saw blade then needs. Since I usually don’t do these cuts on the miter saw anyway, I don’t need to account for that. If I ever need to make one I’ll just put a sacrificial piece underneath the workpiece to protect the insert.

It also allows to operate containers in an unprivileged mode, increasing security by reducing the permission level. But in order for this to work there are some special preparations needed.

Note

There is one thing that won’t work in this scenario due to the lack of permissions: setting a domain name or an FQDN in a docker container. If either the domainname setting is used in the docker-compose.yml, or if the hostname setting contains an FQDN instead of a regular hostname (no periods!), the start of the container will fail with a permission error.

However, there is nothing speaking against using a hostname with an app that runs inside the container, it just can not be set as a container parameter.

Docker inside Proxmox LXC

Set up an unprivileged container in Proxmox using the latest Debian template (at the time of writing this is Debian 12 “Bookworm”).

Inside the container

The following describes the basic setup inside the container, the commands are run as root.

Configure password-less SSH login

All that’s needed to allow a key-based login is adding the respective public key to the root user’s authorized_keys file:

echo 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIB0t4snxPv/aibNCtIujhkwVBRclKFtXKDwCG5WBANuj mcfisch@local' > /root/.ssh/authorized_keys

Now the local system’s key-store (Debian/Ubuntu keyring, Windows SSH-agent, etc.) can store the private part of the key, asking for its password once, and from there password-less SSH logins should make the following even easier, especially if one doesn’t use the Proxmox Gui to connect to the container.

Update packages

Next we update the repo list and install all package updates.

apt update && apt upgrade -y

A reboot shouldn’t be necessary as the container uses the host’s kernel, but it can help with getting the services started as supposed. It also helps with verifying that all settings are properly applied on boot.

Install additional packages

Some tools might be needed for later steps, or just to satisfy personal preferences. I use curl and vim a lot, so these are on my list. fuse-overlayfs is necessary as in an unprivileged LXC container there are some permission issues prohibiting the default docker storage driver overlayfs from working correctly. vfs could be an alternative, but it lacks the space-saving features of overlayfs and can cause a massive headache by using disk space uncontrollably. That’s where fuse-overlayfs comes in, the FUSE implementation of overlayfs.

apt install -y curl vim fuse-overlayfs

Once apt has finished, open the container’s options in Proxmox and enable FUSE under the Features setting. Restart the container.

Install Docker

Now the container is ready to get Docker. I prefer the convenience script that Docker provides. And since curl is already on the system I use it to fetch the script. For wget adjust the command accordingly (curl’s -L stands for “follow redirects”).

curl -fsSL https://get.docker.com | sh

Once the script is done the system should have the docker container service running.

Now configure the new storage driver and restart the service.

cat <<EOF >/etc/docker/daemon.json 
{
  "storage-driver": "fuse-overlayfs"
}
EOF
systemctl restart docker.service

Create regular user

In order to avoid working with the root user all the time, as even in a rootless container this is still the superuser that has all available permissions. So I create a regular user that is also allowed to maintain docker resources.

useradd -m -d /home/mcfisch -U -s /bin/bash mcfisch
usermod -aG docker mcfisch
echo 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIB0t4snxPv/aibNCtIujhkwVBRclKFtXKDwCG5WBANuj mcfisch@local' > /home/mcfisch/.ssh/authorized_keys
chown -R mcfisch:mcfisch /home/mcfisch/.ssh/
chown -R mcfisch:docker /docker/
chmod 700 /home/mcfisch/.ssh/
chmod 600 /home/mcfisch/.ssh/authorized_keys

The ssh key allows me to directly connect to the user without setting a password, so a password-based login will always fail.

Set up a container

Now we can begin setting up docker containers. I usually prefer docker-compose files combined with environmental variables in either .env files or stored in my shell profile.

The process usually resembles something like this:

mkdir -p /docker/grafana && cd /docker/grafana
curl -fsSL https://github.com/docker/awesome-compose/raw/master/prometheus-grafana/compose.yaml -o /docker/grafana/docker-compose.yml
docker compose -f /docker/grafana/docker-compose.yml pull
docker compose -f /docker/grafana/docker-compose.yml up -d

If all goes well this will start an instance of each Prometheus and Grafana, using the sample docker-compose file from the Docker github repo.

Happy Containerizing!

Modeling

I used SketchUp to plan out a model based on some ideas that I had in mind. One idea was to take a board I had, cut it into some strips, and then glue them together to resemble a bed.

Usually I tend to put a lot of thought into this kind of preparation, and this project wasn’t any different. I just got my hands onto some boards of oak flooring cut-offs, and at first I thought about milling some of those to the right size. But then I remembered that I had one, which should have the right size, and that was already milled to the right thickness - and which I had no use for during the past 2 years. So after making up my mind about the material I designed a bunk bed with the measurements of roughly 12” x 6” x 9”.

While modeling the details and checking the material requirements I’ve noticed that not only was my model much wider than necessary, it would also exceed the amount of material the board would provide. So I reduced the width to about 4.5 inches. The length I also increased by half an inch to account for the thickness of the stiles that were about to make up the posts of the bed.

For almost all joinery I’ve planned on using half-lap joints, but I felt like I would need to add some extra strength to the build, so it would have a better chance of surviving when my daughter was going to play with it. That’s where the bamboo skewers came into play. They were going to become dowels, used as loose tenons to reinforce the entire structure.

When I felt like my model was done I’ve made a part list. That I fed into my favorite cut list generator that allowed me to not only verify that I actually had enough material, but also gave me a visualization of which cuts to make to get the most out of the board.

Materials and tools

Wood

Square stock: oak board

This piece of oak I had left from one of my earliest builds: a smartwatch charging stand where I used strips of this big box store purchase as miter keys to strengthen some joints. It was roughly of the size 20” x 3” x 1/4”, and I never really found another use for this thin board. But now was the time to finally use it up.

Round stock: bamboo skewers

For the ladder steps as well as the dowels/tenons I wanted some round stock. This I found in the kitchen in the form of two bamboo skewers.

Sheet goods: plywood

For the boards that would make those parts of the bed that hold the mattresses I’ve cut up a scrap piece of a really soft 1/4” ply that I had. In hindsight it would have been better to use either MDF or hardboard because of their much smoother surface, but when I realized this it was already too late and the plywood glued in. Meh…

Tools

There was nothing too special to the tool set, although it likely goes a little beyond what most DIY people have in their garage or tool shed. However, if these tools wouldn’t have been available, a set of hand saws (like japanese pull saws), a chisel and a power drill would have worked out, too - but the effort and required skill level would have been a little higher, I guess.

Table saw

To cut the oak board into strips, the table saw was pretty handy, and better suited, for instance, than a band saw. I’ve used two kind of special blades this time.

Thin kerf 7-1/4” circ saw blade

Though my table saw is made for 10” blades I’ve specifically chosen to use a smaller blade to cut up the oak board. This helped keeping the waste down: the kerf (the width of the actual cut) is just slightly larger than half the kerf of my regular (full kerf) 10” combination blade, and still a third thinner than a 10” thin kerf rip blade. I got this blade in a clearance sale at a big box store specifically for ripping smaller pieces of wood like this.

Box joint blade

This is a form of a dado blade made by Freud, just that it lacks the shims and chipper blades that would be used in a regular dado stack. This specific blade set consists of 2 blades with wide, offset teeth, that - depending of the way they are positioned to each other - have a kerf width of either 1/4” or 3/8”. Though this blade set is specifically meant for cutting box joints it works for dados of certain widths as well. Another benefit for my personal setup is that they fit the max size of dado cuts that my table saw can do anyway - and that without even having to get or make a dado insert for the saw.

This blade set I’ve used to cut the half laps into the oak strips.

Drill press

Though it certainly would have been possible to drill the holes for the bamboo skewers by hand I have used my drill press for that as it is a much more stable way to drill consistently perpendicular holes into the oak strips, especially after the glue-up.

Flush cut saw, chisel

For cleaning up the ends of the skewers after gluing them in I used a flush cut saw as well as chisel. The latter also came to use for the mortises where the stretchers under the boards were added for stability.

Fabrics and filling

For the bedding I’ve used some packaging material: pieces of a rigid plastic foam as mattresses, and some thin, soft foam that came from a TV protective packaging, as filling for the blankets and pillows. The fabric for all these was sewn by my wife, using up some leftover fabric from when she made masks for the kids during the pandemic.

The build process

Cutting

The first step was to rip down the oak board into strips that were 1/4” wide, following the cut list I created earlier. Then the strips were cut to length.

After switching to the box joint blades I’ve cut the rabbets and dados into these strips where they were going to be joined later with half laps.

I’ve also cut the plywood strip into 2 pieces of the same size to make up the mattress boards.

Fitting

Some of the rabbets and dados needed a bit of cleanup, so I took a chisel, a few thin pieces of wood, some sand paper and a file and made them work as good as I could. Some still look a bit sloppy, but for my first time doing that kind of detail work I think it is good enough.

Glueing

When all parts seemed to fit together well enough I started glueing them together. I used very little clamping pressure, mostly with bandy clamps, just enough to ensure a proper hold at the joints. It went so well that I totally forgot to put the plywood pieces in place. When I noticed that it was already too late - they wouldn’t go in. At that moment I just left them out, postponing the search for an alternative way to make them work.

Tenoning

To strengthen the joints I had decided to use small dowels. Well, compared to the size of the oak strips they actually weren’t that small. They were going to be legit lose tenons, half the size of the joined pieces. So I drilled 1/8” holes into each joint, making sure the dowel would get proper contact with all mating pieces.

When all holes were drilled I cut the skewers into small sections of about 1/2” each. Then I glued them into the holes I had drilled. When the glue was almost dry I cut off the parts of the dowels that were sticking out, then cleaned them up with a chisel. In this process I’ve also removed the remaining glue squeeze-out.

Forcing the ply boards in

Well, before even seriously thinking about an alternative solution I just forced the boards in, going diagonally through the front, partially out the back, then back in, into the final position, pushing the frame as much as it needed to. I figured this would also make for a good test of stability - and it worked: the boards were in, and the whole construction has proven strong enough even for this kind of abuse.

A little bit of glue and the weight of some heavier wooden blocks were enough to secure the boards in place.

Cleanup

After the construction was done, I took some sand paper and cleaned up the surfaces. I didn’t go too crazy, just knocking off the saw marks and smoothing the edges, just so everything felt nice to the touch. I also had to sand down one of the foots of the bed a little bit because it was rocking.

Finish

To finish the doll bed I used a butcher block conditioner, based on mineral oil, beeswax, and carnauba wax. I rubbed in 2 coats, wiped off the excess and polished it a little. The important thing here was that the conditioner is safe for food contact, even exceeding the FDA regulations. So it would be safe for kids, too, even if they would decide to chew on the wood.

Bedding

The last task remaining was to make some bedding. My wife used her sewing skills to sew some foam packing material into the fabrics she’s chosen, creating mattresses, pillows and blankets for the dolls.

The final result

When we presented our daughter the now finished toy she really did love it. Seeing this kind of happiness in your child is one of the greatest things in live as a parent.

This was a really fun build, totally worth the effort and a great way to use up some scrap and household materials. I’m looking forward to building more furniture, next time in full size. I’ve already made some plans for the next projects, so stay tuned…

Situation

I was handed a virtual appliance that had to be run in a customer’s OpenStack environment. For licensing reasons there was no way to run the appliance on ESXi in this particular case. Unfortunately this is exactly what the appliance was built for: VMWare’s ESXi resp. vSphere, and there was no alternative build process set up yet. This might change in the future, but for now I had to find a way to make this work.

So my plan was to run a virtual machine with CentOS 7 in vSphere (something baremetal would have worked as well, but using our existing infrastructure was more convenient). Then this would run QEMU with KVM and operate the appliance from a converted virtual hard disk file using libvirtd.

This post refers to the steps to make that conversion working on CentOS 7. If you run a different OS you need to adjust the commands accordingly.

Preparations

Some things have to be prepared first to make all of that work. The easiest way for me to do this was to set up a system which later runs all the commands and the virtual appliance too. However, there is no need to do all of that on the same system, just go with a setup that fits your circumstances best.

Install tools

The necessary tools to convert the virtual hard disk need to be installed. In CentOS 7 that happens by installing QEMU and its surrounding packages.

install -y qemu qemu-common qemu-img qemu-kvm-common qemu-system-x86 qemu-user bridge-utils

Set up environment

In RedHat/CentOS the default location to store virtual disks, images etc. is /var/lib/libvirt/images. So let’s set a variable and make sure that directory does exist:

export VMDIR=/var/lib/libvirt/images
mkdir -p $VMDIR

Then let’s give the new appliance VM a short distinct name - e.g. orienting on its purpose and version number - and create its own directory.

export VMNAME=edge-151
mkdir -p $VMDIR/$VMNAME

Also we need an environmental variable set for the QEMU virtual filesystem handling:

export LIBGUESTFS_BACKEND=direct

Conversion

To get a vSphere appliance image working on QEMU we first need to convert the encapsuled disk image into a supported format, here QCOW2.

Extract the OVA file

Copy your original OVA file into your virtual machine image library (I’m using $VMDIR for this). The create a temporary directory - or if it exists already, make sure it is cleaned up - and unpack the OVA’s contents:

mkdir -p $VMDIR/tmp
rm -rf $VMDIR/tmp/*
tar xf $VMDIR/$VMNAME-vsphere.ova -C $VMDIR/tmp

Convert the virtual disk

QEMU comes with the qemu-img command that is not only used to create new images, but also for converting between different formats. Use it to make the virtual disk conversion, adjust the pattern to match the actual name of the VMDK file.

If there are more than one disk images than repeat the step for each of them and remember to attach them all to the new VM later.

qemu-img convert -f vmdk $VMDIR/tmp/*-disk1.vmdk $VMDIR/$VMNAME.qcow2

This step will leave the file at its intended size: i.e. if the original image of the virtual appliance was configured with a size of 100GB, this new QCOW2 image will be as big, too. So there is another step to reduce that size to what the file actually needs on the file system:

qemu-img convert -O qcow2 $VMDIR/$VMNAME.qcow2 $VMDIR/$VMNAME-shrunk.qcow2

The bigger file can be removed, and so can the other files that came with the OVA:

Remember to get other information from the original VMX configuration file first, i.e. specific MAC addresses that you may need to configure in the VM to satisfy an existing DHCP config or so.

rm -f $VMDIR/$VMNAME.qcow2
rm -rf $VMDIR/tmp/*

The last step here is to copy/move the new disk image to your virtual machine’s directory:

cp $VMDIR/$VMNAME-shrunk.qcow2 $VMDIR/$VMNAME/$VMNAME.qcow2

Or - as I like to do - create a snapshot from the image which makes it faster and more efficient to start over if needed. This also allows for running multiple virtual machines from the same image.

cd $VMDIR/$VMNAME
qemu-img create -b ../$VMNAME-shrunk.qcow2 -f qcow2 $VMNAME.qcow2 100G

Prepare a config ISO image

To use cloud images you may need a config ISO image that the system would mount as CD-ROM during a cloud-init run. If that image doesn’t exist yet you can use the following examples and modify them to fit your needs. Both files are written in the YAML format, a simple to understand descriptive language that you may already know from other DevOps tools.

Create the cloud-init config files

The first file provides meta information about the system, like internal and external hostnames:

cat <<EOF> $VMDIR/$VMNAME/meta-data
instance-id: $VMNAME
local-hostname: $VMNAME
EOF

The second file contains instructions for cloud-init to execute during the initial setup. In this basic example the first user is created and set up with an SSH key and sudo permission, so you can log in right after the system came up and start working on it.

cat <<EOF> $VMDIR/$VMNAME/user-data
#cloud-config 
preserve_hostname: False
hostname: $VMNAME
fqdn: $VMNAME.yourdomain.local
users:
    - default
    - name: mcfisch
      groups: ['wheel']
      shell: /bin/bash
      sudo: ALL=(ALL) NOPASSWD:ALL
      ssh-authorized-keys:
        - ssh-ed25519 AAAACDFMSNLKGDJSRETWOEIIIDFGJDT+SORk4v+dsERFGvsdfgseT35Fv35Vssdoegff KVM Lab SSH Login mcfisch
output:
  all: ">> /var/log/cloud-init.log"
ssh_genkeytypes: ['ed25519', 'rsa']
ssh_authorized_keys:
  - ssh-ed25519 AAAACDFMSNLKGDJSRETWOEIIIDFGJDT+SORk4v+dsERFGvsdfgseT35Fv35Vssdoegff KVM Lab SSH Login key mcfisch
timezone: America/Los_Angeles
runcmd:
  - systemctl stop network && systemctl start network
  - yum -y remove cloud-init
EOF

Since this file allows for a lot more than this - including arbitrary file creation - you can define an entire system that does it supposed work without you ever logging in personally. This is one way to keep cloud images simple, clean and easily maintainable by separating them from the customization, which then can easily be managed in a code repository.

Create the ISO file

Now these files need to go into an ISO image, and all that’s needed for this is the genisoimage command that can be installed from the systems package repo:

yum install genisoimage

Then run the following command to built an ISO file with the 2 files created above:

genisoimage -output $VMDIR/$VMNAME/$VMNAME-config.iso -volid config -joliet -r meta-data user-data

Modify an existing ISO image

In case you already have an image that just needs to get adjusted, you can do that, too. Just mount the image, copy its contents somewhere else, then modify them and rebuild the image:

# mount and copy the existing files to a local directory
MNTDIR=/mnt
TMPDIR=/tmp
mount $VMDIR/$VMNAME-config.iso $MNTDIR
mkdir -p $TMPDIR
cp $MNTDIR/* $TMPDIR/
umount $MNTDIR
# make your changes in $TMPDIR, then repack it
genisoimage -output $VMDIR/$VMNAME-config-new.iso -volid config -joliet -r $TMPDIR/*
rm -rf $TMPDIR/*

Configure a bridged virtual network

If your VM needs a regular IP address within your network over which it can be reached, serve incoming requests etc. then you will need a bridged network the VM can use. For that simply create an additional KVM network and a local bridge it can use. The culprit here is that, depending on your particular setup, in the moment you reconfigure your network interfaces you may lose access to the system. So make sure you have direct access to its console before following these steps.

Add virtual bridge to physical interface

This example is for an additional interface, that is attached to a virtual bridge, which then is assigned a fixed IP, so the host system has two network interfaces connected.

brctl addbr br0
ip link set dev br0 up
ip addr add 192.168.1.10/24 dev br0

The same affect can be achieved by directly adding/editing the configuration files:

cat <<EOF >/etc/sysconfig/network-scripts/ifcfg-br0
STP=yes
TYPE=Bridge
BOOTPROTO=static
NAME=br0
DEVICE=br0
ONBOOT=yes
IPADDR=192.168.1.10
PREFIX=24
GATEWAY=192.168.1.1
DNS1=192.168.1.1
PROXY_METHOD=none
BROWSER_ONLY=no
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=no
AUTOCONNECT_SLAVES=yes
DOMAIN=yourdomain.local
BRIDGING_OPTS=priority=32768
EOF

cat <<EOF > /etc/sysconfig/network-scripts/ifcfg-ens224 
TYPE=Ethernet
NAME=ens224
DEVICE=ens224
ONBOOT=yes
BRIDGE=br0
BOOTPROTO=none
DEFROUTE=yes
EOF

systemctl restart network

Create a virtual network

To be able to use this new bridge we also need a virtual network defined that QEMU can attack virtual machines to. Specify the respective configuration in an XML file, then import that into the QEMU setup.

cat <<EOF > host-bridge.xml
<network>
  <name>host-bridge</name>
  <forward mode='bridge'/>
  <bridge name='br0'/>
</network>
EOF
virsh net-define host-bridge.xml
virsh net-start host-bridge
virsh net-autostart host-bridge

Enable packet forwarding

The following part my differ from what your system needs, it totally depends on how the host system is configured. In my case, where I was provided a ready-to-use VM in vSphere by another team, I had to follow these steps to make sure virtual machines nested in QEMU/KVM inside a vSphere machine can actually talk to the local network.

cat <<EOF > /etc/udev/rules.d/99-bridge.rules
ACTION=="add", SUBSYSTEM=="module", KERNEL=="br_netfilter", RUN+="/sbin/sysctl -p /etc/sysctl.d/bridge.conf"
EOF
cat <<EOF > /etc/sysctl.d/bridge.conf
net.bridge.bridge-nf-call-ip6tables=0
net.bridge.bridge-nf-call-iptables=0
net.bridge.bridge-nf-call-arptables=0
EOF
echo "NM_BOND_BRIDGE_VLAN_ENABLED=yes" >> /etc/sysconfig/network
echo "net.ipv4.ip_forward=1" >> /etc/sysctl.d/99-sysctl.conf
sysctl -p /etc/sysctl.d/99-sysctl.conf
service NetworkManager restart

Enable promiscuous mode on vSphere vSwitch port

If you’re attempting this setup as I did in vSphere, you (or the respective vSphere admin) probably need to set up a port or port group that is configured to operate in promiscuous mode and allows for address spoofing. The reason for this potentially dangerous setup is, that the nested virtual network internally uses a routed connection between the VM’s and the bridge interface. So this physical interface needs to listen to all packets of the incoming traffic, not just those addressed to its own MAC address (promiscuous mode), and it needs to send packets in the name of the VM’s interfaces and their MAC addresses (address spoofing).

To keep the security impact of these settings as low as possible I’d recommend using a dedicated port group for this VM in vSphere that has the following settings enabled:

• Promiscuous mode
• MAC address changes
• Forged transmits

However, I’d recommend turning these on one at a time and testing after each if your connections start working.

Setup the VM

Once the disk and CD-ROM images are in place it is time to configure the actual VM. The process for an official cloud-image of CentOS 7 for instance is relatively straightforward:

virt-install --import --name $VMNAME --virt-type=kvm --memory 2048 --vcpus 2 --cpu host --disk $VMDIR/$VMNAME/$VMNAME.qcow2,format=qcow2,device=disk --hvm --disk $VMDIR/$VMNAME/$VMNAME-seed.iso,device=cdrom --network network=host-bridge --os-type=linux --os-variant=centos7.0 --graphics vnc --noautoconsole

However, for my specific case I needed a specific setup that required a couple things:

• 3 NICs
• static IP addresses that will be utilized by a package installed by the config ISO
• fixed MAC addresses to use the company’s DHCP that I preconfigured for these

To satisfy these I used the following command:

virt-install --import --name $VMNAME --virt-type=kvm --memory 8192 --vcpus 8 --cpu host --disk $VMDIR/$VMNAME/$VMNAME.qcow2,format=qcow2,device=disk,bus=ide --hvm --disk $VMDIR/$VMNAME/$VMNAME-config.iso,device=cdrom --network=network=host-bridge,model=virtio,mac=52:54:00:a7:85:d8 --network=network=host-bridge,model=virtio,mac=52:54:00:7b:b3:9f --network=network=host-bridge,model=virtio,mac=52:54:00:79:09:c5 --os-type=linux --os-variant=centos7.0 --graphics vnc --noautoconsole

Not only does that set the basic VM parameters as well as the hard-coded MAC addresses, it also specifies a key setting for the successful conversion of (at least my) vSphere virtual appliance to QEMU/KVM:

--disk $VMDIR/$VMNAME/$VMNAME.qcow2,format=qcow2,device=disk,bus=ide

The bus=ide at the end of the disk definition was crucial as the VMs wouldn’t boot with any other configuration. This may vary for your appliance, so if an appliance won’t boot check if setting another controller type makes it work. The most commonly used type for instance is virtio, but depending on your version of KVM it might be something like scsi0.0, ahci.0 or sata instead, usually accompanied by a device id. Check the documentation for your particular QEMU/KVM installation.

Operation

With this all set the new VM should be ready to be used.

Start/stop the VM

The last thing to do is to start the VM up:

virsh start $VMNAME

If the VM needs to be shutdown this can be done so:

virsh shutdown $VMNAME

To pull the VM’s virtual power plug run this:

virsh destroy $VMNAME

This would be also helpful when you’re going to replace the VM’s disk but want to keep the actual VM configuration.

Now if that’s not the case and you need to completely start over - or simply clean up - the following command will remove the VM from inventory:

virsh undefine $VMNAME

View/edit the VM configuration

However, if you ever need to access or change the VM’s configuration, it is possible to just output it to the command line:

virsh dumpxml $VMNAME

Or load it into your systems’s default editor to make permanent changes to the VM setup:

virsh edit $VMNAME

Connect to VM console

Sometimes there is no way to access the VM remotely - maybe the network interfaces are getting moved into Docker containers, maybe it has no route to your other networks, no SSH server is installed, or the appliance just doesn’t allow for any incoming connections. Either wey, there are other ways to access a VM’s console through the host system. What worked best for me was VNC. The VMs in such setup get VNC display IDs attached, starting with 0, and incrementing with each VM that get’s started.

To access any of them in a restricted network I use the port forwarding/tunnelling functionality that SSH provides. Starting at 5900 the last digit of the port number represents the VNC display ID: 5900 connects to VM 0, 5901 connects to VM 1, etc.

To access any of these VMs I add the parameters -L <VNC port>:127.0.0.1:<local port> to my SSH command:

I then point a VNC viewer to localhost:<VNC display ID> (not the full port) and are connected to the respective VM’s actual console.

ssh -L 5900:127.0.0.1:5900 root@192.168.1.10

Conclusion

At this point I had a working procedure to manually convert and run a VMware appliance on QEMU. This is still lacking the implementation in OpenStack, but at least it is a workaround to get going. OpenStack nodes usually have the needed services and drivers already installed, so for the moment this setup will do it. Finding a way to convert the CD-ROM image into an OpenStack config drive is the one task on my ToDo list, building a Jenkins job for this procedure is another.

Happy virtualizing!

So I said: “That’s a great idea, but - you gotta help me with this so we get this done before Halloween. Alright?”

Of course he said “yes” and did get to “work” right away…

Brainstorming

First I’ve asked him to think about what he actually wanted, and then to draw some sketches on paper, so we can assess what resources we would need. He came up with a list of items:

• three Pumpkins
• a cat
• some bats
• a ghost
• a spider

Once he scribbled them on some sheets of paper we thought about how big all of that was supposed to get, where we were going to put them, and what materials we would actually need.

Materials

Lucky me again got some 5/8in plywood from a construction site that was about to be thrown away there. I’ve also collected some other pieces from a household that had their garage shelves removed and were giving away some boards, too. Given that my wife also asked for a decorative piece I knew that we needed about one full sheet.

Tools

Since I was going to work on this project with a seven years old child (and sometimes a 4yo was around, too) I wanted to keep it to the small tools - no table saw, no miter saw etc. Just the good old jigsaw and a power drill.

Well, we actually did use the bandsaw for cutting the bats out of 1/4in plywood, but this is probably the one larger tool of the bunch that is the safest for kids to use - under permanent direction and supervision, of course.

Another reason to not use the bigger saws or the router was the quality of the material respectively the fact that it was used on the ground on a construction site: while the wood itself was not bad, it had quite some nails, brads, staples and even some small rocks embedded, all of which could lead to disaster when coming in contact with large, powerful, spinning blades.

Besides that I just needed sandpaper as well as a some pencils.

Paint

For coloring the pieces I’ve got cans spray paint in several colors as well as clear enamel spray, all in a satin finish, from the big box store. The colors were orange, red, black, white, yellow, green and brown. Besides the some parts of one of the pumpkins everything was sprayed directly onto the plywood. The clear coat was put on all surfaces of the workpieces to seal them off from the weather, or any kind of humidity.

Hardware

Since some of the pieces were supposed to go on the lawn we needed a way to “mount” them. I actually found 2 ways with the stuff I had laying around:

• a remainder of 1/2in PVC Schedule 40 pipe, cut into shorter pieces somewhere between 2 and 2 1/2 inches long
• some plastic pipe straps that I had laying around from when I secured some pipes to wooden beams underneath the house

Both kinds were screwed onto the boards from behind, allowing to slide them (with the board they were attached to) over plant stakes that were driven into the ground. These stake my wife got me from her gardening equipment - after I promised to give them back once we take the decorations inside again…

The build

Drawing

Once we had a better idea what we were going to build we started transferring the sketches from paper onto the plywood. My son drew one of the pumpkins and the bat(s). I’ve added two more pumpkins, the spider and the cat. The latter two were also based on my sons drawing.

The bat he actually drew on a piece of card board first which I then cut on the bandsaw before hew used it to outline three of these on a thinner sheet of plywood. Everything else went onto the thicker construction plywood, while we were trying to use it as economical as possible.

Cutting

The cutting was unspectacular: following the lines with the jigsaw, sometimes drilling a hole first as a starter for narrow cutouts. For the bats and parts of the spider I used the bandsaw - just because I have it and it was easier. Though I could have get by with just the jigsaw if I wanted, too. A scroll saw would also work, at least for the thinner material.

It is more important to use saw blades that are made for your respective material, sharp, and thin enough to cut narrow turns, as well as taking time when moving the saw (or the workpiece).

Painting

To get the paint on we just placed the pieces on a large liner of cardboard and sprayed them with the cans until we had the desired look. For the pumpkins we needed to apply just a plain color on the front, another color on their stems, and the cutouts in their faces we blacked out from behind so they would not interfere with the fronts.

For the “silly” pumpkin I created two small makeshift ashtray-like containers from aluminum foil and used small paint brushes to get the white and red paint onto eyes, teeth and tongue, all of which I had masked with frog tape before when spraying the face with orange.

The cat, the spider and the bats we sprayed black from all sides, the spider also got some red spots by using stencils that were quickly cut from sheets of paper.

The result

This is a great DIY project that doesn’t require a lot of woodworking skills or experience, and one a child can easily contribute to. Use leftover plywood, buy some, or - if you have the tools and skills - laminated some boards yourself. Besides that only basic tools are needed to cut and shape the materials. The exterior spray paint is easy to apply and allows to put the then sealed workpieces inside or outside the house. The costs are also relatively low, especially when materials are used that are already there, like garden stakes and pipe cutoffs.

And I am really proud of my son, he really did put his mark on the whole project. Not only is more than half of it made after his very own designs, he also helped in the process of making, was cleaning up the mess afterwards and had a say in where to put them once we were done with all the pieces.

:jack_o_lantern: :spider: Happy Halloween, everyone! :spider: :jack_o_lantern:

PS: for next year we’ll also work on a spider web as well as the ghost he was asking for…

On a system that has SSH access I stash a list of remote names and/or IP adresses in a variable:

iplist="192.168.1.3
192.168.2.100
10.10.0.5"

Then I define the list of commands I want to run through the SSH connection. The reason for me to not issue these directly in the loop was the combination of the use of an IF condition and using a subshell for root access via sudo. Also this shows an example how to properly nest commands when tunneling through SSH - note the use of '\'' to escape the single quotes.

export cmdlist='echo "22b557a27055b33606b6559f37703928d3e4ad79f110b407d04986e1843543d1  /tmp/ISRG_Root_X1.crt" > /tmp/ISRG_Root_X1.sha256
curl -k --output "/tmp/ISRG_Root_X1.crt"  "https://letsencrypt.org/certs/isrgrootx1.pem.txt"
sha256sum -c /tmp/ISRG_Root_X1.sha256 && sudo bash -c '\''
  mv -f /tmp/ISRG_Root_X1.crt /usr/share/ca-certificates/mozilla/ISRG_Root_X1.crt; 
  echo "mozilla/ISRG_Root_X1.crt" | sort -u -o /etc/ca-certificates.conf -m - /etc/ca-certificates.conf; 
  sed -i '\''s|^mozilla\/DST_Root_CA_X3\.crt|!mozilla/DST_Root_CA_X3.crt|'\'' /etc/ca-certificates.conf;
  update-ca-certificates
'\''
curl -I https://letsencrypt.org/certs/isrgrootx1.pem.txt'

This will create a text file that has the checksum of the certificate file in it. After downloading the new root CA certificate with disabled SSL check (because that would fail as my system doesn’t trust any new certificates yet which use this new CA) the check file allows me to verify that the downloaded file hasn’t been tempered with.

I made sure to get the checksum from a valid copy of the file on my local system which already had this cert added automatically.

Once that check succeeded the file will be moved to the right place in /usr/share/ca-certificates/ and added to the config while the old certificate will be disabled. Then the ca-certificates database is updated and another call of curl is issued to verify the system is working as expected.

The next step then is to cycle through the list of remote systems and issue the set of commands I’ve defined above.

for i in $iplist ; do ssh $i "$cmdlist"; done

Sometimes I may add a sleep 5 or so to the loop if I need to be able to interrupt the process before moving on to the next system.

So she asked if I could build a plant bed to get this project started.

“Of course!” I said. :smile:

Planning

First we needed to find a space to put the plant bed. We found it along the rear wall of the house we live in. There was a mostly unused flower bed that needed some care anyway, and that was perfect for this project. About 16’ by 2,75’ it had enough space, was in a good place to benefit from weather and sun, and due to its almost rectangular shape it shouldn’t be too hard to build a well fitting plant bed.

Making a SketchUp model

So once I had the measurements I created a model in SketchUp to get the exact dimensions of the material I would need. Constructing it perfectly to the size of the flowerbed allowed me to calculate exactly the sizes of the parts - well, I did subtract some inches to allow for tolerances, and I didn’t want the wood stick to the wall of the house either so they wouldn’t become a moisture trap.

The first iteration of the model was only to be able to calculate for the sizes of the boards I would need, so it was more of a rough draft. But once I knew exactly what material I was getting I finished the design.

Gathering the material

I was lucky to get some redwood scraps from a construction site that were about to be disposed and would provide enough material for the project. It were a couple 1x8 inch redwood boards in multiple length: some at around 12 feet (which came in handy to make the long sides very stable and easy to set), some at 8 feet, and some shorter ones between 3 and 5 feet.

Redwood has a natural resistance to decay and bug infestation, so it is perfect for outside use. One of the key requirements my wife gave me was the absolute avoidance of any hazardous materials - like wood finishes that could be poisonous when seeping into the ground, contaminating the plants. We were aware that it might mean to redo the whole thing in a couple of years, and we are fine with it. By then we’ll know if this is exactly what’s needed, or if and where we would need to make changes then.

“Measure twice, cut once”

When I had the material at home I measured exactly to make sure I only calculate with what I have, and to know what else to buy if needed. It also helped in using the boards in the most efficient way by sorting out holes from knots, cracks and other imperfections. Remember, these came from a construction site, so they weren’t exactly furniture quality.

But they were more than good enough for a plant bed, so I adjusted the SketchUp model to accommodate for the newly gathered information.

Then I took to a cut planning tool: www.cutlistoptimizer.com. Its free version has enough functionality to allow for exact cut list creation and to optimize the the cut list, so I get the most out of the material I had. When I entered all information - measures from the SketchUp model as well as the dimensions of the available boards - and worked out a cut list that I exported as PDF.

Marking the boards

To make sure I can easily tell the boards apart and which part of the cut list applied to them I labeled them all with blue painters tape and a sharpie. These labels were put so that when cutting the boards to size each part would still be labeled with the letter the respective part of the cut list as well as the SketchUp model had. This made the cutting and the assembly really easy.

Construction

Cutting the boards

Nothing special here: cutting the boards to length on the miter saw that I rolled into the back yard as it had more space than the shop (which is a garage), and then ripping these boards where needed to their final width.

Glue and screws

To connect the boards I relinquished the finer methods of joinery in woodworking. Instead I made short vertical posts by glueing the faces of two boards together with a waterproof wood glue, so they basically got the circumference of a 2x4.

These were screwed onto the back of the longer boards with coated deck screws, right at the seams where the ends of the boards meet. The longer boards also got some extra posts screwed on to stabilize them. Some more posts connected the boards at the corners, where the angles on one side required some beveled cuts.

At roughly a third of the length from each end I’ve put a board across the plant bed and screwed it also to a post on both sides. This gives the whole structure more stability and would keep the soil from pushing the long sides apart over time.

At one of the short sides I let the plant bed end in a triangular shape to follow the lines of the flower bed. This also became kind of a design element that my wife specifically asked for.

To give the build a nicer touch I’ve set kind of a crown on top, using some narrower strips that were screwed into the edges of the top row of boards. Since I’ve layed them out specifically to overlap with the seems of the boards below they too make for an even stronger structural stability of the final build.

Smoothing out the surfaces

To reduce splintering and ensuring a nice feel to the touch I’ve sanded the top and front. I’ve also rounded the edges and corners to reduce the danger of anyone getting hurt. After all the kids were supposed to join the gardening at some point, so everything has to be as smooth as possible. On the other side it is still an outdoor object, so I didn’t have to get too crazy about it.

Finalizing

Soil

When the actual build was done we’ve put a double layer of plain cardboard at the bottom to act as a fertilizer when it would start rotting later (a tip that my wife has gotten in a gardening group). Then we’ve filled the plant bed up with soil.

The my wife started dividing the space into small parcels that were planned for the different plants, marking them with some gardening stuff she had (that’s her domain, not mine).

Irrigation

I came back into the game when she knew where to put the irrigation system. I drilled some holes into the sides underneath the crown, so I could fit a hose in. A couple drippers and sprayers as desired, and we now have a pretty well functioning vegetable garden.

Produce and flowers

This summer it already provided us with quite some nice fruits and vegetables: strawberries, tomatoes, cucumbers, bell peppers, beans and a whole bunch of herbs. Next year it also should have corn and small pumpkins.

For the kids there were also a few different flowers in between the veggies, but the most appreciated by the kids were the sun flowers they planted in that decorative corner at the end of the plant bed.

Spontaneous upgrade

A couple weeks after planting the first plants my wife asked for a top to the plant bed. Since this was after lumber prices started to skyrocket I had to improvise a little: I added a top structure to the existing model in SketchUp and started building this from fence pickets which I cut into strips and screwed together with pocket hole screws.

The base of that was done and put on, but then I got sick and couldn’t work on that for a while, so it currently is stuck at this stage. The sides and back are secured with hardware cloth that we got from a friend some time ago, and the front for now is just covered with a nylon net. that’s ok for now, but over this fall I need to make some doors and put them on…

Conclusion

There we have it: a nice little vegetable garden that keeps some of us busy for quite some time. I’m sure we’ll have more fun and joy with it next year, when soil and plants as well as gardening skill have settled a bit.

My only concern is that the wood may not hold up as well as we’ve hoped, but we are taking that risk anyway. So far it does holt up pretty well, though. Fingers crossed it stays that way. And if not then we already have some more ideas what to improve next time…

Well, it is not. There is a way to reconnect to a phone (no matter if it’s the same as before or not) without resetting the watch, so no apps, watch faces or tiles are getting lost as they wood with a full reset.

Preparation

To issue the commands needed to have the watch reconnecting you need to establish a debugging connection via the Android Debug Bridge or ADB. The tools for this protocol are part of the Android Studio, a development software provided by Google that is pretty large. Depending on your system you may be able to install a tools-only package from your system’s software repo, or use one from another (trustworthy) source, like the XDA Developer Forum.

However you get it on the system, make sure you can actually run the adb command from your preferred command line.

Enable Developer options

If you haven’t done that yet the first thing to do on the watch is to enable the Developer Settings. In order to do that you open the Settings, navigate to System, then About. There you scroll down and start tapping the line that says Build number. A toast notification (usually a small text bubble at the bottom of the screen) will appear multiple times and display a countdown. Keep tapping until it says You are now a Developer, then go back to the Settings.

Enable ADB debugging

Open the Developer options at the bottom of the list and scroll until you see ADB debugging. Enable this.

Connect your computer to your watch. If you’re doing it over USB, plug your watch into your computer. If you are going to connect by Wi-Fi then you also need to enable the option Debug over Wi-Fi. Wait a moment and then note down the IP address that is now shown underneath that option, assuming the watch is on the same Wi-Fi as the computer.

Bluetooth is also an option here, but I’ve never tried that, as I find the Wi-Fi connection the easiest. The handling should be the same as via USB, though.

Connect via ADB

If you have connected the watch to your Wi-Fi, connect to the watch remotely via ADB. You can do this by typing adb connect xxx.xxx.x.x:nnnn with the xxx.xxx.x.xx’s being the IP you noted earlier under the wireless debugging option, and nnnn is the port ADB is using. If only one connection is active this port should be 5555 by default, otherwise use whatever the watch shows.

For a USB connection no extra command is needed to connect, it happens automatically on the first run of adb.

adb connect 192.168.1.187:5555

When the ADB connection is coming up the watch will display a prompt, asking Allow Debugging?. Chose either OK or Always allow debugging from this computer. Once it has successfully connected, run the next command to verify the connection is established. It should print an alphanumeric string that represents the device ID.

adb devices

If this doesn’t work make sure you have an ADB driver installed. Your phone might have come with one, or the adb package has it, or look up this thread on XDA for a universal installer.

Remove the existing connection

Now it is time to reset the connection that is stored inside the watch without resetting the entire watch.

Reset the watch’s connection data

Run this command to remove the existing connection information:

adb shell "pm clear com.google.android.gms && reboot"

After a few seconds, you will see the word “Success” appear, followed by your watch rebooting. When it has rebooted, do not attempt to connect to it with your phone”s WearOS app. Connect the watch to your computer again, then reconnect to it via ADB following the procedure from earlier.

Trigger the setup routine

When the watch has reconnected, run the following command to manually start the setup routine that let’s the phone discover the watch:

adb shell "am start -a android.bluetooth.adapter.action.REQUEST_DISCOVERABLE"

Confirm the prompt that appears on the watch, asking for allowing other devices to discover it.

Reconnect

Connect your phone to the watch

You may now open the Wear OS app on your phone and connect to the watch as if it were new. If the app gets stuck on searching for updates, close the app and open it again. It’ll go away and the setup should work as usual like before, now with your new phone/ROM setup.

Enjoy!