summaryrefslogtreecommitdiffstats
path: root/docs/part-1/2_install-xds-server.md
blob: cbbca4460788e8a422d5ec2e5122f858e366659e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
# Installing XDS server

Depending of your configuration, this step is necessary or not.

In other words **you are a developer and plan to use/connect to an existing `xds-server`**
running on your local network (On-Premise config) or in the Cloud (SaaS config),
**you don't need to install the server part and you can skip this step**.

For others (standalone config or administrators that want to install an
On-Premise solution) xds-server must be installed.

Several installation types are supported:

| Install type | Supported OS | Section to refer |
|--------------|--------------|------------------|
| Container | Linux or MacOS | [see Installation based on Docker container](#installation-based-on-docker-container) |
| Virtual Machine | Linux, MacOS or Windows | [see Installation based on VirtualBox appliance](#installation-based-on-virtual-machine-appliance) |
| Native | Linux | [see Native installation](#native-installation) |

## Installation based on Docker container

### Docker container prerequisites

Docker is installed on the host machine, please refer to [Docker documentation](https://docs.docker.com/engine/installation/) for more details.

### Get the container

Load the pre-build AGL SDK docker image including `xds-server`:

```bash
wget -O - http://iot.bzh/download/public/XDS/docker/docker_agl_worker-xds-latest.tar.xz | docker load
```

You should get `docker.automotivelinux.org/agl/worker-xds:X.Y` image

```bash
# List image that we just load
docker images "docker.automotivelinux.org/agl/worker-xds*"

REPOSITORY                                  TAG                 IMAGE ID            CREATED             SIZE
docker.automotivelinux.org/agl/worker-xds   5.0                 877979e534ff        3 hours ago         106MB
```

### Create and start a new container

Use provided script to create a new docker image and start a new container:

```bash
# Get script
wget -O xds-docker-create-container.sh 'https://gerrit.automotivelinux.org/gerrit/gitweb?p=src/xds/xds-server.git;a=blob_plain;f=scripts/xds-docker-create-container.sh;hb=master'

# Create new XDS worker container
bash ./xds-docker-create-container.sh

# Check that new container is running
docker ps | grep worker-xds
f67079db4339        docker.automotivelinux.org/agl/worker-xds:5.0   "/usr/bin/wait_for..."   About a minute ago   Up 34 seconds       0.0.0.0:8000->8000/tcp, 0.0.0.0:69->69/udp, 0.0.0.0:10809->10809/tcp, 0.0.0.0:2222->22/tcp   agl-xds-HOSTNAME-0-USERNAME
```

This container exposes following ports:

| Port number | Description                                 |
|-------------|---------------------------------------------|
|     8000    | `xds-server`: serve XDS webapp and REST API |
|      69     | TFTP                                        |
|     2222    | ssh                                         |

This container also creates the following volumes (shared folders between
inside and outside docker):

| Directory on host | Directory inside docker | Comment |
|-------------------|-------------------------|---------|
| $HOME/xds-workspace | /home/devel/xds-workspace | XDS projects workspace location|
| $HOME/xds-workspace/.xdt_0 | /xdt | location to store SDKs |
| $USER_VOLUME | $USER_VOLUME | user path, see `--volume` option of `xds-docker-create-container.sh` script |

<!-- note -->
**Note:**

You can add a new shared directory using `--volume` option in order
to use for example with Path-Mapping folder type.

```bash
# Create new XDS worker container and share extra '$HOME/my-workspace' directory
bash ./xds-docker-create-container.sh --volume /my-workspace:$HOME/my-workspace
```

You can change docker used port with `-id` option

```bash
# Create new XDS worker container with a different port number
bash ./xds-docker-create-container.sh -id ${ID}

# Check that new container is running
docker ps | grep worker-xds
f67079db4339        docker.automotivelinux.org/agl/worker-xds:5.0   "/usr/bin/wait_for..."   About a minute ago   Up 34 seconds       0.0.0.0:(2222+ID)->22/tcp, 0.0.0.0:(69+ID)->69/udp, 0.0.0.0:(8000+ID)->8000/tcp, 0.0.0.0:(10809+ID)->10809/tcp   agl-xds-HOSTNAME-ID-USERNAME
```

<!-- endnote -->

#### Manually setup docker user id

<!-- note -->
**Note:**

If you used `xds-docker-create-container.sh` script to create XDS
docker container, user uid/gid inside docker has already been changed by this script.
<!-- endnote -->

If you plan to use **path-mapping sharing type for your projects**, you need to
have the same user id and group id inside and outside docker.

By default user and group name inside docker is set `devel` (id `1664`).

Use following commands to replace id `1664` with your user/group id:

```bash
# Set docker container name to use (usually agl-xds-xxx where xxx is USERNAME@MACHINENAME-IDX-NAME)
export CONTAINER_NAME=agl-xds-seb@laptop-0-seb
docker ps | grep -q ${CONTAINER_NAME} || echo "ERROR: No container name \"${CONTAINER_NAME}\" please set a valid CONTAINER_NAME before you continue"

# First kill all processes of devel user (including running xds-server)
docker exec ${CONTAINER_NAME} bash -c "/bin/loginctl kill-user devel"

# Change user and group id inside docker to match your ids
docker exec ${CONTAINER_NAME} bash -c "usermod -u $(id -u) devel"
docker exec ${CONTAINER_NAME} bash -c "groupmod -g $(id -g) devel"

# Update some files ownership
docker exec ${CONTAINER_NAME} bash -c "chown -R devel:devel /home/devel /tmp/xds*"

# Restart devel autologin service
docker exec ${CONTAINER_NAME} bash -c "systemctl restart autologin"

# Restart xds-server as a service (ssh port 2222 may depend on your container ID)
ssh -p 2222 devel@localhost -- "systemctl --user restart xds-server"
```

### Check if xds-server is running (open XDS webapp)

**`xds-server` is automatically started** as a service on container startup.

If the container is running on your localhost, you can access to a basic web
application:

```bash
xdg-open http://localhost:8000
```

If needed you can status / stop / start  it manually using following commands:

```bash
# Status XDS server:
ssh -p 2222 devel@localhost systemctl --user status xds-server.service

# Stop XDS server
ssh -p 2222 devel@localhost systemctl --user stop xds-server.service

# Start XDS server
ssh -p 2222 devel@localhost systemctl --user start xds-server.service

# Get XDS server logs
ssh -p 2222 devel@localhost journalctl --user --unit=xds-server.service --output=cat
```

`xds-server` is now up and running, you can now install AGL SDKs, please refer
to next chapter named [Installing AGL SDKs](3_install-sdks.html#installing-agl-sdks)

<!-- note -->
Please refer to [part 2 - xds-server](../part-2/1_xds-server.html#sdk-cross-toolchain-management) documentation
for additional info.
<!-- endnote -->

## Installation based on Virtual Machine appliance

### Virtual Machine appliance prerequisites

> VirtualBox is installed on the host machine

please refer to [VirtualBox documentation](https://www.virtualbox.org/wiki/Downloads) for more details.

### Get the appliance

Load the pre-build AGL SDK appliance image including `xds-server`:

```bash
wget http://iot.bzh/download/public/XDS/appliance/xds-vm-debian9_latest.ova
```

### Clean old appliance

You must have one and one xds appliance only.

So, first remove the oldest xds appliance if needed.

```bash
# Get the virtual machine name
VDS_VMNAME=$(VBoxManage list vms | grep xds-vm-debian | cut -d "\"" -f2)
echo ${VDS_VMNAME}

# Remove old XDS appliance
[ -n ${VDS_VMNAME} ] && VBoxManage controlvm ${VDS_VMNAME} poweroff
[ -n ${VDS_VMNAME} ] && VBoxManage unregistervm ${VDS_VMNAME} --delete
```

### Create and start a new appliance

Used provided script to create a new appliance or you can use VirtualBox GUI:

```bash
# Import image into VirtualBox
VBoxManage import ./xds-vm-debian9_latest.ova

# Check import result
VDS_VMNAME=$(VBoxManage list vms | grep xds-vm-debian | cut -d "\"" -f2)
echo ${VDS_VMNAME}

# Start XDS appliance
[ -n ${VDS_VMNAME} ] && VBoxManage startvm ${VDS_VMNAME}
```

**Mandatory**:

Add share folder to appliance, to allow files sharing using pathmap method:

```bash
# Create local share folder
mkdir -p $HOME/xds-workspace

#Add share folder to appliance
vboxmanage sharedfolder add ${VDS_VMNAME} --name XDS-workspace --hostpath $HOME/xds-workspace
```

### Appliance settings

This image exposes following network ports (NAT mode):

- 8000 : `xds-server` to serve XDS basic web page
- 69   : TFTP
- 2222 : ssh

## Check if xds-server is running

`xds-server` is automatically started as a service on container startup.

To check if xds-server is correctly install and running, you can access the basic web page that gives you some instructions:

```bash
# if container/appliance is running on your local host
# (else replace localhost by the name or the ip of the machine running the container)
xdg-open http://localhost:8000
```

`xds-server` is now up and running, you can now install AGL SDKs, please refer
to next chapter named [Installing AGL SDKs](3_install-sdks.html#installing-agl-sdks)

## Native installation

You can chose to install xds-server 'natively' instead of within a docker
container but note that only Linux host OSes are supported and tested for native
installation !

### Install packages for debian distro type

```bash
# 'DISTRO' can be set to { xUbuntu_16.04, xUbuntu_16.10, xUbuntu_17.04, Debian_8.0, Debian_9.0}
export DISTRO="xUbuntu_16.04"

wget -O - http://download.opensuse.org/repositories/isv:/LinuxAutomotive:/app-Development/${DISTRO}/Release.key | sudo apt-key add -
sudo bash -c "cat >> /etc/apt/sources.list.d/AGL.list <<EOF
deb http://download.opensuse.org/repositories/isv:/LinuxAutomotive:/app-Development/${DISTRO}/ ./
EOF"

sudo apt-get update
sudo apt-get install agl-xds-server
```

### Install packages for openSUSE distro type

```bash
# DISTRO can be set to {openSUSE_Leap_42.2, openSUSE_Leap_42.3, openSUSE_Tumbleweed}
export DISTRO="openSUSE_Leap_42.2"

sudo zypper ar http://download.opensuse.org/repositories/isv:/LinuxAutomotive:/app-Development/${DISTRO}/isv:LinuxAutomotive:app-Development.repo

sudo zypper ref
sudo zypper install agl-xds-server
```

### Configure xds-server

<!-- note -->
**Optional step**: skip this chapter if you plan to use default settings
<!-- endnote -->

Please refer to [Configuration chapter of xds-server](../part-2/1_xds-server.html#configuration)
documentation for more details about JSON configuration file.

### Start/Stop xds-server

`xds-server` can be managed as a systemd service with the following commands:

```bash
# Status XDS server:
systemctl --user status xds-server.service

# Stop XDS server
systemctl --user stop xds-server.service

# Start XDS server
systemctl --user start xds-server.service

# Get XDS server logs
systemctl --user --unit=xds-server.service --output=cat
```

To check if xds-server is correctly install and running, you can access the web
interface, using a web browser :

```bash
xdg-open http://localhost:8000
```

or get the current version using the following curl command:

```bash
curl http://localhost:8000/api/v1/version
```