Alpine en Android

Finalmente probé con lo siguiente

[setup.sh](https://gist.githubusercontent.com/coderofsalvation/43d7d476dc5eeba98926b9437e52bb49/raw/c0fbd270deaa6d42df58e7c94b4df94245410c35/install.sh)

```bash
#!/bin/bash
INSTALL='/data/data/berserker.android.apps.sshdroid/home/alpine'
APKTOOLS='2.10.3-r1'
ARCH='armv7'
MIRROR='http://dl-cdn.alpinelinux.org/alpine'
MIRROR='http://nl.alpinelinux.org/alpine'
VER='v3.9'
RED='\033[0;31m'
NC='\033[0m'
set -e

mkdir -p $INSTALL/etc
printf "${RED}remounting /system as writable to write /etc/resolv.conf${NC}"
mount -o remount,rw $(mount | grep '/system' | awk '{ print $1 }') /system

printf "${RED}initing DNS settings"
echo -e "nameserver $(getprop net.dns1)\nnameserver $(getprop net.dns2)" > /etc/resolv.conf
set +e; mkdir $INSTALL/etc; set -e
cp /etc/resolv.conf $INSTALL/etc/.

printf "${RED}Downloading Static installer apk...${NC}\n"
set -x
wget $MIRROR/$VER/main/$ARCH/apk-tools-static-$APKTOOLS.apk
tar -xzf apk-tools-static-*.apk
rm apk-tools-static-*.apk
rm .PKGINFO


printf "\n${RED}Installing Base Alpine...${NC}\n"
./sbin/apk.static -X $MIRROR/$VER/main -U --allow-untrusted --root $INSTALL --initdb add alpine-base
rm -r ./sbin/

printf "\n${RED}Adding Repos to chroot${NC}\n"
echo "$MIRROR/$VER/main" > $INSTALL/etc/apk/repositories
echo "$MIRROR/$VER/community" >> $INSTALL/etc/apk/repositories
echo "http://nl.alpinelinux.org/alpine/edge/testing/" >> $INSTALL/etc/apk/repositories

printf "\n\n${RED} Done! Logging into chroot..${NC}\n"
echo "in the future you can do this using: chroot $INSTALL bash"
chroot $INSTALL apk update
```

### Esto tampoco funcionó

El script lo saqué de [Laurynas Četyrkinas / AlpineDroid · GitLab](https://gitlab.com/stnby/alpinedroid)

Acá el [setup.sh](https://gitlab.com/stnby/alpinedroid/-/raw/master/setup.sh?ref_type=heads)

```bash
#!/system/bin/sh
set -e

# PARAMETERS ---
DEST='/data/alpinedroid'
MIRR='http://dl-cdn.alpinelinux.org/alpine'
DNS1='1.1.1.1'
DNS2='1.0.0.1'
# --------------

# Prepare (start)
ARCH=`uname -m`
mkdir -p $DEST
cd $DEST
echo "> prepare"
# Prepare (end)



# Download rootfs (start)
echo "< download rootfs"
FILE=`busybox wget -qO- "$MIRR/latest-stable/releases/$ARCH/latest-releases.yaml" | busybox grep -o -m 1 'alpine-minirootfs-.*.tar.gz'`

busybox wget "$MIRR/latest-stable/releases/$ARCH/$FILE" -O rootfs.tar.gz
echo "> download rootfs"
# Download rootfs (end)



# Extract rootfs (start)
echo "< extract rootfs"
busybox tar -xf rootfs.tar.gz
echo "> extract rootfs"
# Extract rootfs (end)



# Configure (start)
echo "> configure"
mkdir -p mnt/sdcard

echo "nameserver $DNS1
nameserver $DNS2" > etc/resolv.conf

echo "#!/system/bin/sh -e
busybox mount -t proc none $DEST/proc
busybox mount --rbind /sys $DEST/sys
busybox mount --rbind /dev $DEST/dev
busybox mount --rbind /sdcard $DEST/mnt/sdcard" > up.sh

echo "#!/system/bin/sh
busybox umount $DEST/proc
busybox umount -l $DEST/sys
busybox umount -l $DEST/dev
busybox umount -l $DEST/mnt/sdcard" > down.sh

echo "#!/system/bin/sh
busybox chroot $DEST /bin/sh --login" > chroot.sh

busybox chmod +x {up,down,chroot}.sh
echo "< configure"
# Configure (end)
```

Luego hacemos:
```bash
cd /data/alpinedroid
./up.sh
./chroot.sh
exit
./down.sh
```
  
---


#### TODO ESTO NO ME SIRVIÓ PARA NADA Y CUANDO HACÍA LOS MOUNTS EL CELULAR QUEDA COMPLETAMENTE BUGGEADO POR ESOS MOUNTS

Miralo en YouTube: [Install Alpine in android | fossfrog - YouTube]()



Mirala en invidious: [Install Alpine in android | fossfrog - Invidious]()

Googleá alpine download y bajá el rootfs de la arquitectura de tu celular, en mi caso armv7 (moto g3 2015) esto lo podés hacer desde tu PC y pasarlo al celular o directamente lo podés hacer desde tu celular bajandolo con wget o desde el navegador, si lo haces del navegador tendras que ubicarte en la carpeta de downloads desde la terminal.


Tenés que rootear el telefono, yo instalé lineageos 14.1, addonsu 14.1, open_gapps-nano-7.1



Ahora andá a settings habilitá la terminal, ejecutá su y deberias poder tener root.



Ahora:

```bash
cd /data/local/ ; mkdir rootfs
tar xvf alpine-minirootfs.tar.gz -C rootfs
```

Esto lo podes hacer desde tu computadora y pasarlo al celular o desde el celular directamente :

```bash
cd /data/local
touch alpine_start.sh
chmod 755 alpine_start.sh (para hacerlo ejecutable)
o chmod +x alpine_start.sh
```

#### Poné lo siguiente:

```bash
!#/bin/sh

mount --bind /sys rootfs/sys
mount --bind /proc rootfs/proc
mount --bind /dev rootfs/dev
mount --bind /dev/shm rootfs/dev/shm
mount --bind /dev/pts rootfs/dev/pts

export PATH="/bin:/sbin:/usr/local/bin:/usr/bin:/usr/sbin"

chroot rootfs bin/ash
umount rootfs/dev/pts
umount rootfs/dev/shm
umount rootfs/proc
umount rootfs/dev
umount rootfs/sys
```

Guardalo en `/data/local` o copialo con cp y ejecutalo: `cd /data/local` y  `./alpine_start.sh`



Ahora estarás ejecutando alpine con chroot.

Probá tirar un `ping` porque a veces el DNS no está bien configurado en ese caso tenés que cambiar `/etc/resolv.conf` y pone las dns de google o las que quieras.

Ahora probá ejecutar `apk` el gestor de paquetes de alpine.


```bash
apk update
apk search apache
apk search mariadb
apk add vim
```

También podés construir tu propia busybox 

Si lo estás haciendo en windows tenes que tener cuidado porque el fin de linea en windows es diferente que el de linux por lo tanto no funcionaran tus scripts.

```bash
\n = linux
\r\n = windows
```

Si usas vim o gvim podes ejecutar para ver el ^M al final de la linea :e ++ff=unix