diff --git a/botanist/target/device.go b/botanist/target/device.go
index 0ea5b11..5df0ae3 100644
--- a/botanist/target/device.go
+++ b/botanist/target/device.go
@@ -5,11 +5,19 @@
 package target
 
 import (
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/ioutil"
+	"net"
+	"time"
 
+	"fuchsia.googlesource.com/tools/botanist"
 	"fuchsia.googlesource.com/tools/botanist/power"
+	"fuchsia.googlesource.com/tools/build"
+	"fuchsia.googlesource.com/tools/netboot"
+	"fuchsia.googlesource.com/tools/netutil"
 
 	"golang.org/x/crypto/ssh"
 )
@@ -26,7 +34,24 @@
 	SSHKeys []string `json:"keys,omitempty"`
 }
 
-// LoadDeviceConfigs unmarshalls a slice of DeviceConfigs from a given file.
+// DeviceOptions represents lifecycle options for a target.
+type DeviceOptions struct {
+	// Netboot gives whether to netboot or pave. Netboot here is being used in the
+	// colloquial sense of only sending netsvc a kernel to mexec. If false, the target
+	// will be paved.
+	Netboot bool
+
+	// SSHKey is a private SSH key file. If provided, the corresponding authorized key
+	// will be paved.
+	SSHKey string
+
+	// Fastboot is a path to the fastboot binary. If provided, it will be assumed that
+	// the device is waiting in fastboot mode, and it will be attempted to 'continue'
+	// it into zedboot.
+	Fastboot string
+}
+
+// LoadDeviceConfigs unmarshalls a slice of device configs from a given file.
 func LoadDeviceConfigs(path string) ([]DeviceConfig, error) {
 	data, err := ioutil.ReadFile(path)
 	if err != nil {
@@ -40,25 +65,126 @@
 	return configs, nil
 }
 
-// Returns the SSH signers associated with the key paths in the botanist config file if present.
-func SSHSignersFromConfigs(configs []DeviceConfig) ([]ssh.Signer, error) {
-	processedKeys := make(map[string]bool)
-	var signers []ssh.Signer
-	for _, config := range configs {
-		for _, keyPath := range config.SSHKeys {
-			if !processedKeys[keyPath] {
-				processedKeys[keyPath] = true
-				p, err := ioutil.ReadFile(keyPath)
-				if err != nil {
-					return nil, err
-				}
-				s, err := ssh.ParsePrivateKey(p)
-				if err != nil {
-					return nil, err
-				}
-				signers = append(signers, s)
+// DeviceTarget represents a target device.
+type DeviceTarget struct {
+	config  *DeviceConfig
+	opts    *DeviceOptions
+	signers []ssh.Signer
+}
+
+// NewDeviceTarget returns a new device target with a given configuration.
+func NewDeviceTarget(config DeviceConfig, opts DeviceOptions) (*DeviceTarget, error) {
+	// If an SSH key is specified in the options, prepend it the configs list so that it
+	// corresponds to the authorized key that would be paved.
+	if opts.SSHKey != "" {
+		config.SSHKeys = append([]string{opts.SSHKey}, config.SSHKeys...)
+	}
+	signers, err := parseOutSigners(config.SSHKeys)
+	if err != nil {
+		return nil, fmt.Errorf("could not parse out signers from private keys: %v", err)
+	}
+	return &DeviceTarget{
+		config:  &config,
+		opts:    &opts,
+		signers: signers,
+	}, nil
+}
+
+// Nodename returns the name of the node.
+func (t *DeviceTarget) Nodename() string {
+	return t.config.Nodename
+}
+
+// IPv6 returns the link-local IPv6 address of the node.
+func (t *DeviceTarget) IPv6Addr() (*net.UDPAddr, error) {
+	addr, err := netutil.GetNodeAddress(context.Background(), t.Nodename(), false)
+	return addr, err
+}
+
+// Start starts the device target.
+func (t *DeviceTarget) Start(ctx context.Context, images build.Images, args []string) error {
+	if t.opts.Fastboot != "" {
+		zirconR := images.Get("zircon-r")
+		if zirconR == nil {
+			return fmt.Errorf("zircon-r not provided")
+		}
+		// If it can't find any fastboot device, the fastboot tool will hang
+		// waiting, so we add a timeout.  All fastboot operations take less
+		// than a second on a developer workstation, so two minutes to flash
+		// and continue is very generous.
+		ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
+		defer cancel()
+		if err := botanist.FastbootToZedboot(ctx, t.opts.Fastboot, zirconR.Path); err != nil {
+			return fmt.Errorf("failed to fastboot to zedboot: %v", err)
+		}
+	}
+
+	// Set up log listener and dump kernel output to stdout.
+	l, err := netboot.NewLogListener(t.Nodename())
+	if err != nil {
+		return fmt.Errorf("cannot listen: %v", err)
+	}
+	go func() {
+		defer l.Close()
+		for {
+			data, err := l.Listen()
+			if err != nil {
+				continue
+			}
+			fmt.Print(data)
+			select {
+			case <-ctx.Done():
+				return
+			default:
 			}
 		}
+	}()
+
+	addr, err := t.IPv6Addr()
+	if err != nil {
+		return err
+	}
+
+	// Boot Fuchsia.
+	var bootMode int
+	if t.opts.Netboot {
+		bootMode = botanist.ModeNetboot
+	} else {
+		bootMode = botanist.ModePave
+	}
+	return botanist.Boot(ctx, addr, bootMode, images, args, t.signers)
+}
+
+// Restart restarts the target.
+func (t *DeviceTarget) Restart(ctx context.Context) error {
+	if t.config.Power != nil {
+		if err := t.config.Power.RebootDevice(t.signers, t.Nodename()); err != nil {
+			return fmt.Errorf("failed to reboot the device: %v\n", err)
+		}
+	}
+	return nil
+}
+
+func parseOutSigners(keyPaths []string) ([]ssh.Signer, error) {
+	if len(keyPaths) == 0 {
+		return nil, errors.New("must supply SSH keys in the config")
+	}
+	var keys [][]byte
+	for _, keyPath := range keyPaths {
+		p, err := ioutil.ReadFile(keyPath)
+		if err != nil {
+			return nil, fmt.Errorf("could not read SSH key file %q: %v", keyPath, err)
+		}
+		keys = append(keys, p)
+	}
+
+	var signers []ssh.Signer
+	for _, p := range keys {
+		signer, err := ssh.ParsePrivateKey(p)
+		if err != nil {
+			return nil, err
+		}
+		signers = append(signers, signer)
 	}
 	return signers, nil
 }
diff --git a/botanist/target/device_test.go b/botanist/target/device_test.go
index 1626a2f..30687ab 100644
--- a/botanist/target/device_test.go
+++ b/botanist/target/device_test.go
@@ -7,9 +7,6 @@
 	"io/ioutil"
 	"os"
 	"testing"
-
-	"fuchsia.googlesource.com/tools/botanist/power"
-	"fuchsia.googlesource.com/tools/sshutil"
 )
 
 func TestLoadConfigs(t *testing.T) {
@@ -55,81 +52,3 @@
 		}
 	}
 }
-
-func TestSSHSignersFromConfigs(t *testing.T) {
-	tests := []struct {
-		name        string
-		device1Keys []string
-		device2Keys []string
-		expectedLen int
-		expectErr   bool
-	}{
-		// Valid configs.
-		{"ValidSameKeyConfig", []string{"valid1"}, []string{"valid1"}, 1, false},
-		{"ValidDiffKeysWithDuplicateConfig", []string{"valid1", "valid2"}, []string{"valid1"}, 2, false},
-		{"ValidDiffKeysConfig", []string{"valid1"}, []string{"valid2"}, 2, false},
-		{"ValidEmptyKeysConfig", []string{}, []string{}, 0, false},
-		// Invalid configs.
-		{"InvalidKeyFileConfig", []string{"valid1"}, []string{"invalid"}, 0, true},
-		{"MissingKeyFileConfig", []string{"missing"}, []string{}, 0, true},
-	}
-
-	validKey1, err := sshutil.GeneratePrivateKey()
-	if err != nil {
-		t.Fatalf("Failed to generate private key: %s", err)
-	}
-	validKey2, err := sshutil.GeneratePrivateKey()
-	if err != nil {
-		t.Fatalf("Failed to generate private key: %s", err)
-	}
-	invalidKey := []byte("invalidKey")
-
-	keys := []struct {
-		name        string
-		keyContents []byte
-	}{
-		{"valid1", validKey1}, {"valid2", validKey2}, {"invalid", invalidKey},
-	}
-
-	keyNameToPath := make(map[string]string)
-	keyNameToPath["missing"] = "/path/to/nonexistent/key"
-	for _, key := range keys {
-		tmpfile, err := ioutil.TempFile(os.TempDir(), key.name)
-		if err != nil {
-			t.Fatalf("Failed to create test device properties file: %s", err)
-		}
-		defer os.Remove(tmpfile.Name())
-		if _, err := tmpfile.Write(key.keyContents); err != nil {
-			t.Fatalf("Failed to write to test device properties file: %s", err)
-		}
-		if err := tmpfile.Close(); err != nil {
-			t.Fatal(err)
-		}
-		keyNameToPath[key.name] = tmpfile.Name()
-	}
-
-	for _, test := range tests {
-		var keyPaths1 []string
-		for _, keyName := range test.device1Keys {
-			keyPaths1 = append(keyPaths1, keyNameToPath[keyName])
-		}
-		var keyPaths2 []string
-		for _, keyName := range test.device2Keys {
-			keyPaths2 = append(keyPaths2, keyNameToPath[keyName])
-		}
-		configs := []DeviceConfig{
-			{"device1", &power.Client{}, keyPaths1},
-			{"device2", &power.Client{}, keyPaths2},
-		}
-		signers, err := SSHSignersFromConfigs(configs)
-		if test.expectErr && err == nil {
-			t.Errorf("Test%v: Expected errors; no errors found", test.name)
-		}
-		if !test.expectErr && err != nil {
-			t.Errorf("Test%v: Expected no errors; found error - %v", test.name, err)
-		}
-		if len(signers) != test.expectedLen {
-			t.Errorf("Test%v: Expected %d signers; found %d", test.name, test.expectedLen, len(signers))
-		}
-	}
-}
diff --git a/cmd/botanist/zedboot.go b/cmd/botanist/zedboot.go
index 57a001c..748fb87 100644
--- a/cmd/botanist/zedboot.go
+++ b/cmd/botanist/zedboot.go
@@ -22,13 +22,10 @@
 	"fuchsia.googlesource.com/tools/build"
 	"fuchsia.googlesource.com/tools/command"
 	"fuchsia.googlesource.com/tools/logger"
-	"fuchsia.googlesource.com/tools/netboot"
-	"fuchsia.googlesource.com/tools/netutil"
 	"fuchsia.googlesource.com/tools/runner"
 	"fuchsia.googlesource.com/tools/runtests"
 
 	"github.com/google/subcommands"
-	"golang.org/x/crypto/ssh"
 )
 
 // ZedbootCommand is a Command implementation for running the testing workflow on a device
@@ -184,66 +181,7 @@
 	return cmd.tarHostCmdArtifacts(summaryBuffer.Bytes(), stdoutBuf.Bytes(), tmpDir)
 }
 
-func (cmd *ZedbootCommand) runTests(ctx context.Context, imgs build.Images, nodes []target.DeviceConfig, cmdlineArgs []string, signers []ssh.Signer) error {
-	var err error
-
-	// Set up log listener and dump kernel output to stdout.
-	for _, node := range nodes {
-		l, err := netboot.NewLogListener(node.Nodename)
-		if err != nil {
-			return fmt.Errorf("cannot listen: %v\n", err)
-		}
-		go func(nodename string) {
-			defer l.Close()
-			logger.Debugf(ctx, "starting log listener for <<%s>>\n", nodename)
-			for {
-				data, err := l.Listen()
-				if err != nil {
-					continue
-				}
-				if len(nodes) == 1 {
-					fmt.Print(data)
-				} else {
-					// Print each line with nodename prepended when there are multiple nodes
-					lines := strings.Split(data, "\n")
-					for _, line := range lines {
-						if len(line) > 0 {
-							fmt.Printf("<<%s>> %s\n", nodename, line)
-						}
-					}
-				}
-
-				select {
-				case <-ctx.Done():
-					return
-				default:
-				}
-			}
-		}(node.Nodename)
-	}
-
-	var addrs []*net.UDPAddr
-	for _, node := range nodes {
-		addr, err := netutil.GetNodeAddress(ctx, node.Nodename, false)
-		if err != nil {
-			return err
-		}
-		addrs = append(addrs, addr)
-	}
-
-	// Boot fuchsia.
-	var bootMode int
-	if cmd.netboot {
-		bootMode = botanist.ModeNetboot
-	} else {
-		bootMode = botanist.ModePave
-	}
-	for _, addr := range addrs {
-		if err = botanist.Boot(ctx, addr, bootMode, imgs, cmdlineArgs, signers); err != nil {
-			return err
-		}
-	}
-
+func (cmd *ZedbootCommand) runTests(ctx context.Context, imgs build.Images, addr *net.UDPAddr, cmdlineArgs []string) error {
 	// Handle host commands
 	// TODO(IN-831): Remove when host-target-interaction infra is ready
 	if cmd.hostCmd != "" {
@@ -251,11 +189,6 @@
 	}
 
 	logger.Debugf(ctx, "waiting for %q\n", cmd.summaryFilename)
-	if len(addrs) != 1 {
-		return fmt.Errorf("Non-host tests should have exactly 1 node defined in config, found %v", len(addrs))
-	}
-
-	addr := addrs[0]
 	return runtests.PollForSummary(ctx, addr, cmd.summaryFilename, cmd.testResultsDir, cmd.outputArchive, cmd.filePollInterval)
 }
 
@@ -265,22 +198,22 @@
 	if err != nil {
 		return fmt.Errorf("failed to load target config file %q", cmd.configFile)
 	}
-
-	signers, err := target.SSHSignersFromConfigs(configs)
-	if err != nil {
-		return err
+	opts := target.DeviceOptions{
+		Netboot:  cmd.netboot,
+		Fastboot: cmd.fastboot,
 	}
 
+	var devices []*target.DeviceTarget
 	for _, config := range configs {
-		if config.Power != nil {
-			defer func(cfg *target.DeviceConfig) {
-				logger.Debugf(ctx, "rebooting the node %q\n", cfg.Nodename)
-
-				if err := cfg.Power.RebootDevice(signers, cfg.Nodename); err != nil {
-					logger.Errorf(ctx, "failed to reboot the device: %v", err)
-				}
-			}(&config)
+		device, err := target.NewDeviceTarget(config, opts)
+		if err != nil {
+			return err
 		}
+		devices = append(devices, device)
+	}
+
+	for _, device := range devices {
+		defer device.Restart(ctx)
 	}
 
 	imgs, err := build.LoadImages(cmd.imageManifests...)
@@ -291,27 +224,21 @@
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	errs := make(chan error)
-	go func() {
-		if cmd.fastboot != "" {
-			zirconR := imgs.Get("zircon-r")
-			if zirconR == nil {
-				errs <- fmt.Errorf("zircon-r not provided")
-				return
-			}
-			// If it can't find any fastboot device, the fastboot
-			// tool will hang waiting, so we add a timeout.
-			// All fastboot operations take less than a second on
-			// a developer workstation, so two minutes to flash and
-			// continue is very generous.
-			ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
-			defer cancel()
-			logger.Debugf(ctx, "flashing to zedboot with fastboot\n")
-			if err := botanist.FastbootToZedboot(ctx, cmd.fastboot, zirconR.Path); err != nil {
+
+	for _, device := range devices {
+		go func() {
+			if err := device.Start(ctx, imgs, cmdlineArgs); err != nil {
 				errs <- err
-				return
 			}
+		}()
+	}
+	go func() {
+		addr, err := devices[0].IPv6Addr()
+		if err != nil {
+			errs <- err
+			return
 		}
-		errs <- cmd.runTests(ctx, imgs, configs, cmdlineArgs, signers)
+		errs <- cmd.runTests(ctx, imgs, addr, cmdlineArgs)
 	}()
 
 	select {
diff --git a/cmd/health_checker/main.go b/cmd/health_checker/main.go
index 5fba855..48190fe 100644
--- a/cmd/health_checker/main.go
+++ b/cmd/health_checker/main.go
@@ -4,6 +4,7 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"flag"
 	"fmt"
@@ -75,21 +76,6 @@
 	return HealthCheckResult{nodename, healthyState, ""}
 }
 
-func reboot(config target.DeviceConfig) error {
-	if config.Power == nil {
-		return fmt.Errorf("Failed to reboot the device: missing power management info in botanist config file.")
-	}
-	signers, err := target.SSHSignersFromConfigs([]target.DeviceConfig{config})
-	if err != nil {
-		return fmt.Errorf("Failed to reboot the device: %v.", err)
-	}
-
-	if err = config.Power.RebootDevice(signers, config.Nodename); err != nil {
-		return fmt.Errorf("Failed to reboot the device: %v.", err)
-	}
-	return nil
-}
-
 func printHealthCheckResults(checkResults []HealthCheckResult) error {
 	output, err := json.Marshal(checkResults)
 	if err != nil {
@@ -120,15 +106,25 @@
 	if err != nil {
 		log.Fatal(err)
 	}
-	var checkResultSlice []HealthCheckResult
+
+	var devices []*target.DeviceTarget
 	for _, config := range configs {
-		nodename := config.Nodename
+		device, err := target.NewDeviceTarget(config, target.DeviceOptions{})
+		if err != nil {
+			log.Fatal(err)
+		}
+		devices = append(devices, device)
+	}
+
+	var checkResultSlice []HealthCheckResult
+	for _, device := range devices {
+		nodename := device.Nodename()
 		if nodename == "" {
-			log.Fatal("Failed to retrieve nodename from config file")
+			log.Fatal("no nodename in config")
 		}
 		checkResult := checkHealth(client, nodename)
 		if checkResult.State == unhealthyState && rebootIfUnhealthy {
-			if rebootErr := reboot(config); rebootErr != nil {
+			if rebootErr := device.Restart(context.Background()); rebootErr != nil {
 				checkResult.ErrorMsg += "; " + rebootErr.Error()
 			}
 		}