Asked  6 Months ago    Answers:  5   Viewed   29 times

I see a lot of google-app-engine questions from users mixing up the standard environment with the flexible environment, especially when it comes to documentation, often attempting to follow the wrong instructions, obviously with undesired results.

How can one easily tell which GAE environment a certain page is applicable to?

 Answers

40

Most (if not all) of the GAE documentation is structured by the environment. When looking at a certain documentation page the environment is clearly indicated in several places:

  • the second section at the top of the left-side documentation navigation bar
  • the navigation trail at the top of the actual documentation page (which may vary slightly depending on the programming language)
  • the docs/flexible vs docs/standard strings in the doc page URLs
  • some pages applicable to multiple programming languages and/or environments (maybe with small differences) have tabs indicating:
    • the currently selected language and environment
    • the other languages and environments the page applies to (selectable)
    • the languages and environments the page doesn't apply to (grayed out)

Examples:

enter image description here enter image description here enter image description here enter image description here

If the documentation page doesn't show the above mentioned patterns (for example if it's a page about some other Google Cloud product somehow related to the App Engine), then check about the App Engine feature being discussed and try to locate the respective GAE documentation.

What may also help with the distinction would be to check these guides putting the 2 environments and/or their features side by side:

  • Choosing an App Engine Environment
  • App Engine Flexible Environment for Users of App Engine Standard Environment
  • Migrating Services from the Standard Environment to the Flexible Environment

Note: when multiple language versions are listed/mentioned under the standard environment (excepting Node.js) they refer to the 1st and 2nd generation standard environment, significantly different from each-other. You should also check the comparison and/or migration guides for these cases:

  • Understanding differences between Python 2 and Python 3 on the App Engine standard environment
  • Migrating from Java 7 to Java 8 Runtime
  • Migrating Your App from PHP 5.5 to PHP 7.2
  • Migrating your App Engine app from Go 1.9 to Go 1.11
Tuesday, June 1, 2021
 
nasty
answered 6 Months ago
26

The safe/blanket answer would be no as the flex env docker image would need to be updated regardless of how tiny the changes are, see How can I speed up Rails Docker deployments on Google Cloud Platform?

However, there might be something to try (YMMV).

From App Engine Flexible Environment:

  • You always have root access to Compute Engine VM instances. SSH access to VM instances in the flexible environment is disabled by default. If you choose, you can enable root access to your app's VM instances.

So you might be able to login as root on your GAE instance VM and try to manually modify a particular app artifact. Of course, you'd need to locate the artifact first.

Some artifacts might not even be present in the VM image itself (those used exclusively by the GAE infra, queue definitions, for example). But it should be possible to update these artifacts without updating the docker image, since they aren't part of the flex env service itself.

Other artifacts might be read-only and it might not be possible to change them to read-write.

Even if possible, such manual changes would be volatile, they would not survive an instance reload (which would be using the unmodified docker image), which might be required for some changes to take effect.

Lots of "might"s, lots of risks (manual fiddling with the app code could negatively impact its functionality), up to you to determine if a try is really worthy.

Update: it seems this is actually documented and supported, see Accessing Google App Engine Python App code in production

Saturday, August 28, 2021
 
Brian
answered 3 Months ago
90

This is what I am doing:

enum WatchModel {
    case w38, w40, w42, w44, unknown
}

extension WKInterfaceDevice {

    static var currentWatchModel: WatchModel {
        switch WKInterfaceDevice.current().screenBounds.size {
        case CGSize(width: 136, height: 170):
            return .w38
        case CGSize(width: 162, height: 197):
            return .w40
        case CGSize(width: 156, height: 195):
            return .w42
        case CGSize(width: 184, height: 224):
            return .w44
        default:
            return .unknown
    }
  }
}
Wednesday, September 8, 2021
 
ShadowZzz
answered 3 Months ago
29

There is no way to use shared (fractional) CPUs on App Engine Flexible at the moment; The number of CPUs you specify must be an even number between 2 and 96. (If it's not the default value of 1)

There is an open feature request for shared CPU instances on the Public Issue Tracker which you can star or add to in order to show your interest in that feature.

Note that there is also no existing feature that lets you directly specify App Engine Standard instance classes or Compute Engine machine types to use in App Engine Flexible.

Friday, November 5, 2021
 
Kev
answered 3 Weeks ago
Kev
83

Is there any way to detect if the user is in the process of installing app X?

The closest you'll get to this is by using a NotificationListenerService.

From the docs:

A service that receives calls from the system when new notifications are posted or removed.

But considering this Service was recently added in API level 18 and your use case, you might consider using a BroadcastReceiver and listening for when android.intent.action.PACKAGE_ADDED and android.intent.action.PACKAGE_REMOVED are called. This way once an app is installed or removed, you can do what you want with the package name, like provide a link to the Play Store.

Here's an example:

BroadcastReceiver

public class PackageChangeReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent == null || intent.getData() == null) {
            return;
        }

        final String packageName = intent.getData().getSchemeSpecificPart();
        // Do something with the package name
    }

}

In your AndroidManifest

<receiver android:name="your_path_to.PackageChangeReceiver" >
    <intent-filter>
        <action android:name="android.intent.action.PACKAGE_ADDED" />
        <action android:name="android.intent.action.PACKAGE_REMOVED" />

        <data android:scheme="package" />
    </intent-filter>
</receiver>
Thursday, November 11, 2021
 
RenegadeAndy
answered 3 Weeks ago
Only authorized users can answer the question. Please sign in first, or register a free account.
Not the answer you're looking for? Browse other questions tagged :  
Share