Netflix&#x27;s American Conspiracy: The Octopus Murders is a vast and compelling story of a conspiracy theory--but more so about the process of being consumed by the fascination of an extraordinary mystery. The mystery stems from the death of Danny Casolaro...

'The Octopus Murders' Review: The Absorbing, Unhinged Investigation into the Death of Danny Casolaro

It&#x27;s your latest binge-worthy true crime must-watch. Find out more about American Conspiracy: The Octopus Murders on Netflix.

The Octopus Murders: Why people can't stop talking about the bizarre true story

The Apptopus

We are going to build a simple Front End that interacts with an EOS smart contract Our simple front end: Login Page I have always been a big fan of React from the very beginning, but lately I have been playing around with Vue and have to admit that I really fell in love with it for it’s simplicity. To keep things simple as possible for you, I have decided to use Vue to build our front end this time. NOTE: If you have not tried out Vue, their official documentation is the best place to start. Create a Vue Project Start by installing Vue, open up terminal and type this: npm i -g @vue/cli Now that Vue is installed we are going to use it’s CLI to create our project vue create eos-login When prompted choose “Manually select features” then, use the space bar to select Babel, Router and Vuex feature. For the rest of the questions you can just choose the defaults. Once the Vue CLI have created our project, we can change directory into it and add plugins. We are going to add the Vuetify plugin for helping us with the design. cd eos-login vue add vuetify You will be asked a series of questions, just follow my answers like bellow: vuetify options Ok lastly we will need to install EOS official javascript library so that we can easily make calls to the EOS blockchain. npm i eosjs@beta NOTE: The npm package eosjs@beta is the latest compared to just eosjs By now you will have a perfect project setup to start coding. npm run serve Follow the link on your browser and you should see the default Vue template up and running! Deploy our Smart Contract Before we start coding the front end let’s deploy our latest smart contract to the EOS blockchain. I have written a simple smart contract that has a ‘users’ table and a login method that accepts an EOS account as it’s input. The login method will store the account in the users table if no records already exist for that name. However if there is already a record, it will increment the reward_points by 1 instead. The login also ensures that only valid EOS account can enter. Let’s go ahead and deploy this contract . I have previously written a step by step guide on how to accomplish this, please click here. Coding the Front End part Now that we have our hello contract deployed, we can resume our work on the front end. Open the eos-login project folder in VSCode (or you favourite IDE), we will be adding 4 files to our project: AppTopBar.vue under the components folder EosService.js under the eosio folder (create this folder) Login.vue under the views folder .env under the project root folder Add this files to your project. Your project structure should now look like bellow. Project directory structure Let’s start by coding the AppTopBar component. In Vue, components can be easily added to pages making it very re-usable. The AppTopBar component is simply a header bar with a title of our application.  <template><span><v-toolbar app color="black darken-4" dark><v-spacer class="hidden-md-and-up"></v-spacer><v-toolbar-title>{{appTitle}}</v-toolbar-title></v-toolbar></span></template> <script>export default {name: 'AppTopBar',data() {return {appTitle: 'My EOS Dapp'};}};</script> <style scoped></style> Now open App.vue under the src folder to import our component. Notice that AppTopBar has been format as <app-top-bar> inside the template.  <template><v-app><app-top-bar></app-top-bar><v-content transition="slide-x-transition"><router-view></router-view></v-content></v-app></template> <script>import AppTopBar from '@/components/AppTopBar'; export default {name: 'App',components: {AppTopBar}};</script> For our application we will have 2 main page which is the Login page and the Home page. On the App.vue we are using the Vue Router to link to both pages with the <router-view></router-view> tag. Open the router.js file to edit the paths. //router.js import Vue from 'vue';import Router from 'vue-router';import Login from './views/Login.vue'; Vue.use(Router); export default new Router({mode: 'history',base: process.env.BASE_URL,routes: [{path: '/',name: 'login',component: Login},{path: '/home',name: 'home',component: () => import('./views/Home.vue')}]}); Edit our Home.vue  <template><v-card-title primary-title><h4>Welcome to my Dapp main page!</h4></v-card-title></template> <script>export default {components: {}};</script> Create our Login.vue  <template><v-container><v-layout row class="text-xs-center"><v-flex xs3 style="background-image: url(' )"><v-card height="500px"></v-card></v-flex><v-flex xs4 class="grey lighten-4"><v-container style="position: relative;top: 13%;" class="text-xs-center"><v-card flat><v-card-title primary-title><h4>Login</h4></v-card-title><v-form><v-text-fieldv-model="accountName"prepend-icon="person"name="AccountName"label="Account Name"></v-text-field><v-text-fieldv-model="privateKey"prepend-icon="lock"name="PrivateKey"label="Private Key"></v-text-field><v-card-actions><v-btn ="handleLogin()" primary large block>Login</v-btn></v-card-actions></v-form></v-card></v-container></v-flex></v-layout></v-container></template> http://cdn.wallpapersafari.com/7/86/gqiGH7.jpg' @click <script>import EosService from '@/eosio/EosService'; export default {data() {return {accountName: '',privateKey: ''};},methods: {handleLogin: function() {EosService.login(this.accountName, this.privateKey).then(() => {this.$router.push('home');}).catch(err => {alert(err.toString());});}}};</script> The Login.vue page calls the login function on EosService and passes the inputs for account name and private key. If the login function returns success it simply redirects to the Home.vue page. Now before I dive into the EosService login function, let’s edit our .env file with the correct values. Open the .env file under the project root directory. VUE_APP_SMART_CONTRACT_NAME="youraccname1"VUE_APP_NODE_ENDPOINT=" " https://api.kylin.alohaeos.com:443 Set the value for VUE_APP_SMART_CONTRACT_NAME to the account name you created earlier on the Testnet to deploy the hello contract. The value for VUE_APP_NODE_ENDPOINT should be then set to a Testnet endpoint, in this case I am using the CryptoKylin Testnet. Subsequently if you have deployed your smart contract on the Mainnet then you should set the value of the endpoint to any of the . 21 main block-producers EosService Finally let’s look into the code for the EosService.js library I created. This is where the bulk of action is happening. //EosService.js import { Api, JsonRpc } from 'eosjs';import JsSignatureProvider from 'eosjs/dist/eosjs-jssig'; async function invokeAction(action, dataValue) {const rpc = new JsonRpc(process.env.VUE_APP_NODE_ENDPOINT); const privateKey = localStorage.getItem('private_key');const signatureProvider = new JsSignatureProvider([privateKey]); const api = new Api({rpc,signatureProvider,textDecoder: new TextDecoder(),textEncoder: new TextEncoder()}); try {const resultWithConfig = await api.transact({actions: [{account: process.env.VUE_APP_SMART_CONTRACT_NAME,name: action,authorization: [{actor: localStorage.getItem('name_account'),permission: 'active'}],data: dataValue}]},{blocksBehind: 3,expireSeconds: 30});return resultWithConfig;} catch (err) {throw err;}} class EosService {static login(acc, key) {return new Promise((resolve, reject) => {localStorage.setItem('name_account', acc);localStorage.setItem('private_key', key);invokeAction('login', { user: acc }).then(() => {resolve();}).catch(err => {localStorage.removeItem('name_account');localStorage.removeItem('private_key');reject(err);});});}} export default EosService; Basically what we are doing here is creating an API transaction by passing in the parameters of the .env file earlier. For this to work we need to create a signature provider with an EOS account private-key to access the smart contract. Since this is meant to be a simple tutorial we are directly dealing with the private-key here, however in a real world application it is best to integrate with a 3rd party wallet to handle the creation of the signature provider. That way you do not have to ask your users for their private-key directly which is insecure. NOTE: Scatter is a good example of a 3rd party wallet out there. They have established them-self as one of the trusted wallet solution through out the EOS community. Interestingly they already have an existing API for you to integrate with your applications. Ok we are done with all the front end code. If you have reached to this point, give yourself a big pat on the back for following through. I believe we have completed a bare minimum front end for any EOS smart contract. All the work you will be doing in the future will most probably be built upon this base. I have posted this project files on GitHub: . Now will be a good time for you to compare your code and mine to make sure everything is the same before we continue. https://github.com/shankqr/eos-login Run our Code Go ahead, get into our project directory and run the code: npm run serve Follow the link on your browser: , your screen should look like this: http://localhost:8080/ Enter the details Enter your account name along with the private key that you have created previously on the Testnet. Click on Login. Dapp main page If you have entered everything properly you will be directed to our Home page after a few seconds. Congratulations! you have just built your first Dapp. Before we end this series, let us just check to see if our smart contract have registered this login into our users table. As you can see the return that your record has been added to the users table. Now let’s test to see if the reward_points is incremented if we login again. Refresh your browser and try to login again. After login, let’s check again: Fantastic! Our smart contract is doing what it was programmed to do. Don’t you just love the Blockchain, it is just so reliable. Summary You have learned how to: Create an empty Vue project Add a Vue plugin Install the EOS official javascript library Write an EOS smart contract that can store data in tables Connect a front end to EOS I hope you enjoyed this guide, please leave your comments bellow. I am thinking about writing on Scatter wallet integration next. I would love to hear your thoughts. Follow me on LinkedIn!

How to build a simple Front End for your EOS smart contract

After 4 year of waiting we had another World Cup full of surprises and once again I decided to do a football pool, or quiniela as called in Latin America, to scam all my friends… I mean to learn more. My first experience was on 2014 using PHP and Yii to create it but this time I wanted to learn something new and fresh. I want to share my experience with Node and the solution I reached. Note: This article is about my experience creating one of my first apps with Node and in no way an actual guide for beginners. If you are new to Node there are several guides you find that will help you more, including the official guide . Of course I’m always eager to help in any way I can. Why Node? I’ve been using Python for web development for the last years and every time I’m searching for news they are all talking about Node, so I decided to join the cool kid’s club and try it. Me Rules Before starting I needed to set the rules for this year. I don’ think these are the standard rules but on my experience are extremely fun (specially on the last matches when a point or two can make you win): All the users must enter the prediction of a match before starts. If the prediction of a score is an exact match of the final result he earns 3 points. If is not an exact match but have the same winner then he earns 1 point. Example: if user A goes with 3–0 and the actual score is 2–1 then the user gets 1 one point. If the match is a tie and the user also predicts a tie he will earn 1 point. Example: if user B goes 3–3 and the score is 1–1 then the user gets 1 point. The winner is the user with the most points. Structure (You can get the complete code ) here The first thing I needed to do was finding an structure that was easy to understand but at the same time scalable. Finally I decided to use an structure somewhat similar to which I’m more familiar with (baby steps!). Flask blueprints api/|-- config.js|-- controllers|   |-- database.js|   `-- positions.js|-- matches|   |-- index.js|   `-- matches.js|-- teams|   |-- index.js|   `-- teams.js`-- users|-- index.js`-- users.js This structure groups the functionality of each main feature of the API and views in a directory. Since this is a small project I used only an index file to expose the router and a single file to store the endpoints. The config file contains the variables used to change the behavior of the app and stores other configuration like for example the id for Oauth A brief description of each component in the api directory: Teams To display the info of all the teams or just a single team by id. Users Calculate the total points of each user and update the prediction of each user before a match. Matches Contains controllers to view the result of matches, update results, get next match or n last matches. Controllers Functions used by any of the other components. Mainly used to handle the connection to the database and queries. Speaking of that… Database My second problem was to find a way to store the information of the teams, predictions, dates and results. Although most of the guides I found recommended a different approach (like non relational databases) I opted to use Postgres mainly because that’s what I usually do and didn’t want to add more difficulty as I was on a tight dead line with the first match starting on a couple days (procrastination, hooray!). The database is simple and contains only four tables: Matches: stores the date and final results of each match. Teams: the name of each team. Predictions: the score predicted by each user. Users: a name used to identify each user and an email for login purposes. The API Routing To create the API I used and its powerful component. With it I can separate the routes the same way I created the structure and use the router to create the endpoint in each module: Express router // An example of matches.js inside api/matches// obtain routerconst express = require('express'),router = express.Router()... // example of an endpoint.router.get("/all", (req, res) => {console.log("obtain all matches");// do stuff}) And in the server.js file I import all routes from the other modules: // require express and import the routes in the api directoryconst express = require('express');matches = require('./api/matches'),teams = require('./api/teams'),users = require('./api/users'),... // register the routes in the appapp.use('/teams',teams).use('/matches', matches).use('/users', users)... // other routes Postgres To manage the database session and the queries I used . With this library you can obtain the database url from the environment (safer and used in some places like Heroku): Node-postgres const { DATABASE_URL } = process.env;var pool = new Pool({connectionString: DATABASE_URL}); Or create the object and pass it to the Pool: var pool = new Pool({user: 'username',host: 'localhost',database: 'database_name',password: 'my_password',port: 5432}); With the connections established you can execute queries like this: // connect pool and query all teams in tablepool.connect().then(client => {return client.query("SELECT * FROM teams").then(data =>{// do stuff with the data...}) With this two components I was able to start coding the endpoints needed for each of the modules and store the data in the database By the way if you think the code for the query is ugly… you are right! I was descending to hell … callback hell But that’s a story for another day If you want to test the app follow the next steps. Requirements node js(obviously) npm postgres a browser or curl to view the responses Installing First clone the project from github: git clone https://github.com/agmezr/quiniela.git The project’s structure: api/: controllers, views and responses assets/: contains the script for the database server.js: the file that configure and starts the server packages json: used to install the needed dependencies Install the dependencies of the project using npm: npm install Run the script in assets/database.sql to create the database: psql <db name | postgres> -f assets/database.sql After installing the dependencies and db, run the server using: node server.js If everything is ok you should see a message like this: Staring app on 8080 Now open your browser (or use curl) and access localhost:8080/index to see an awesome response: {"status":"ok"} If you see that response everything is running. You can play with the other endpoints, for example to view the information of the first team enter to: http://localhost:8080/teams/1 you will see this response: [{"id":1,"name":"Russia","grp":"A"}] Next steps On next articles I want to share my experience with the use of Oauth to login users using a Google account and creating the views to display the data user friendly and finally deploying it on Heroku. Conclusion As one of my fists approaches to Node I want to say it was very pleasant working with it. There are many guides helping the beginners including the official documentation and many more libraries to help you with common task like security, connection to db, etc. Of course there are some things that are hard to understand at first like and the new but nothing a few hours worth of coding can’t fix. Promises ES6 syntax My advice if you want to try Node JS is create something easy and fun like I did and beware of ! callback hell

Creating a football pool as an excuse to learn Node JS

Kudos to (via Unsplash). Fabian Grohs for the pic TL;DR: When adopting serverless, you need to make up your mind who will be on call to troubleshoot and fix functions. If you can’t imagine your developers being on call, then you need to think harder. As I tried to argue in my 2016 O’Reilly book on , when adopting compute, organizations need to consider the operations side of things (also, thanks for whoever coined NoOps, not helping): Serverless Ops serverless There is an operations part around the itself. If you’re using one of the public cloud providers’ offerings—such as , , , or —then chances are you’ll never meet the fine folks who’re running the platform. If you, however, run serverless on your own infra—for example the popular offerings and or up and coming things like Oracle’s or Pivotal’s —then you’ve got at least a chance to know the people who maintain the Kubernetes cluster it’s running on. We will not be talking about this ops aspect in the following. platform AWS Lambda Google Cloud Functions Microsoft Azure Functions IBM Cloud Functions Kubernetes OpenFaaS kubeless fn PFS Then there’s the operations part around the . A function might break, due to a bug in the code itself or due to unexpected load. How about security? Someone needs to be (a) alerted that something went wrong (that is, on call), and (b) in a position to fix it (logs, metrics, tracing, troubleshooting). This is what interests me. app (or function) How do folks who’ve adopted serverless deal with it and how do folks who plan to adopt serverless think they’ll cover this ops task? Now, don’t get me wrong, I’m a big believer in serverless (I wouldn’t have been investing in it myself since ca. 2015 if I thought it wouldn’t fly). I also by and large agree with : Simon Wardley where he says I’m a big fan of containers, despite what people might think. I look at them as invisible subsystems. That’s not where the battle is. The battle is code execution environments, particularly with functional billing. I’ve used various serverless offerings in the cloud (AWS Lambda, Google Functions, and Azure Functions) as well as on top of Kubernetes (like with and kubeless). Heck, I’ve even . I how awesome the UX is. No more thinking about what kind of VM or what container base image. Here’s my code and off we go! OpenFaaS implemented one myself know Nevertheless, and I say that despite the fact that folks are trying to lead the discussion into a (sigh, it’s NOT about serverless vs. containers, see also Simon’s statement, above), one has to come up with a strategy around how to deal with the appops serverless aspect. certain direction Have you? From organizations and individuals I hear essentially two kind of answers: Progressive, forward-looking ones say: “Of course our developers are on call for serverless”, Expedia’s engineering lead Subbu Allamaraju. for example The majority of folks I’ve been talking with at various conferences and user groups, mainly in Europe and USA, say something along the line: “We’re paying our developers to produce code, not to be on call”. Hmmmmm … I’d love to learn your approach here. How are dealing with the app operations part in serverless compute? Who’s on call in your team? you

Serverless: who’s on call now?

The key components in this story: NodeJS, ReactiveSearch, React Native and Auth0 Authentication is an important concern when building apps. A common use case we come across when building apps is in order to accept only authenticated requests, hence preventing misuse. securing our API In this story, I’ll be using a and explain how to create a secure Node/Express API to handle the reate, pdate and elete operations for the app. This will let the app only allow editing of data by authenticated users. For this post we’ll assume that: Todos app built with React Native C U D All users have access to the todos. Read Only an authenticated user has write access for , and the todos. For brevity, we’ll be considering all the authenticated users to have write access. Creating Updating Deleting The key components that I will be using for the app are: a data-driven UI components library for React Native, ReactiveSearch Native , as a middleware server for authenticating the requests and doing write operations to the database , NodeJS/Express, , as a hosted authentication service, Auth0 , as a hosted database service. Appbase.io You can check out a screencast of the app . here Final app preview ReactiveSearch is an open-source React and React Native UI components library for Elasticsearch which I’ve co-authored with . It provides a variety of React Native components that can cluster. ReactiveSearch some awesome people connect to any Elasticsearch In this story I’ll be expanding on another story I wrote on which you may check out if you’re interested in building the starter project which I’ll be using here. How to build a real-time todo app with React Native Getting Started We will use the as a baseline to build our authenticated Todos app. I’ve already setup starter projects which we’ll use both for client and server side. However, before we dive into the code, I’ll talk about a few concepts. Todos app built with appbase.io and ReactiveSearch Native Every Appbase app allows different sets of credentials ( and ) for . read write read and write access control In this post, we will ensure that client side app can only hold the for our appbase app and we’ll extract the logic for operations (for creating, deleting and editing todos) to a Node/Express server. This will allow us to restrict the write access only to authenticated users and also keep the safe. read credentials write write credentials All the todos will have the following structure: { "title": "Writing code", "completed": true, "createdAt": 1518766646430, "name": "divyanshu", "avatar": "https://s.gravatar.com/avatar/33ca46e56260bc7d54b2d7246f9a7052?s=480&r=pg&d=https%3A%2F%2Fcdn.auth0.com%2Favatars%2Fdi.png"} Before we start building the UI, we’ll need a place to store our todos. For brevity, you can use which is hosted on or clone it for yourself by following and clicking on button. This will let you make a copy of the dataset as your own app. my app appbase.io this link Clone this App View my app dataset . You can also clone this to your own app here Authentication Concepts We’re using Auth0 for handling authentication which uses (JSON Web Tokens) as the access tokens. It comprises three parts , and separated by . A JWT looks like: JWT header payload signature dots(.) xxx.yyy.zzz The header(xxx) defines the type of token and the algorithm used for hashing. The payload(yyy) contains information about the user and additional metadata. The signature(zzz) is used to verify the sender of the token and ensure the message was not tampered along the way. You can find a more detailed explanation at the . JWT introduction guide Another popular alternative to using JWT tokens has been managing sessions. However, that introduces statefulness — JWT, being stateless, is a better approach. The access token once verified tells us that the user is authorized to access the API and forms the basis of our system. The authentication flow will look as follows: token based authentication Each request from the React app to the server will include an that will be verified on the server using Express middleware. When we signup or login via Auth0 we’ll receive an (containing user’s profile information)and an (a credential that can be used by a client to access an API). access_token id_token access_token App design We will be using , and create a new client for our tutorial app. We’ll need the and in order to configure auth0 in our app. You can get these from your Auth0 . Auth0 native Client ID Domain dashboard Getting Domain and Client Id for the app We’ll also need to add a callback URL in the section since after authentication the client is redirected back to the callback URL with the info which we’ll later parse for our use. We’ll come to this part later. Allowed Callback URLs token Adding callback URLs for the app Next we’ll need to create a new API for the identifier (a unique string value used for configuring auth0 instance in the app) which we’ll use later to verify the access tokens. audience Getting the audience identifier Diving into the code The final directory structure will look something like this: android                      // android related configsios                          // ios related configscomponents├── RootComponent.js         // Root component for our app├── MainTabNavigator.js      // Tab navigation component├── TodosScreen.js           // Renders the TodosContainer├── Header.js                // Header component├── AddTodo.js               // Add todo input├── AddTodoButton.js         // Add todo floating button├── TodoItem.js              // The todo item├── TodosContainer.js        // Todos main containerapi├── todos.js                 // APIs for performing writesconstants                    // Some constants used in the apptypes                        // Todo type to be used with prop-typesutils                        // Streaming logic goes here Here are the final repositories so you can refer to them at anytime: (i) (React Native App) Todos Auth Client (ii) (Node/Express server) Todos Auth Server 1. Getting the projects ready We are starting with the Todos app code from this and adding an authentication flow to it. You can use the following repositories as starter project files: previous post (i) Todos Native Auth Client starter project (ii) Todos Native Auth Server starter project After you’ve cloned the projects you can switch into the client project directory and test it out: npm installnpm startreact-native run-ios (or)react-native run-android This will start the Todos app (which has the entire logic on client side). Now that everything is up and running, we can start writing the authentication flow code. Note We’re using an ejected create-react-native-app template, hence the reason for using for running the app. This is needed by the package which I’m using here for authentication purposes. react-native react-native-auth0 2. Configuring Auth0 Callbacks Auth0 requires the callbacks for or which you can define in the following manner: ios android {PRODUCT_BUNDLE_IDENTIFIER}://divyanshu.auth0.com/ios/{PRODUCT_BUNDLE_IDENTIFIER}/callback and {YOUR_APP_PACKAGE_NAME}://divyanshu.auth0.com/android/{YOUR_APP_PACKAGE_NAME}/callback You can add these to your application’s callback URL via the Auth0 . dashboard For our case the package name is however you can use your own package name and update the same in android manifest and ios plist files. In the starter files I’ve already added these but if you were to do them by yourself, this is how you may done it : com.todosnative (here you can skip to the next step) You can find the file at AndroidManifest.xml /android/app/src/main/AndroidManifest.xml package="com.auth0sample" For ios, you can update the file at Info.plist /ios/todosnative/Info.plist <key>CFBundleIdentifier</key><string>com.todosnative</string> The dependency for is already present in the starter project. You can run the following command to all the native dependencies: react-native-auth0 link react-native link Next, we can update the file to have a of and add another . The file should look something like: AndroidManifest.xml launchMode singleTask intent-filter <activity    android:name=".MainActivity"    android:label="@string/app_name"    android:launchMode="singleTask"      android:configChanges="keyboard|keyboardHidden|orientation|screenSize"    android:windowSoftInputMode="adjustResize"><intent-filter>    <action android:name="android.intent.action.MAIN" />    <category android:name="android.intent.category.LAUNCHER" /></intent-filter><intent-filter>    <action android:name="android.intent.action.VIEW" />    <category android:name="android.intent.category.DEFAULT" />    <category android:name="android.intent.category.BROWSABLE" />    <data        android:host="YOUR_AUTH0_DOMAIN"        android:pathPrefix="/android/YOUR_APPLICATION_ID/callback"        android:scheme="YOUR_APPLICATION_ID" /></intent-filter></activity> You can substitute the stub values with your own auth0 domain and application id. Next, update the file and add the following: /ios/todosnative/AppDelegate.m #import <React/RCTLinkingManager.h> /* Add the following after @implementation AppDelegate */ - (BOOL)application:(UIApplication *)application openURL:(NSURL *)url  sourceApplication:(NSString *)sourceApplication annotation:(id)annotation{  return [RCTLinkingManager application:application openURL:url                      sourceApplication:sourceApplication annotation:annotation];} Next, we’ll add a in the file: CFBundleURLSchemes Info.plist <key>CFBundleURLTypes</key><array>    <dict>        <key>CFBundleTypeRole</key>        <string>None</string>        <key>CFBundleURLName</key>        <string>auth0</string>        <key>CFBundleURLSchemes</key>        <array>            <string>org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier)</string>        </array>    </dict></array> 3. Handling authentication When you start the app from the starter project, it will look something like the following: Initial version of the app Note that initially you will not be able to add, delete or update the todo items. We’ll add the methods to handle these operations shortly. First lets add the login in . You may add the following in the function of : Button /components/TodosContainer.js render TodosContainer <ScrollView><Buttontitle="Login Button"style={{marginTop: 10,marginBottom: 10}}/>... Next, we’ll create handlers for login and logout in and pass them to the child components for use. I’ve added comments in the starter project to identify where we would need to add code. /components/RootComponent.js For authentication, I’m using . You can use your own Auth0 and here. In the method we’re saving the along with user and in state. The method will remove these from the state. All the handlers and state are passed via to the child components rendered by the component which uses from . It takes these props and makes them available under . react-native-auth0 domain clientId handleLogin accessToken avatar name handleLogout screenProps MainTabNavigator [TabNavigator](https://reactnavigation.org/docs/tab-navigator.html) react-navigation screenProps We’ll use these in : /components/TodosContainer.js Now we’ll be able to login by clicking on the login button and save the access token for use. After adding authentication Login screen after clicking on Login button 4. Passing the screenProps to Update and Delete calls in TodoItem After the authentication happens, I’m saving the , and in the state of . These are made available to the children components via by the in . In the previous step, we already passed the to the component. Next, we’ll update the component to make them pass to the API calls. accessToken avatar name /components/RootComponent screenProps TabNavigator /components/MainTabNavigator.js screenProps TodoItem 5. Handling writes So far, we have just console logged when invoking the , or calls. Next, I’ll be using three endpoints to handle writes on the data: add update delete to create todos POST / to update todos PUT / to delete todos DELETE / Here’s how we can handle these calls on the client side app. We’ll add these to : /api/todos.js One thing you’ll notice here is I’m passing some in the calls. I’m using the access token we received earlier and passing it in all the calls. We’ll use this to verify the requests on the server side. The includes the necessary data for creating, updating or deleting the todos. Also, the calls will not go through if the access token is not present. headers fetch body Now, for the final missing piece, here’s how I’m handling the requests on the server: Here the middleware verifies the access token on each request using the same which we specified on the client side and your specified here as the . If the token is absent or invalid the request will be rejected as unauthorized. Now you can fire up the server in a different terminal and you’ll be able to handle writes for your app securely. 🙂 checkJwt audience domain issuer Useful Links Todos app starter projects for and client side server side Todos app final repos for and client side server side ⭐️ ReactiveSearch GitHub repo ReactiveSearch docs Further Reading Hope you enjoyed this story. You might also like some related stories I’ve written: _A todo app touches on all the important parts of building any data-driven app, including the Create, Read, Update and…_medium.freecodecamp.org How to build a real-time todo app with React Native _Elasticsearch is one of the most popular full-text search engines which allows you to search huge volumes of data…_medium.freecodecamp.org Building a GitHub Repo Explorer with React and Elasticsearch

Securing a React Native App with Server-side Authentication

TL;DR: Linkerd 2 .0 is a composable service sidecar built with the Unix philosophy in mind. That is, it doesn’t aim to do everything and more but (or: because of this?) it’s really good at what it’s doing: instant observability into and troubleshooting of your containerized microservices. In a microservices environment the service owner writes the code as well as increasingly is also responsible for keeping the service(s) they wrote up and running. We call that, very fittingly, . To me, the service ops idea is really a kind of a subset of the moniker I’m subscribing to and advocating for. Now, how does that look like from a practical perspective? service ops appops The cloud native appops maturity model. With the cloud native appops maturity model in mind you start off with ensuring that you have all your code and configuration in a repo (Git, usually, nowadays). Then you want to have all your container images in a secure, private container registry such as , for example. You make sure you have a proper CI/CD pipeline in place, producing said container images in a reproducible manner. Next, you’ll likely be using Kubernetes, the de-factor industry standard for orchestrating containers. Now, once you’re starting to experience pain points when running your containerized microservices, asking yourself question like: Quay How to identify which of the microservices behaves badly? Both HTTP and gRPC services? Which of the service in a call chain is the slowest? What errors do I see on the wire? How do I troubleshoot or optimize a certain request path across a number of microservices? Meet Linkerd 2.0 Linkerd 2.0 helps you at this stage of the evolution. It is built with the Unix philosophy in mind, that is, it focuses on core service mesh responsibilities: system-wide telemetry, , and reliability; here’s what’s in the box: security A self-contained so called design, augmenting services. service sidecar A zero-config installation process and no need to change your app code. Out of the box, preconfigured Grafana dashboards as well as integrated monitoring via Prometheus. Automatic TLS management incl. certificate generation & distribution. A usable Web UI and powerful command line interface (CLI): The Linkerd 2.0 CLI in action, showing service-level communication stats across all namespaces. For the rest, such as policy management, observability, etc., Linkerd 2.0 integrates super smooth with other tools such as Prometheus and Grafana. In fact, for the dashboarding it provides them embedded out of the box: A pre-built Grafana dashboard you get for free from Linkerd 2.0. A demo says more than a 1000 words … In the following I show you a little interaction with Linkerd 2.0, after having completed the in less than 5 minutes. We will with Linkerd 2.0, using the command line tool: setup debug an app consisting of a couple of microservices linkerd _Walkthrough of https://linkerd.io/2/debugging-an-app/_asciinema.org Linkerd 2.0 demo Next steps … Alrighty, where to go from here? Well, I do have some suggestions: You might want to join in the around Linkerd 2.0, today. Leave feedback, suggest a feature or ask for help either in the forum or join the (on the #linkerd2 channel). discussion Linkerd Slack community Try out I’ve put together, it’s accessible via your favourite browser and you’ll learn how to install and use Linkerd 2.0 in less than 10 minutes end to end. Linkerd 2.0 via a Katacoda scenario In my beginning of October, I will use Linkerd 2.0 in one of the hands-on parts. Say Hi if you’re around ;) Velocity NYC talk In conclusion, I will say that Linkerd 2.0 is a super useful tool that comes with a minimal footprint. It assists you, as a service ops, to get your work faster and more effectively done. I am excited about the possibilities here and looking forward to see what the community behind this will deliver on top of what you already get out of it these days. Also, I’m confident that support for things like distributed tracing, , or traffic shaping (think: A/B testing, etc.) are high on the list of things yet to come and can’t wait to see Linkerd 2.0 continue to grow sustainably and healthy. CNCF project layer 7 policy enforcement Great work folks and keep it up!

Linkerd 2.0: service ops for you and me

Data has become an increasingly important factor when it comes to the health of any app or website. Having all of your important numbers such as the number of downloads, amount of money generated from downloads and even the most recent feedback is the key to continued success. Companies who incorporate multiple sources of customer data drastically outperform their competitors and have higher shareholder returns. All of these numbers are able to be measured through mobile analytics. With so many mobile analytics tools on the market it can be quite difficult to choose the best option for you. What Are Mobile Analytical Tools? Mobile analytics tools help to support the analysis of both mobile and web applications and may even compare data from different applications and platforms. Mobile web analytics provides insights on how site visitors using the app via smartphone or tablet experience the app in their browser. App analytics for mobile applications allow developers to examine user interaction with the app and utilize them as a guide to assist with development. The number of downloads as well as retention time/app usage are key metrics for mobile app analytics. If the app monetizes directly then mobile analytics may include hard ROI. Types of Mobile Analytical Tools Some tools are concentrated around marketing, providing data that aids in decision making about audience segmentation or the most effective places to put in-app notifications. A majority of these tools fall into the mobile marketing software sector. Other advertising-focused tools pay close attention to mobile and marketing attribution. Mobile attribution measurement platforms track how users find mobile or web apps and begin using them. Having the ability to identify the attribution source gives companies the ability to measure the success of ad campaigns on different platforms and websites. Some tools are mostly focused on engagement and overlap with the usability and mobile app development sectors. Although many mobile analytical tools mainly monitor and report online, some tools also track mobile web page or app usage as a channel. With so many analytics companies on the market, the main differentiator is companies who provide all-around analytics that include ad intelligence and ASO. The advantage of using these products is that users can track trends in cross-channel activity within a single platform, complete market research, improve app performance and increase revenue. Mobile Analytics Tools – A huge analytical company that covers both mobile and web platforms. They offer comprehensive analytics and a high level of data accuracy. However, if you’re a smaller company this may not be an option as the subscription price starts at around $25,000/year for only one country and category. This is the best option for large developers. App Annie – This tool offers market analytics, ad intelligence and ASO all in one convenient location. This comprehensive tool makes it perfect for companies looking for a range of features. With a full subscription price of $72,000/year and only average ad intelligence quality, this option may not be the best value for money. Apptopia – With market analytics, ad intelligence and ASO in one place, this is another comprehensive option. However, this tool is a much better price than the previous option with a subscription price of about $50,000/year. A much better value for money for larger companies. Sensor Tower – This tool is a mobile ad intelligence and store analytics tool that provides mobile experts with accurate data on mobile apps and in-app advertising. Apptica provides market analytics, ad intelligence and ASO in one convenient location. It has one of the strongest ad intelligence programs with over 7 million ad creatives. This tool also offers custom features by request at a price of only $15,000/year. Probably the best value for money so far. Apptica – As one of the most affordable options, this tool is one of the best options for smaller companies. Although the pricing is much more affordable the ad intelligence is fairly poor. This toll is also mainly focused on market analytics, so companies looking for a comprehensive option may not benefit from this option. Mobile Action – This tool offers ad intelligence at a fairly low cost of $35,000/year; however, it is limited in that it focuses mainly on the Chinese market. Social Peta Choosing the best mobile analytics tools for your app can be a difficult task as a new vendor enters the market daily. Hopefully we could make the decision a little easier with our list of the best mobile analytics tools for 2020.

Top 6 Mobile Analytics Tools of 2020

Kubernetes needs no introduction in this cloud-native world. It was born when I was a middle-aged man. Years later, I am still as young as earlier (take with a pinch of salt) while Kubernetes grew out to be a fine tool that outperformed other platforms in enabling operational efficiency and application resilience. In the past, I wrote on Kubernetes and supported platforms. But then, in the pursuit of appyness, there is no end to innovation. several articles and guides In this article today, I take up another interesting use-case of Devtron as an open-source platform that refactors the Kubernetes ecosystem into an easy-to-use AppOps model. First, a few basics. What Are We Trying to Achieve? Exploring the Devtron platform to validate its capabilities to build, deploy and manage apps on a K8s cluster. What is Devtron? Devtron is an open-source, GUI based platform to deploy and manage Kubernetes applications. The platform allows you to manage an entire application ecosystem through a single control pane that spans across multiple cloud service providers with varying environments. While doing so, efficient collaboration and security sits at its core to naturally enable a DevOps model. Let's get a hands-on. Stage 1: Creating an Amazon EKS Cluster We will start with configuring an AWS EKS cluster (you may also use a GKE or AKS cluster as per your choice). In case you already have a cluster setup, you may skip over to Stage 2. Part One: Installing the AWS CLI To work with AWS on the command line, you need to install the , that enables the creation and management of AWS services from a Linux, macOS, or Windows console. If you’re logged into the AWS console, you can spin up the which comes preinstalled with the AWS CLI. AWS CLI AWS CloudShell, To install AWS CLI on Linux, log into your Linux operating system and access the console. Fetch the latest AWS CLI version for platform. Linux-x86(64-bit) $ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" The URL above is different for the ARM platform-based Linux. More details can be found . Quick Tip: here 2. Unzip the fetched zip file. $ unzip awscliv2.zip 3. Run the with admin privileges. install script $ sudo ./aws/install 4. Finally, validate the version of the AWS CLI installed. $ aws --version Output of the command above shows the current version of the AWS CLI installed. Once confirmed, we are ready to proceed with the next steps. Part Two: Installing the eksctl command-line tool. To create the Amazon EKS Cluster from the command line, install the command-line tool on the Linux operating system. Note that this is also possible on macOS and Windows. The following commands will cover how to install the tool on 64-bit Linux. eksctl Fetch the latest version of . eksctl $ curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp 2. Move the extracted files to . /usr/local/bin $ sudo mv /tmp/eksctl /usr/local/bin 3. Then confirm your In my case, it was and might be different for you. eksctl version. 0.40.0 $ eksctl version 0.40 .0 Part Three: Deploy an EKS Cluster with Active Nodes. The next step is to deploy an Amazon EKS cluster. To do so, use the command, that sets up all the required resources. create cluster $ eksctl create cluster \ - -name devtron-darwin-cluster \ - -region us-east-2 \ - -nodegroup-name devtron-darwin-nodegroup \ - -node-type t2.micro \ - -nodes 4 \ - -nodes-min 1 \ - -nodes-max 5 \ - -managed The command above creates an with  - EKS Cluster a given , name region, nodegroup-name, node-type, nodes, and of the node group, minimum nodes maximum nodes and then deploys the cluster on a type. managed node group You may also change the values of the above to those as desired for your environment. 2. When the command execution completes, you should have your EKS cluster ready with a similar message as shown below. Don’t worry about the message , that is what we will install in the next part. “kubectl not found” You can then confirm your created EKS cluster and node configuration on the AWS portal as shown below. Part Four: Installing kubectl To work with our new EKS cluster, we need to install an open-source command-line tool used to interact with Kubernetes clusters. kubectl, Fetch the tool for Kubernetes version 1.18. Note that there are different links available for lower or higher versions, however, to use Devtron, version 1.18 or above is recommended. kubectl $ curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/a md64/kubectl 2. Change the permissions to allow execution on the binary fetched. kubectl $ chmod +x ./kubectl 3. Copy the binary in the current path to your home directory. $ mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin 4. Check the version of installed to confirm the installation has been successful and as intended. kubectl $ kubectl version --short --client Client Version: v1.18.9-eks-d1db3c 5. Next, you should be able to run the command below to see your active Kubernetes cluster. $ kubectl get service NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.100 .0 .1 <none> 443 /TCP 33 d Stage 2: Installing Devtron Installing Devtron is supported through three ways, installation using , Helm 2, or Helm 3. kubectl For the purpose of this article, we shall cover installing Devtron using with that use to store build cache and logs. Helm 3 default configurations Minio Start by changing the Kubernetes context to the EKS cluster that you want to use, change the and values to those specific to your environment. region cluster name $ aws eks --region us-east-2 update-kubeconfig --name darwin-devtron-cluster02 2. Create a to use for Devtron using as the name. namespace devtroncd $ kubectl create namespace devtroncd 3. Fetch Helm 3 from the official helm repo using the curl command. $ curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 4. Change the permissions on the to allow . helm script execution $ chmod 700 get_helm.sh 5. Execute the helm script. $ ./get_helm.sh For Helm to install, you need the OpenSSL library on your Linux operating system. For this article, we are using a RedHat-based Linux operating system so we will use the package manager to install OpenSSL. Quick Tip: yum $ sudo yum -y install openssl 6. To confirm the Helm installation, type the command below to receive the output as shown. $ helm version WARNING: Kubernetes configuration file is group-readable. This is insecure. Location: /home/cloudshell-user/.kube/config WARNING: Kubernetes configuration file is world-readable. This is insecure. Location: /home/cloudshell-user/.kube/config version.BuildInfo{Version:"v3.5.3", GitCommit:"041ce5a2c17a58be0fcd5f5e16fb3e7e95fea622", GitTreeState:"dirty", GoVersion: "go1.15.8" } 7. After installing Helm, add the Devtron Helm chart repo that uses the Helm installation method. ( : https://docs.devtron.ai/) Source $ helm repo add devtron https://helm.devtron.ai 8. Next, use the command below to navigate to the Devtron installation directory, set the for Devtron, the for PostgreSQL, and start installing Devtron. ( : https://docs.devtron.ai/) namespace password Source $ helm install devtron devtron/devtron-operator --namespace devtroncd --set secrets.POSTGRESQL_PASSWORD=new-password-here 9. To monitor the Devtron installation’s progress, access the pods within the namespace and take note of the that begins with devtroncd pod inception-849d647c4d. $ kubectl get pod -n devtroncd 10. Type the command below to monitor the that show the installation progress. logs $ kubectl logs -f inception-849d647c4d-ldncs -n devtroncd The installation takes about 15 to 30 minutes to complete. When that is done, use the following command to verify that the installation has been completed successfully. The command should echo a result onto the console. Applied $ kubectl -n devtroncd get installers installer-devtron -o jsonpath='{.status.sync.status}' Applied[cloudshell-user@ip-10-0-XX-XX ~]$ 11. You can also verify the running pods in the namespace by typing the command shown below. devtroncd $ kubectl get pods -n devtroncd The command output above shows us the running pods within the namespace. devtroncd 12. Before we can access the dashboard, obtain the that was created during the Devtron installation process. Use the command below to get the password. admin password $ kubectl -n devtroncd get secret devtron-secret -o jsonpath='{.data.ACD_PASSWORD}' | base64 -d

argocd-server-59XXXXX-XXXX[cloudshell-user@ip-10-0-XX-XX ~]$ 13. After that, type a command that gets all the within the namespace and choose the , which has a that you can paste into your browser. services devtroncd load balancer service public address $ kubectl get svc -n devtroncd devtron-grafana ClusterIP 10.100 .159 .169 devtron-kubernetes-external-secrets ClusterIP 10.100 .171 .60 devtron-minio ClusterIP 10.100 .230 .236 devtron-minio-svc ClusterIP None devtron-nats ClusterIP 10.100 .195 .145 devtron-nats-mgmt ClusterIP None devtron-service LoadBalancer 10.100 .204 .202 a4777dd57858a4dc59afb0a4517b1748-XXXXXXXXXX.us-east-2.elb.amazonaws.com PS: Dashboard URL above is edited for security purposes. 14. Paste the URL of the in a browser, which then loads up the Devtron dashboard. The next step is to insert the username “ ” and the password that was provided. load balancer admin To access the password that was automatically generated for the default admin user account, type the below command into your console. Quick Tip: $ kubectl -n devtroncd get secret devtron-secret -o jsonpath='{.data.ACD_PASSWORD}' | base64 -d That’s it, you have successfully installed Devtron on your Amazon EKS cluster and accessed the dashboard. You are now ready to start creating applications using Devtron. Quick Tip: Once you are through with the Devtron dashboard setup, you can also enable Single Sign-On for the Devtron dashboard using third-party Identity providers. To do so, you need to access the Devtron page and then apply settings under the tab. Global Configurations SSO Login Services Stage 3: Deploying an Application using Devtron The following steps will cover how to deploy an application using Devtron. To get started, we need to set up a few prerequisites for successful deployment. Part One: Setting the Host URL In the Devtron dashboard, click on the button at the bottom left and select the option Global Configurations Host URL. 2. Update the URL with that of the Devtron Service Load Balancer. You can use a custom domain within AWS Route 53 that points to the Devtron service load balancer to avoid using the long URL. Quick Tip: Part Two: Adding a GitOps account For successful Continuous Integration and Continuous Deployment (CI/CD) using Devtron, the tool needs to access a that holds different parameters and configurations (Helm charts) for your Devtron applications. A repository will be automatically created once CI is initiated, as we shall see in the following steps. GitOps account To add a GitOps account, click on the GitOps tab on the left of your global configurations screen and add the Github organization and access credentials. Add the the name, and then click . Git Host, Github organization Git access credentials, Save Part Three: Adding a Git Account After adding a GitOps account, the next step is adding a Git account. Click on Name to your Git provider, set the the Git , , and then click . add git account, URL, Authentication type, Username Password Save Part Three: Adding a Docker Registry The next step is adding a docker registry that we shall use to build, push, and pull our images to the designated Docker Repo using the Devtron CI/CD pipeline. Click set the , the (in our case its ECR), add the , the the , and then click . Add docker registry, Registry name Registry type Registry URL AWS region, Amazon IAM role access Id, Secret access key Save Part Four: Adding a New App On the Devtron dashboard, click on the tab; this will bring up a display with a button at the top right of the screen, click on the button. Applications Add New App 2. The next step is to give the Application a , select the for the Application, and set the Applications . In this demo, we are using a Blank App template. Name Project Template You can create multiple projects and groups for your applications across different projects. This enables ease of management of deployments. To create new projects, access the projects tab under the global configuration menu. Quick Tip: 3. After clicking a new screen will add the and In this demo, we are using the Github public provider, add the Git repo URL for our application, set the checkout path to its defaults, and click . Create App, Git Provider, Git Repo URL, Checkout Path. Save 4. Next, the Git Materials configuration will appear, where you are ready to move on to the step. Click Next at the bottom right of the screen, which takes you to the page. next Docker Build Configuration 5. Set the Dockerfile’s for the application, select the set the click and then click . Relative Path Container Registry, Docker Repository, Save Configuration, Next 6. The next page allows us to set the parameters. For this demo, we shall leave all the settings with their defaults and click . Deployment Template Save 7. Once you click , you should see the Devtron Application’s Helm chart repo automatically created in the Github organization specified. Then, click to proceed to the workflow editor page. Save Next Stage 4: Triggering Continuous Integration & Delivery (CI/CD) In this section, we will build and deploy our containerized application to a Kubernetes cluster using Devtron. Part One: Triggering Continuous Integration To enable Continuous Integration, we need to add a new workflow to our application. Click add a give the workflow a and click . New Workflow , Name Save 2. Once that is done, click to start setting up Continuous Integration. Add CI Pipeline Then, select the option to that contains the Dockerfile. Continuous Integration build a docker image from the Git repo 3. Next, assign the CI pipeline a , set the Git to build the image, click and leave the other settings with their defaults for demo purposes. name branch name create pipeline You may select the pipeline execution method in a situation where you want to maintain complete control over the builds and deployments of your workload. Quick Tip: Manual 4. After creating the pipeline, click the button and then select the option. + Deploy to Environment 5. Next, assign the to the deployment pipeline, click and leave other settings with their defaults unless required specifically. Name Create pipeline, You can select , , or deployment strategies for your applications within the deployment pipeline and can change any time with just a single click. Quick Tip: Rolling Canary Blue-green After setting the configurations, the new should appear as shown below. Workflow 6. Next,  click on the tab, and select the step button to initiate the Continuous Integration pipeline. Trigger build material 7. Once you a popup shows a list of previous commits to build the application from. Select Material, 8. Select the commit and click . You can also monitor progress by selecting the tab and select the section. Start Build Build History Logs The screenshot displays the build logs, the build and push process of the container image, and the container registry. Part Two: Triggering Continuous Deployment The final step is to deploy the application to the EKS cluster using the deployment pipeline step. Select the tab to view your available workflows. Click on the deploy step to trigger the deployment using the deployment strategy that we defined, and the pipeline will display as . Trigger Select Image Progressing 2. To confirm that the deployment is done, click on the tab, and select your environment. Deployment Metrics And we are done! The Devtron platform is now all setup with your workload. Below I have also captured a few troubleshooting steps in case you face any of the issues. Stage 5: Troubleshooting Typical Setup and Deployment Issues Re-installation of Devtron freezes or returns errors. Issue 1: If an earlier Installation of Devtron failed on the cluster, you might receive errors in case you try to re-install Devtron. Make sure to look at the errors that are being thrown from the pod. You can quickly check the logs using the command below. inception $ kubectl logs -f inception-d95bc9478-7blw6 -n devtroncd 2. Change the name of the pod to that of your environment. The command below also produces similar output on any cluster. inception $ pod=$(kubectl -n devtroncd get po -l app=inception -o jsonpath='{.items[0].metadata.name}')&& kubectl -n devtroncd logs -f $pod 3. Then run the following commands to clean up the previous installations. $ cd devtron-installation-script/ $ kubectl delete -n devtroncd -f yamls/ $ kubectl delete -n devtroncd -f charts/devtron/templates/devtron-installer.yaml $ kubectl delete -n devtroncd -f charts/devtron/templates/install.yaml $ kubectl delete -n devtroncd -f charts/devtron/crds $ kubectl delete ns devtroncd 4. Additionally, you can also run the command below to make sure that all components of the past installation are removed. $ cd devtron-installation-script/ $ kubectl delete -n devtroncd -f yamls/ $ kubectl -n devtroncd patch installer installer-devtron --type json -p '[{"op": "remove", "path": "/status"}]' Initial Devtron Application build error using CI pipeline. Issue 2: You may get a build error as shown in the screenshot below just after logging in to the Devtron dashboard while creating your first application, and then triggering Continuous Integration. This may also occur when the previous installation was set to and cache logs initially set to AWS S3 storage and then later changed to the Store Build default storage configuration. To resolve the issue, run the commands below to upgrade your Devtron installation. $ helm repo update $ helm upgrade devtron devtron/devtron-operator -n devtroncd 2. Then, monitor the status of the upgrade and confirm completion by running the command below. $ kubectl -n devtroncd get installers installer-devtron -o jsonpath='{.status.sync.status}' Devtron fails to connect to Github for GitOps Issue 3: Often, this might not be a Devtron issue, but the Github API’s connection might be broken. The solution to this is to make sure that you can call Github to get your organization’s repository. The screenshot below shows a failed call. The screenshot below shows a successful API call to the organization’s (Brollyca) repo. Additionally, you can monitor the logs for all your Git operations by checking the activity within the pod that runs all the Git operations. git-sensor $ kubectl logs -f git-sensor-0 -n devtroncd Verdict? Straightforward and simple! The concept of an AppOps model has been in theory since a long time. Several other platforms including GitLab, Azure DevOps, Harness, etc. tried this in the past but had their own set of limitations to be considered for a wider adoption. It is interesting to note that Devtron has held the bull by its horn by making itself platform agnostic, where collaboration is the key. In a set of forthcoming articles, I wish to dig deeper on Devtron’s claimed features which aren’t covered in this article, such as - scanning Docker images for vulnerabilities, writing config maps, storing application secrets, and defining an application deployment strategy. I am sure the platform has much in store to explore, make use of and review. Till then, happy coding with masks on. 😷

AppOps with Kubernetes and Devtron: The Perfect Fit

So, recently the “do-something-to-earn” concept has been becoming more and more popular in the crypto world.  And not the crypto world only… Today we will go over a few trending projects that have been on the surface of the “do-something-to-earn” space. So. It all started with NFT games back in 2018. “Play-to-earn” The biggest play-to-earn game so far was Axie Infinity launched in March 2018, where users need to pay money to play. The Axie Infinity app was never available on the App Store or Play Market. However, this type of play-to-earn has deflated in value due to huge in-game inflation as you can see from the chart. It had its time in the limelight in November 2021 when the Axie token reached 500x of its original value, and like all things that catch on fire pretty fast, well, they lose their flame just as quickly - easy come, easy go. Move-to-earn The next stage in the “do-something-to-earn” space has become STEPN with its new “move-to-earn” concept launched in December  2021 where users also need to pay money to earn. This project has racked in and became just as popular as the “play-to-earn” Axie Infinity game at its peak of popularity. STEPN is a web 3.0 social-fi and game-fi project. STEPN is fantastic since it encourages people to live a healthier life by earning money while they walk, jog, or run outside. Its market cap is at $859,915,299 which looks very promising considering the project was released less than a year ago. ** ** They have wild things coming up in their roadmap and this could act as a catalyst for people like me to get up and move a little. STEPN is available on App Store and Play Market. Next big thing. ‘Watch-to-earn’ The new short-video “watch-to-earn” lit.it app has become #1 most sticky users app according to apptopia.com - . more sticky than TikTok Since the lit.it app was released on App Store & Google Play in April 2022, it has attracted over 25,000 users from 70+ different countries with an average user growth rate of 13% per day. On lit.it users don’t need to pay any money to earn LITIT tokens. So where does the token value come from - you might wonder. Content and community have value, and the more people join lit.it, the more creators get rewarded and at the same time the value of the tokens users have earned through concept will continue to increase. ‘social mining’ The platform has just launched and now is the best time to join! The lit.it app is available on . App Store & Play Market

THE APPTOPUS

theapptopus.com

-- employees

Since n.d.

COMPANY RANKING

THE APPTOPUS

EVERGREEN INDEX #10410

Representing this company? Click here to claim and customize this page!

The Apptopus WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

THE APPTOPUS

theapptopus.com

-- employees

Since n.d.

COMPANY RANKING

THE APPTOPUS

EVERGREEN INDEX #10410

RELATED COMPANIESRANK

STORIES ABOUT THE APPTOPUS

Representing this company? Click here to claim and customize this page!

The Apptopus WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!